Wallet liquidation-risk monitor

// Wallet liquidation-risk monitor: watches the open positions of Hyperliquid wallets and warns when the mark comes
// within a set distance of a position's liquidation price. Node 18+, no dependencies. One GET /wallets/{address} per
// wallet and poll (each answer has the positions with liqPx and the signed distance liqDistance).
//
//   export BLOCKMETRIC_API_KEY=bm_live_...            # optional: without a key it uses keyless public access
//   export BLOCKMETRIC_BASE_URL=https://<domain>/api/v1
//   export WALLETS=0xabc...,0xdef...                   # the wallets to watch (yours, or any tracked wallet)
//   node risk-monitor.mjs
//
// Options: WARN_AT (0.10 = warn within 10 %), DANGER_AT (0.03), POLL_SECONDS (60), ONCE=1 (one check, then exit).
// Distance = (liquidation price - mark) / mark, so -0.08 means the price may fall 8 % before a long is liquidated.

const BASE = (process.env.BLOCKMETRIC_BASE_URL ?? '').replace(/\/+$/, '')
const KEY = process.env.BLOCKMETRIC_API_KEY
if (!BASE) throw new Error('Set BLOCKMETRIC_BASE_URL, e.g. https://<domain>/api/v1')
const WALLETS = (process.env.WALLETS ?? '').split(',').map((a) => a.trim()).filter(Boolean)
if (!WALLETS.length) throw new Error('Set WALLETS=0x...,0x... (Hyperliquid addresses)')
const WARN_AT = Number(process.env.WARN_AT ?? 0.1)
const DANGER_AT = Number(process.env.DANGER_AT ?? 0.03)
const POLL_SECONDS = Number(process.env.POLL_SECONDS ?? 60)
const ONCE = process.env.ONCE === '1'
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))

async function api(path) {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(BASE + path, { headers: KEY ? { Authorization: `Bearer ${KEY}` } : { 'X-Blockmetric-Access': 'public' }, signal: AbortSignal.timeout(30_000) })
    if (res.status === 429 && attempt < 5) {
      await sleep(Number(res.headers.get('Retry-After') ?? 5) * 1000)
      continue
    }
    const body = await res.json()
    return { status: res.status, body }
  }
}

const usd = (n) => (n >= 1e6 ? `$${(n / 1e6).toFixed(2)}M` : `$${(n / 1e3).toFixed(1)}K`)
const px = (p) => p.toLocaleString('en-US', { maximumFractionDigits: p >= 1000 ? 0 : p >= 1 ? 2 : 6 })
const short = (a) => `${a.slice(0, 6)}…${a.slice(-4)}`

/** ok | warn | danger for one position (no liquidation price, e.g. fully collateralised: ok). */
export function level(p) {
  if (typeof p.liqDistance !== 'number') return 'ok'
  const d = Math.abs(p.liqDistance)
  return d <= DANGER_AT ? 'danger' : d <= WARN_AT ? 'warn' : 'ok'
}

const lastLevel = new Map() // wallet:coin -> level, so each change alerts once

async function check() {
  for (const address of WALLETS) {
    const { status, body } = await api(`/wallets/${address}`)
    if (status === 404) {
      console.log(`${short(address)}: not tracked by the API (404). For a wallet of your own, Guard on the site (Alerts > Guard) watches it live.`)
      continue
    }
    if (status !== 200) throw new Error(`${status} ${body.error?.code}: ${body.error?.message}`)
    const { wallet, positions } = body.data
    if (!positions.length) console.log(`${short(address)}: no open positions (account ${usd(wallet.accountValue ?? 0)})`)
    for (const p of positions) {
      const key = `${address}:${p.coin}`
      const now = level(p)
      const dist = typeof p.liqDistance === 'number' ? `${(p.liqDistance * 100).toFixed(1)} %` : 'no liquidation price'
      const text = `${short(address)} ${p.coin} ${p.side} ${usd(p.positionUsd)} ${p.leverage}x: mark ${px(p.mark)}, liquidation ${p.liqPx ? px(p.liqPx) : '-'} (${dist})`
      if (lastLevel.get(key) !== now && now !== 'ok') console.log(`${now === 'danger' ? 'DANGER' : 'WARNING'} ${text}`)
      else if (ONCE || !lastLevel.has(key)) console.log(`ok      ${text}`)
      lastLevel.set(key, now)
    }
  }
}

for (;;) {
  await check()
  if (ONCE) break
  await sleep(POLL_SECONDS * 1000)
}