Verify it yourself

// audit.mjs: re-derive the venue's numbers from its public reads. No key, no signing, nothing is sent: it only reads.
//   node audit.mjs snapshot <wallet> > before.json                       your state, the custody gap and your HyperCore balance, now
//   node audit.mjs fee <qty> <markUSD> <premiumUSD> <feeUSD>               the taker fee is the published formula
//   node audit.mjs fill <fillPriceUSD> <frontPriceUSD> [tolPct]            a close fills within a % of the front you read just before
//   node audit.mjs close-keeps-money before.json after.json <account> <closeCostUSD>
//   node audit.mjs pays-out before.json after.json <account> <residualUSD> <payoutUSD> [new]
//   node audit.mjs custody                                                 the venue's own money check, from /chain/health
import { readFileSync } from "node:fs";

const BASE = process.env.TEMPORAL_BASE ?? "https://protect.temporal.exchange/api/venue";
const get = (p) => fetch(BASE + p).then((r) => r.json());

// The published numbers. Change them only if the docs page changes them: a check in the repo fails when they differ.
const FEE = { bps: 3, capOfPremiumPct: 12.5, floorUSD: 0.25, tolUSD: 0.01 };
const TOL = { cashUSD: 0.01, hypercoreUSD: 0.02, depositUSD: 0.01, closeFillPct: 1, newAddressFeeUSD: 1 };

const rows = [];
const row = (check, pass, expected, observed) => {
  rows.push({ check, pass, expected, observed });
  console.log(`${pass === null ? "NOT EXPOSED" : pass ? "PASS" : "FALSE"}  ${check}\n      expected: ${expected}\n      observed: ${observed}`);
};
const money = (x) => (x == null ? "n/a" : `$${Number(x).toFixed(2)}`);
const [cmd, ...args] = process.argv.slice(2);
const load = (f) => JSON.parse(readFileSync(f, "utf8"));

if (cmd === "snapshot") {
  const wallet = args[0];
  const [state, health, hc] = await Promise.all([get(`/chain/state?wallet=${wallet}`), get("/chain/health"), get(`/hypercore/balance?wallet=${wallet}`)]);
  console.log(JSON.stringify({ at: new Date().toISOString(), state, custody: health.custody ?? null, hypercoreUSD: hc.perpUSD != null ? hc.perpUSD + hc.spotUSD : null }, null, 1));
  process.exit(0);
}

if (cmd === "fee") {
  const [qty, mark, premium, fee] = args.map(Number);
  const byNotional = (qty * mark * FEE.bps) / 1e4;
  const cap = (premium * FEE.capOfPremiumPct) / 100;
  const expected = Math.max(Math.min(byNotional, cap), FEE.floorUSD);
  row("taker fee = max(min(3 bps of notional, 12.5 % of premium), $0.25)", Math.abs(fee - expected) <= FEE.tolUSD, money(expected), `${money(fee)} (notional fee ${money(byNotional)}, premium cap ${money(cap)})`);
}

if (cmd === "fill") {
  const [fill, front, tol = TOL.closeFillPct] = args.map(Number);
  const dev = ((fill - front) / front) * 100;
  row(`the fill is within ${tol} % of the front quoted just before`, Math.abs(dev) <= tol, `within ${tol} %`, `fill ${money(fill)} vs front ${money(front)} (${dev >= 0 ? "+" : ""}${dev.toFixed(3)} %)`);
}

if (cmd === "close-keeps-money" || cmd === "pays-out") {
  const [fb, fa, account, ...rest] = args;
  const b = load(fb), a = load(fa);
  const acct = (s) => Object.values(s.state.accounts).find((x) => String(x.id) === account || x.name === account);
  const [ab, aa] = [acct(b), acct(a)];
  const dCash = a.state.cashUSD - b.state.cashUSD;
  if (cmd === "close-keeps-money") {
    const cost = Number(rest[0]);
    const tot = (x) => x.depositUSD + (x.heldUSD ?? 0);
    const dTot = tot(aa) - tot(ab);
    row("(R3a) free cash unchanged by a single-leg close", Math.abs(dCash) <= TOL.cashUSD, `0 ± ${money(TOL.cashUSD)}`, `${money(b.state.cashUSD)} -> ${money(a.state.cashUSD)}`);
    row("(R3b) deposit + held falls by the close's own cost and its fee, no more", dTot <= -cost + TOL.cashUSD && dTot >= -cost * 1.01 - TOL.cashUSD, `${money(-cost)} to ${money(-cost * 1.01)}`, `${money(tot(ab))} -> ${money(tot(aa))} (change ${money(dTot)})`);
    const dHc = a.hypercoreUSD - b.hypercoreUSD;
    row("(R3c) nothing paid out: your HyperCore total is unchanged", Math.abs(dHc) <= TOL.hypercoreUSD, `0 ± ${money(TOL.hypercoreUSD)}`, `${money(b.hypercoreUSD)} -> ${money(a.hypercoreUSD)}`);
  } else {
    const [residual, payout, isNew] = [Number(rest[0]), Number(rest[1]), rest[2] === "new"];
    const expected = residual - (isNew ? TOL.newAddressFeeUSD : 0);
    const dHc = a.hypercoreUSD - b.hypercoreUSD;
    row("(R4b) payout = residual minus the fee rule ($1 only to an address new to HyperCore)", Math.abs(payout - expected) <= TOL.hypercoreUSD, money(expected), money(payout));
    row("(R4c) your HyperCore wallet rose by the payout", Math.abs(dHc - payout) <= TOL.hypercoreUSD, `${money(payout)} ± ${money(TOL.hypercoreUSD)}`, `${money(b.hypercoreUSD)} -> ${money(a.hypercoreUSD)} (change ${money(dHc)})`);
    row("(R4d) free cash unchanged: the residual passed through and out", Math.abs(dCash) <= TOL.cashUSD, `0 ± ${money(TOL.cashUSD)}`, `${money(b.state.cashUSD)} -> ${money(a.state.cashUSD)}`);
    row("(R4e) the account holds nothing", !aa || aa.depositUSD <= TOL.depositUSD, `deposit <= ${money(TOL.depositUSD)}`, aa ? money(aa.depositUSD) : "the account is gone from the list");
  }
}

if (cmd === "custody") {
  const c = (await get("/chain/health")).custody;
  row("the venue's HyperCore money matches what its ledger attributes", c ? c.ok === true : null, c ? `|gap| <= ${money(c.toleranceUSD)}` : "custody served", c ? `ledger ${money(c.ledgerUSD)}, HyperCore ${money(c.hypercoreUSD)}, gap ${money(c.gapUSD)}` : "not served");
}

const bad = rows.filter((r) => r.pass === false).length;
console.log(`\n${rows.length} row(s): ${rows.filter((r) => r.pass).length} PASS, ${bad} FALSE`);
process.exit(bad ? 1 : 0);