From 62a23f9043601b4175c9a87b9a362a8fe78ab4ef Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Fri, 10 Jul 2026 23:17:02 +0100 Subject: [PATCH 01/33] docs: drop the simple mode promise and make the deployment verifiable --- DEPLOYMENT.md | 50 +++++ README.md | 4 +- packages/arena/Published.toml | 9 + packages/base_vault/Published.toml | 7 +- packages/keeper_rewards/Published.toml | 9 + .../strategies/bullish_upside/Published.toml | 9 + packages/strategies/hedged_plp/Published.toml | 12 +- packages/strategies/plp_collar/Published.toml | 9 + .../strategies/range_ladder/Published.toml | 10 +- packages/strategies/strangle/Published.toml | 9 + services/operator/scripts/pool-book-spike.ts | 187 ++++++++++++++++++ .../operator/scripts/verify-deployment.ts | 78 ++++++++ services/operator/src/deploy.ts | 42 ++++ web/src/components/landing/page.tsx | 2 +- 14 files changed, 419 insertions(+), 18 deletions(-) create mode 100644 DEPLOYMENT.md create mode 100644 packages/arena/Published.toml create mode 100644 packages/keeper_rewards/Published.toml create mode 100644 packages/strategies/bullish_upside/Published.toml create mode 100644 packages/strategies/plp_collar/Published.toml create mode 100644 packages/strategies/strangle/Published.toml create mode 100644 services/operator/scripts/pool-book-spike.ts create mode 100644 services/operator/scripts/verify-deployment.ts diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md new file mode 100644 index 0000000..ff405f9 --- /dev/null +++ b/DEPLOYMENT.md @@ -0,0 +1,50 @@ +# Deployment — Sui testnet + +Every CallIt package, its source, its live on-chain id, and a verifiable transaction. The single +source of truth is [`services/operator/deployment.testnet.json`](./services/operator/deployment.testnet.json) — +every service reads it, each package's `Published.toml` mirrors it, and +`services/operator/scripts/verify-deployment.ts` checks the three never drift. + +Network: **testnet** (chain `4c78adac`). All packages are v1 (never upgraded). +Deployer: `0xceb3702c184db31f6df4dd5dee93125c0f06836ce2dda74931884b8f2f8624e7` · +Operator: `0x606bc9437c6121817264e4ae006495a6c0700b8e04a16f215beb20361a095e44` + +## Packages + +| Package | Source | Package id | Core object | Last activity (proof) | +| --- | --- | --- | --- | --- | +| `base_vault` | [`packages/base_vault`](./packages/base_vault) | [`0x68f736e0…40f819`](https://suiscan.xyz/testnet/object/0x68f736e0f30bf7a4881799a0cf77393f3fe881334703916f8ffc2c755a40f819) | vault [`0x725808c6…c5789a`](https://suiscan.xyz/testnet/object/0x725808c6e223395dabf586de6ac3b9051a9c71c9767353bf51ec43b0d0c5789a) | [`AS4BmD31…`](https://suiscan.xyz/testnet/tx/AS4BmD31FVmDsKEZA5MUevRY37h3fY2QK58M5826EYof) | +| `hedged_plp_strategy` | [`packages/strategies/hedged_plp`](./packages/strategies/hedged_plp) | [`0x1d31f6fc…5a73eb`](https://suiscan.xyz/testnet/object/0x1d31f6fc178655df407c27d431f15a54ff78db4c32cb554d0985c875475a73eb) | strategy [`0x34b006a8…1da8b0`](https://suiscan.xyz/testnet/object/0x34b006a8a45c7fda01964f25a4723e43c257b5e0c96a4ad780f24e96c61da8b0) | [`pVKZxBR8…`](https://suiscan.xyz/testnet/tx/pVKZxBR8Ti2JdLokQvHQ6eGbpi8Fsqi24SYqKTyssJ8) | +| `plp_collar_strategy` | [`packages/strategies/plp_collar`](./packages/strategies/plp_collar) | [`0xbc367940…1a8666`](https://suiscan.xyz/testnet/object/0xbc3679406f6130a881f8e32052135f62e266a28d5bf4cf63f71499eeec1a8666) | strategy [`0x4761f3b8…67d98b`](https://suiscan.xyz/testnet/object/0x4761f3b80dadc1e5b714980ad202db9b6914027f1453145419c0718eb867d98b) | [`AS4BmD31…`](https://suiscan.xyz/testnet/tx/AS4BmD31FVmDsKEZA5MUevRY37h3fY2QK58M5826EYof) | +| `strangle_strategy` | [`packages/strategies/strangle`](./packages/strategies/strangle) | [`0x2629511b…11876c`](https://suiscan.xyz/testnet/object/0x2629511beba0667aa07519dcefbe91346e3fcfef2026b7288a2d069e0211876c) | strategy [`0xc140312a…d4de650`](https://suiscan.xyz/testnet/object/0xc140312aeebe986d9f838219a6f68d4897092f1ab18082f5f2d3e11f5d4de650) | [`7o48BLhe…`](https://suiscan.xyz/testnet/tx/7o48BLhehHPBtxYbC1djbUJUz5fsbMHvp8bxuTLuDRye) | +| `bullish_upside_strategy` | [`packages/strategies/bullish_upside`](./packages/strategies/bullish_upside) | [`0x44124c6f…3e516e`](https://suiscan.xyz/testnet/object/0x44124c6f36ea35bce2e9d07c78fb5fb7bbbe929ef86bfe2022a3deee3a3e516e) | strategy [`0x7bb781a2…cf6be26`](https://suiscan.xyz/testnet/object/0x7bb781a258940ace6f8f4ab2e11ae6bcc994e386dd8870e02d32c52bdcf6be26) | [`7iTBaHyC…`](https://suiscan.xyz/testnet/tx/7iTBaHyCu4XeG9mb8bfsanb4KLrGd8VFsugQQCX9PG51) | +| `range_ladder_strategy` | [`packages/strategies/range_ladder`](./packages/strategies/range_ladder) | [`0x6cf1f7c7…c29503`](https://suiscan.xyz/testnet/object/0x6cf1f7c7240bfabd34b5957184be36538192babde467d7590bad782a56c29503) | strategy [`0x15d70d72…d884ed`](https://suiscan.xyz/testnet/object/0x15d70d726d875dc7d88b900e331a2ba761b16c627e3200bc67733ecb58d884ed) | [`7JGUVNYm…`](https://suiscan.xyz/testnet/tx/7JGUVNYmb15NkRo58XCHc94PuajBd6XJihpB24UfFnTn) | +| `arena` | [`packages/arena`](./packages/arena) | [`0x86f8fd50…bdb0dac`](https://suiscan.xyz/testnet/object/0x86f8fd50525cf8aea274b2559886fd1b4bdf2a6c8d1b353ff053548eabdb0dac) | arena [`0xda927248…df54e92`](https://suiscan.xyz/testnet/object/0xda927248cef779d5af576962f03b0945e3db292b4153b171c4c9ea4e1df54e92) | [`6zJoXfr9…`](https://suiscan.xyz/testnet/tx/6zJoXfr9qx72cEATYbMr2FVjjUvaBepZtiAWDMYK58aZ) | +| `keeper_rewards` | [`packages/keeper_rewards`](./packages/keeper_rewards) | [`0x5377850c…c52b23`](https://suiscan.xyz/testnet/object/0x5377850cbe864c82594f68a59086fbdda2f5d022fd4f6a4d45a520ec30c52b23) | vault [`0xa50e85c8…3b328d`](https://suiscan.xyz/testnet/object/0xa50e85c869c0aa8f49a57eff1d5bf02f1af77548f7be4296bcf201b33b3b328d) | [`AraNH8z5…`](https://suiscan.xyz/testnet/tx/AraNH8z5kiZqAq3GhqGuMguRNzRV6NeaLPY969NxDtdH) | + +## DeepBook Predict targets (Mysten's shared deployment — called, not forked) + +| What | Id | +| --- | --- | +| Predict package | `0xf5ea2b3749c65d6e56507cc35388719aadb28f9cab873696a2f8687f5c785138` | +| Predict object | `0xc8736204d12f0a7277c86388a68bf8a194b0a14c5538ad13f22cbd8e2a38028a` | +| Quote asset | `0xe950…3e1a::dusdc::DUSDC` | + +## Gas sponsorship + +| What | Value | +| --- | --- | +| Sponsor address | `0x4cf935259f70302ea969be91562885dd6bbb84e1725168ad49ee2fa15fdd4953` | +| Accumulator funding tx | [`G9BLbvcJ…`](https://suiscan.xyz/testnet/tx/G9BLbvcJtteZZ2g5jz8dKDdkLPF2FdaoQ71Mhf8H8X3f) | +| First sponsored tx | [`58mBosiB…`](https://suiscan.xyz/testnet/tx/58mBosiBdzteoSfVueMiKavMq156VcVRu9qBEsuhR5oZ) | + +## Verify it yourself + +```bash +# repo metadata == manifest (offline) +cd services/operator && bun scripts/verify-deployment.ts +# …and == chain (needs network) +bun scripts/verify-deployment.ts --chain +# live pool book + our LP share (read-only) +bun scripts/pool-book-spike.ts +``` diff --git a/README.md b/README.md index 598d3d3..8e6adc9 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ CallIt **composes** DeepBook Predict rather than competing with it. Every Arena | Product | What it is | | --- | --- | -| **Trade** | Open and close prediction positions on live markets. Simple (`Yes`/`No`, fixed risk) and Pro (`Up`/`Down`/`Range`, strikes, expiries, live prices) over the same Predict markets. | +| **Trade** | A prediction terminal for live markets: `Up`/`Down`/`Range` positions across strikes and expiries, with live chain-quoted prices. Premium and payout are fixed before you confirm. | | **Arena** | A social layer. A creator posts a public **call** backed by a locked PLP bond; anyone **backs** or **fades** it by opening their own native Predict position. Track records and a leaderboard. | | **Earn** | Supply DUSDC to the PLP pool that takes the other side of every position. Share value moves with the book. | | **Strategies** | Five automated, on-chain-settled vaults that run a set play each round: Tail-Hedge PLP, PLP Collar, Short Strangle, Bullish Upside, and Range Ladder. | @@ -34,6 +34,8 @@ CallIt **composes** DeepBook Predict rather than competing with it. Every Arena Eight Move packages on Sui. The base vault holds capital and runs the queues; each strategy is its own package that deploys into DeepBook Predict per round; the arena and reward vault layer social and incentive logic on top. +Every package's live id and a verifiable transaction are in [`DEPLOYMENT.md`](./DEPLOYMENT.md); `services/operator/scripts/verify-deployment.ts` checks the repo, the manifest, and the chain agree. + | Package | Source | Role | | --- | --- | --- | | `base_vault` | [`packages/base_vault`](./packages/base_vault) | Shared single-asset cash vault. Mints base shares against deposits and runs the asynchronous [deposit](./packages/base_vault/sources/deposit_queue.move) and [withdrawal](./packages/base_vault/sources/withdrawal_queue.move) queues every strategy settles through. | diff --git a/packages/arena/Published.toml b/packages/arena/Published.toml new file mode 100644 index 0000000..f1397c7 --- /dev/null +++ b/packages/arena/Published.toml @@ -0,0 +1,9 @@ +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. +[published.testnet] +chain-id = "4c78adac" +published-at = "0x86f8fd50525cf8aea274b2559886fd1b4bdf2a6c8d1b353ff053548eabdb0dac" +original-id = "0x86f8fd50525cf8aea274b2559886fd1b4bdf2a6c8d1b353ff053548eabdb0dac" +version = 1 +toolchain-version = "1.73.1" +build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/base_vault/Published.toml b/packages/base_vault/Published.toml index 2656eef..7b5e77a 100644 --- a/packages/base_vault/Published.toml +++ b/packages/base_vault/Published.toml @@ -1,8 +1,9 @@ -# Generated from testnet deployment. +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. [published.testnet] chain-id = "4c78adac" -published-at = "0xa90a078564d244eaf9b6563630eafaf1e023e8d6ab8da0b6a9f695d0e8fa4d0f" -original-id = "0xa90a078564d244eaf9b6563630eafaf1e023e8d6ab8da0b6a9f695d0e8fa4d0f" +published-at = "0x68f736e0f30bf7a4881799a0cf77393f3fe881334703916f8ffc2c755a40f819" +original-id = "0x68f736e0f30bf7a4881799a0cf77393f3fe881334703916f8ffc2c755a40f819" version = 1 toolchain-version = "1.73.1" build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/keeper_rewards/Published.toml b/packages/keeper_rewards/Published.toml new file mode 100644 index 0000000..4feec9b --- /dev/null +++ b/packages/keeper_rewards/Published.toml @@ -0,0 +1,9 @@ +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. +[published.testnet] +chain-id = "4c78adac" +published-at = "0x5377850cbe864c82594f68a59086fbdda2f5d022fd4f6a4d45a520ec30c52b23" +original-id = "0x5377850cbe864c82594f68a59086fbdda2f5d022fd4f6a4d45a520ec30c52b23" +version = 1 +toolchain-version = "1.73.1" +build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/strategies/bullish_upside/Published.toml b/packages/strategies/bullish_upside/Published.toml new file mode 100644 index 0000000..a2d010b --- /dev/null +++ b/packages/strategies/bullish_upside/Published.toml @@ -0,0 +1,9 @@ +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. +[published.testnet] +chain-id = "4c78adac" +published-at = "0x44124c6f36ea35bce2e9d07c78fb5fb7bbbe929ef86bfe2022a3deee3a3e516e" +original-id = "0x44124c6f36ea35bce2e9d07c78fb5fb7bbbe929ef86bfe2022a3deee3a3e516e" +version = 1 +toolchain-version = "1.73.1" +build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/strategies/hedged_plp/Published.toml b/packages/strategies/hedged_plp/Published.toml index 47d40be..75d8b4f 100644 --- a/packages/strategies/hedged_plp/Published.toml +++ b/packages/strategies/hedged_plp/Published.toml @@ -1,11 +1,9 @@ -# Generated by Move -# This file contains metadata about published versions of this package in different environments -# This file SHOULD be committed to source control - +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. [published.testnet] chain-id = "4c78adac" -published-at = "0x389a3c825b061bfab289cd61840ac5e3c1e90ca9733957c98afd63be337af945" -original-id = "0x0908bdb483f870637ac1480e7c5c3784606b512256d3da8c040d3a1b4718f16a" -version = 2 +published-at = "0x1d31f6fc178655df407c27d431f15a54ff78db4c32cb554d0985c875475a73eb" +original-id = "0x1d31f6fc178655df407c27d431f15a54ff78db4c32cb554d0985c875475a73eb" +version = 1 toolchain-version = "1.73.1" build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/strategies/plp_collar/Published.toml b/packages/strategies/plp_collar/Published.toml new file mode 100644 index 0000000..152c1ab --- /dev/null +++ b/packages/strategies/plp_collar/Published.toml @@ -0,0 +1,9 @@ +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. +[published.testnet] +chain-id = "4c78adac" +published-at = "0xbc3679406f6130a881f8e32052135f62e266a28d5bf4cf63f71499eeec1a8666" +original-id = "0xbc3679406f6130a881f8e32052135f62e266a28d5bf4cf63f71499eeec1a8666" +version = 1 +toolchain-version = "1.73.1" +build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/strategies/range_ladder/Published.toml b/packages/strategies/range_ladder/Published.toml index b683ffb..7478cd9 100644 --- a/packages/strategies/range_ladder/Published.toml +++ b/packages/strategies/range_ladder/Published.toml @@ -1,11 +1,9 @@ -# Generated by Move -# This file contains metadata about published versions of this package in different environments -# This file SHOULD be committed to source control - +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. [published.testnet] chain-id = "4c78adac" -published-at = "0xe3b3a7f7c5a5c8b925b42787130ba72ac86fa28c577cd2f7f8307f2e8de72e05" -original-id = "0xe3b3a7f7c5a5c8b925b42787130ba72ac86fa28c577cd2f7f8307f2e8de72e05" +published-at = "0x6cf1f7c7240bfabd34b5957184be36538192babde467d7590bad782a56c29503" +original-id = "0x6cf1f7c7240bfabd34b5957184be36538192babde467d7590bad782a56c29503" version = 1 toolchain-version = "1.73.1" build-config = { flavor = "sui", edition = "2024" } diff --git a/packages/strategies/strangle/Published.toml b/packages/strategies/strangle/Published.toml new file mode 100644 index 0000000..8268221 --- /dev/null +++ b/packages/strategies/strangle/Published.toml @@ -0,0 +1,9 @@ +# Generated from the live testnet deployment (services/operator/deployment.testnet.json). +# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts. +[published.testnet] +chain-id = "4c78adac" +published-at = "0x2629511beba0667aa07519dcefbe91346e3fcfef2026b7288a2d069e0211876c" +original-id = "0x2629511beba0667aa07519dcefbe91346e3fcfef2026b7288a2d069e0211876c" +version = 1 +toolchain-version = "1.73.1" +build-config = { flavor = "sui", edition = "2024" } diff --git a/services/operator/scripts/pool-book-spike.ts b/services/operator/scripts/pool-book-spike.ts new file mode 100644 index 0000000..5f14dc4 --- /dev/null +++ b/services/operator/scripts/pool-book-spike.ts @@ -0,0 +1,187 @@ +// Strategy-model Phase 0 spike (plans/strategy-model.md §11 Phase 0). +// +// Proves, against live testnet, every read the model needs: +// 1. Pool aggregates (balance / total_mtm / vault_value / total_max_payout) +// 2. PLP total supply (treasury cap) +// 3. Per-strike pool book q_up/q_dn via the vault's StrikeMatrix tables +// 4. Our hedged_plp strategy's PLP holdings -> our LP share f +// +// Run: cd services/operator && bun scripts/pool-book-spike.ts +import { readFileSync } from "node:fs" +import { SuiGrpcClient } from "@mysten/sui/grpc" + +const GRPC_URL = "https://fullnode.testnet.sui.io:443" +const PREDICT_OBJECT_ID = + "0xc8736204d12f0a7277c86388a68bf8a194b0a14c5538ad13f22cbd8e2a38028a" +const QUOTE = 1_000_000n // 1 DUSDC / 1 contract in quote units +const PRICE = 1_000_000_000n // strike price scale + +const client = new SuiGrpcClient({ baseUrl: GRPC_URL, network: "testnet" }) + +function usd(v: bigint): string { + return `$${(Number(v) / 1e6).toLocaleString(undefined, { maximumFractionDigits: 2 })}` +} +function px(v: bigint): string { + return `$${(Number(v) / 1e9).toLocaleString(undefined, { maximumFractionDigits: 0 })}` +} +function hexFromBcsBytes(bcs: Record): string { + const bytes = Object.keys(bcs) + .map(Number) + .sort((a, b) => a - b) + .map((i) => bcs[i]) + return `0x${bytes.map((b) => b.toString(16).padStart(2, "0")).join("")}` +} + +async function objectJson(objectId: string): Promise> { + const { object } = await client.getObject({ objectId, include: { json: true } }) + return object.json as Record +} + +async function listAllDynamicFields(parentId: string) { + const out: { fieldId: string; nameHex: string }[] = [] + let cursor: string | undefined + do { + const page = await client.listDynamicFields({ parentId, cursor }) + for (const f of page.dynamicFields) { + out.push({ + fieldId: f.fieldId as string, + nameHex: hexFromBcsBytes(f.name?.bcs as unknown as Record), + }) + } + cursor = page.hasNextPage ? (page.cursor as string) : undefined + } while (cursor) + return out +} + +// ── 1. Pool aggregates + PLP supply ────────────────────────────────────────── +const predict = await objectJson(PREDICT_OBJECT_ID) +const vault = predict.vault as Record +const balance = BigInt(vault.balance as string) +const totalMtm = BigInt(vault.total_mtm as string) +const totalMaxPayout = BigInt(vault.total_max_payout as string) +const vaultValue = balance - totalMtm +const treasury = predict.treasury_cap as { total_supply: { value: string } } +const plpSupply = BigInt(treasury.total_supply.value) + +console.log("── pool aggregates ──") +console.log(`balance ${usd(balance)}`) +console.log(`total_mtm ${usd(totalMtm)}`) +console.log(`vault_value ${usd(vaultValue)}`) +console.log(`total_max_payout ${usd(totalMaxPayout)}`) +console.log(`PLP total supply ${(Number(plpSupply) / 1e6).toLocaleString()} shares`) + +// ── 2. Enumerate oracle matrices, dump each book ───────────────────────────── +const matricesTableId = (vault.oracle_matrices as { id: string }).id +const matrixFields = await listAllDynamicFields(matricesTableId) +console.log(`\n── strike matrices (${matrixFields.length} oracles) ──`) + +interface BookRow { + strike: bigint + qUp: bigint + qDn: bigint +} + +async function readMatrix(fieldId: string): Promise<{ + meta: Record + rows: BookRow[] + pageSize: bigint +}> { + const field = await objectJson(fieldId) + const m = field.value as Record + const tick = BigInt(m.tick_size as string) + const minStrike = BigInt(m.min_strike as string) + const mintedMin = BigInt(m.minted_min_strike as string) + const mintedMax = BigInt(m.minted_max_strike as string) + const pagesTableId = (m.pages as { id: string }).id + const pages = await listAllDynamicFields(pagesTableId) + + const rows: BookRow[] = [] + let pageSize = 0n + for (const p of pages) { + const pageField = await objectJson(p.fieldId) + // page key is a u64 (BCS little-endian in nameHex); decode index + const idxBytes = p.nameHex.slice(2).match(/../g) ?? [] + const pageIndex = idxBytes + .map((b, i) => BigInt(parseInt(b, 16)) << BigInt(8 * i)) + .reduce((a, b) => a + b, 0n) + const nodes = pageField.value as Record[] + if (pageSize === 0n) pageSize = BigInt(nodes.length) + nodes.forEach((n, j) => { + const qUp = BigInt(n.q_up) + const qDn = BigInt(n.q_dn) + if (qUp === 0n && qDn === 0n) return + const strike = minStrike + (pageIndex * pageSize + BigInt(j)) * tick + rows.push({ strike, qUp, qDn }) + }) + } + rows.sort((a, b) => (a.strike < b.strike ? -1 : 1)) + return { + meta: { + mtm: m.mtm as string, + range_qty: m.range_qty as string, + tick: tick.toString(), + mintedWindow: `${px(mintedMin)}..${px(mintedMax)}`, + }, + rows, + pageSize, + } +} + +for (const mf of matrixFields) { + const { meta, rows, pageSize } = await readMatrix(mf.fieldId) + console.log(`\noracle ${mf.nameHex.slice(0, 10)}… minted ${meta.mintedWindow} tick ${px(BigInt(meta.tick))} pageSize ${pageSize} range_qty ${meta.range_qty} mtm ${usd(BigInt(meta.mtm))}`) + if (rows.length === 0) { + console.log(" (empty book)") + continue + } + for (const r of rows) { + console.log( + ` K=${px(r.strike).padEnd(10)} q_up=${(Number(r.qUp) / 1e6).toFixed(2).padStart(10)} q_dn=${(Number(r.qDn) / 1e6).toFixed(2).padStart(10)}` + ) + } + const L = (S: bigint) => + rows.reduce( + (acc, r) => acc + (S > r.strike ? r.qUp : 0n) + (S < r.strike ? r.qDn : 0n), + 0n + ) // NOTE: range_qty subtraction omitted in spike display when 0 + const strikes = rows.map((r) => r.strike) + const lo = strikes[0] - PRICE, + hi = strikes[strikes.length - 1] + PRICE + console.log(` L(S<${px(strikes[0])})=${usd(L(lo))} L(S>${px(strikes[strikes.length - 1])})=${usd(L(hi))}`) +} + +// ── 3. Our PLP holdings → f ────────────────────────────────────────────────── +const manifest = JSON.parse( + readFileSync(new URL("../deployment.testnet.json", import.meta.url), "utf8") +) +const strategyId = manifest.hedgedPlp.strategyId as string +const strategy = await objectJson(strategyId) +console.log("\n── hedged_plp strategy object ──") +console.log("top-level fields:", Object.keys(strategy).join(", ")) +// PLP holdings live either at top level or inside active_round — dump candidates +const candidates: [string, unknown][] = [] +const walk = (obj: unknown, path: string) => { + if (obj === null || typeof obj !== "object") return + for (const [k, v] of Object.entries(obj as Record)) { + if (/plp|lp_|shares|supply/i.test(k)) candidates.push([`${path}.${k}`, v]) + if (typeof v === "object") walk(v, `${path}.${k}`) + } +} +walk(strategy, "strategy") +for (const [p, v] of candidates) console.log(` ${p} =`, JSON.stringify(v)?.slice(0, 120)) + +const ourPlpRaw = candidates.find(([p]) => /plp/i.test(p))?.[1] +const ourPlp = + typeof ourPlpRaw === "string" + ? BigInt(ourPlpRaw) + : typeof ourPlpRaw === "object" && ourPlpRaw !== null && "value" in (ourPlpRaw as object) + ? BigInt((ourPlpRaw as { value: string }).value) + : null +if (ourPlp !== null) { + const f = Number(ourPlp) / Number(plpSupply) + console.log(`\nour PLP: ${(Number(ourPlp) / 1e6).toLocaleString()} shares → f = ${(f * 100).toFixed(4)}%`) +} else { + console.log("\n[spike] our PLP holdings not found at an obvious path — inspect dump above") +} + +console.log("\n✅ spike complete") diff --git a/services/operator/scripts/verify-deployment.ts b/services/operator/scripts/verify-deployment.ts new file mode 100644 index 0000000..7fc97c9 --- /dev/null +++ b/services/operator/scripts/verify-deployment.ts @@ -0,0 +1,78 @@ +// Deployment drift guard (plans/tier0-honesty.md §0.2). +// +// Asserts the three id sources never disagree: +// 1. services/operator/deployment.testnet.json (the manifest every service reads) +// 2. packages/*/Published.toml (repo metadata a judge cross-checks) +// 3. --chain: the live objects on testnet (ground truth) +// +// Run: cd services/operator && bun scripts/verify-deployment.ts [--chain] +// Exits non-zero on any mismatch — safe for CI (offline mode) and pre-demo checks. +import { readFileSync } from "node:fs" + +const manifest = JSON.parse( + readFileSync(new URL("../deployment.testnet.json", import.meta.url), "utf8") +) + +const PACKAGES: { name: string; dir: string; packageId: string; coreObjectId: string }[] = [ + { name: "base_vault", dir: "packages/base_vault", packageId: manifest.baseVault.packageId, coreObjectId: manifest.baseVault.vaultId }, + { name: "hedged_plp", dir: "packages/strategies/hedged_plp", packageId: manifest.hedgedPlp.packageId, coreObjectId: manifest.hedgedPlp.strategyId }, + { name: "plp_collar", dir: "packages/strategies/plp_collar", packageId: manifest.plpCollar.packageId, coreObjectId: manifest.plpCollar.strategyId }, + { name: "strangle", dir: "packages/strategies/strangle", packageId: manifest.strangle.packageId, coreObjectId: manifest.strangle.strategyId }, + { name: "bullish_upside", dir: "packages/strategies/bullish_upside", packageId: manifest.bullishUpside.packageId, coreObjectId: manifest.bullishUpside.strategyId }, + { name: "range_ladder", dir: "packages/strategies/range_ladder", packageId: manifest.rangeLadder.packageId, coreObjectId: manifest.rangeLadder.strategyId }, + { name: "arena", dir: "packages/arena", packageId: manifest.arena.packageId, coreObjectId: manifest.arena.arenaId }, + { name: "keeper_rewards", dir: "packages/keeper_rewards", packageId: manifest.keeperRewards.packageId, coreObjectId: manifest.keeperRewards.vaultId }, +] + +let failures = 0 +const fail = (msg: string) => { + failures += 1 + console.error(` ✗ ${msg}`) +} + +// ── 1. manifest vs Published.toml ──────────────────────────────────────────── +console.log("manifest vs Published.toml") +for (const pkg of PACKAGES) { + const tomlPath = new URL(`../../../${pkg.dir}/Published.toml`, import.meta.url) + let toml: string + try { + toml = readFileSync(tomlPath, "utf8") + } catch { + fail(`${pkg.name}: ${pkg.dir}/Published.toml missing`) + continue + } + const publishedAt = toml.match(/published-at\s*=\s*"(0x[0-9a-f]+)"/)?.[1] + const originalId = toml.match(/original-id\s*=\s*"(0x[0-9a-f]+)"/)?.[1] + if (publishedAt !== pkg.packageId) { + fail(`${pkg.name}: Published.toml published-at ${publishedAt} != manifest ${pkg.packageId}`) + } else if (originalId !== pkg.packageId) { + fail(`${pkg.name}: Published.toml original-id ${originalId} != manifest (all packages are v1)`) + } else { + console.log(` ✓ ${pkg.name}`) + } +} + +// ── 2. --chain: manifest vs live objects ───────────────────────────────────── +if (process.argv.includes("--chain")) { + const { SuiGrpcClient } = await import("@mysten/sui/grpc") + const client = new SuiGrpcClient({ + baseUrl: "https://fullnode.testnet.sui.io:443", + network: "testnet", + }) + console.log("manifest vs chain") + for (const pkg of PACKAGES) { + try { + await client.getObject({ objectId: pkg.packageId }) + await client.getObject({ objectId: pkg.coreObjectId }) + console.log(` ✓ ${pkg.name} package + core object live`) + } catch (error) { + fail(`${pkg.name}: chain read failed — ${error instanceof Error ? error.message.slice(0, 80) : String(error)}`) + } + } +} + +if (failures > 0) { + console.error(`\n${failures} mismatch(es). Repo, manifest and chain must agree — see DEPLOYMENT.md.`) + process.exit(1) +} +console.log("\n✅ deployment ids consistent") diff --git a/services/operator/src/deploy.ts b/services/operator/src/deploy.ts index eaeb213..82b32f5 100644 --- a/services/operator/src/deploy.ts +++ b/services/operator/src/deploy.ts @@ -889,6 +889,47 @@ async function fundKeeperRewardVault({ } } +// Chain identifiers per network, as recorded in each package's Published.toml. +const CHAIN_IDS: Partial> = { testnet: TESTNET_CHAIN_ID } + +// Mirror the freshly deployed package ids into every package's Published.toml +// so the repo metadata can never drift from the manifest (verified by +// scripts/verify-deployment.ts and documented in DEPLOYMENT.md). +async function writePublishedTomls(record: DeploymentRecord, network: Network) { + const chainId = CHAIN_IDS[network] + if (!chainId) { + logger.warn({ network }, "no chain id known; skipping Published.toml sync") + return + } + const packagesRoot = path.join(import.meta.dir, "../../../packages") + const entries: { dir: string; packageId: string }[] = [ + { dir: "base_vault", packageId: record.baseVault.packageId }, + { dir: "strategies/hedged_plp", packageId: record.hedgedPlp.packageId }, + { dir: "strategies/plp_collar", packageId: record.plpCollar.packageId }, + { dir: "strategies/strangle", packageId: record.strangle.packageId }, + { dir: "strategies/bullish_upside", packageId: record.bullishUpside.packageId }, + { dir: "strategies/range_ladder", packageId: record.rangeLadder.packageId }, + { dir: "arena", packageId: record.arena.packageId }, + { dir: "keeper_rewards", packageId: record.keeperRewards.packageId }, + ] + for (const entry of entries) { + const contents = [ + "# Generated from the live testnet deployment (services/operator/deployment.testnet.json).", + "# Kept in sync by the deploy flow; verified by services/operator/scripts/verify-deployment.ts.", + `[published.${network}]`, + `chain-id = "${chainId}"`, + `published-at = "${entry.packageId}"`, + `original-id = "${entry.packageId}"`, + "version = 1", + 'toolchain-version = "1.73.1"', + 'build-config = { flavor = "sui", edition = "2024" }', + "", + ].join("\n") + await writeFile(path.join(packagesRoot, entry.dir, "Published.toml"), contents) + } + logger.info({ count: entries.length }, "Published.toml files synced to manifest") +} + // On-chain ids live in deployment..json (the runtime's source of // truth). The generated .env only carries the operator secret, network/RPC, // Predict-protocol pointers, and strategy tuning. @@ -1262,6 +1303,7 @@ async function main() { const envPath = path.join(import.meta.dir, "../.env") await writeFile(deploymentPath, `${JSON.stringify(record, null, 2)}\n`) + await writePublishedTomls(record, network) await writeOperatorEnv(network, operatorSecretKey, envPath) logger.info( diff --git a/web/src/components/landing/page.tsx b/web/src/components/landing/page.tsx index 9b807ff..dccc8a8 100644 --- a/web/src/components/landing/page.tsx +++ b/web/src/components/landing/page.tsx @@ -750,7 +750,7 @@ export function Page({ stats }: { stats: LandingStatsResult }) { Date: Fri, 10 Jul 2026 23:29:26 +0100 Subject: [PATCH 02/33] test(web): prove the displayed fair value matches on-chain pricing --- web/src/lib/market-svi.golden.test.ts | 92 ++++++++++++++++++++++ web/src/lib/market-svi.test.ts | 87 +++++++++++++++++++++ web/src/lib/market-svi.vectors.json | 106 ++++++++++++++++++++++++++ 3 files changed, 285 insertions(+) create mode 100644 web/src/lib/market-svi.golden.test.ts create mode 100644 web/src/lib/market-svi.test.ts create mode 100644 web/src/lib/market-svi.vectors.json diff --git a/web/src/lib/market-svi.golden.test.ts b/web/src/lib/market-svi.golden.test.ts new file mode 100644 index 0000000..17d1b4a --- /dev/null +++ b/web/src/lib/market-svi.golden.test.ts @@ -0,0 +1,92 @@ +import { describe, expect, it } from "vitest" + +import { computeFairUpProbability } from "./market-svi" +import { getOracleState, getPredictOracles } from "@/services/predict-client" +import { quotePredictTradeSafe } from "@/services/predict-quotes" + +// Live golden test (plans/price-proof.md §B): our client fair value must +// reconcile to the CHAIN's own quoted mid within a cent per $1 contract. +// +// chain mid = (mint_cost + redeem_payout) / (2 * quantity) via devInspect +// client fair = computeFairUpProbability(forward, strike, svi) +// +// Gated behind RUN_GOLDEN=1 because it needs testnet (predict-server + gRPC): +// RUN_GOLDEN=1 bunx vitest run src/lib/market-svi.golden.test.ts +const RUN_GOLDEN = process.env.RUN_GOLDEN === "1" + +// One $1 contract in quote units; any funded-or-not address works for devInspect. +const QUANTITY = 1_000_000n +const SENDER = "0xceb3702c184db31f6df4dd5dee93125c0f06836ce2dda74931884b8f2f8624e7" +const PRICE_SCALE = 1_000_000_000 +const TOLERANCE = 0.01 // $0.01 per $1 contract +const MIN_COMPARABLE_STRIKES = 3 +const MONEYNESS_OFFSETS = [-0.02, -0.01, -0.005, 0.005, 0.01, 0.02] + +describe.skipIf(!RUN_GOLDEN)("client fair value vs chain mid (golden)", () => { + it("reconciles within a cent across strikes", async () => { + const oracles = await getPredictOracles() + const nowMs = Date.now() + const active = oracles.filter( + (oracle) => oracle.status === "active" && oracle.expiry > nowMs + ) + expect(active.length, "no active unexpired oracle on testnet").toBeGreaterThan(0) + + let compared = 0 + const failures: string[] = [] + + for (const candidate of active) { + const state = await getOracleState(candidate.oracle_id) + const svi = state.latest_svi + const price = state.latest_price + if (!svi || !price || price.forward <= 0) continue + + const forwardUsd = price.forward / PRICE_SCALE + const tickUsd = candidate.tick_size / PRICE_SCALE + const minStrikeUsd = candidate.min_strike / PRICE_SCALE + + for (const offset of MONEYNESS_OFFSETS) { + const rawStrike = forwardUsd * (1 + offset) + const strikeUsd = Math.max( + minStrikeUsd, + Math.round(rawStrike / tickUsd) * tickUsd + ) + + const fair = computeFairUpProbability({ + forward: forwardUsd, + strike: strikeUsd, + svi, + }) + if (fair === undefined) continue + + const quote = await quotePredictTradeSafe({ + expiryMs: candidate.expiry, + isUp: true, + oracleId: candidate.oracle_id, + quantity: QUANTITY, + strikePriceUsd: strikeUsd, + walletAddress: SENDER, + }) + if (quote.status !== "quoted") continue // saturated / unmintable strike + + const chainMid = + Number(quote.mintCost + quote.redeemPayout) / (2 * Number(QUANTITY)) + const diff = Math.abs(fair - chainMid) + compared += 1 + + if (diff > TOLERANCE) { + failures.push( + `oracle ${candidate.oracle_id.slice(0, 8)} K=$${strikeUsd.toFixed(0)}: fair=${fair.toFixed(4)} mid=${chainMid.toFixed(4)} diff=${diff.toFixed(4)}` + ) + } + } + + if (compared >= MIN_COMPARABLE_STRIKES) break // one good oracle is enough + } + + expect( + compared, + "not enough mintable strikes to compare; testnet may be thin" + ).toBeGreaterThanOrEqual(MIN_COMPARABLE_STRIKES) + expect(failures, failures.join("\n")).toEqual([]) + }, 120_000) +}) diff --git a/web/src/lib/market-svi.test.ts b/web/src/lib/market-svi.test.ts new file mode 100644 index 0000000..c63a7d3 --- /dev/null +++ b/web/src/lib/market-svi.test.ts @@ -0,0 +1,87 @@ +import { describe, expect, it } from "vitest" + +import { computeFairUpProbability } from "./market-svi" +import vectors from "./market-svi.vectors.json" +import type { OracleSviUpdate } from "@/lib/types/predict" + +// Reference vectors for the SVI -> N(d2) fair-value math (plans/price-proof.md §A). +// +// Expected values are computed with Python's float64 math.erf (~1e-16 accurate) +// over the EXACT formula in Predict's oracle.move `compute_nd2`: +// k = ln(strike / forward) +// w = a + b * (rho * (k - m) + sqrt((k - m)^2 + sigma^2)) // total variance +// d2 = -((k + w / 2) / sqrt(w)); UP = N(d2) +// with params decoded from their 1e9 fixed-point on-chain encoding. Our client +// uses an Abramowitz-Stegun 7.1.26 erf (max error ~1.5e-7), so the assertion +// tolerance is 5e-7 in probability. +const TOLERANCE = 5e-7 + +interface ReferenceVector { + label: string + a: number + b: number + rho: number + rho_negative: boolean + m: number + m_negative: boolean + sigma: number + forward: number + strike: number + expected: number +} + +function toSviUpdate(vector: ReferenceVector): OracleSviUpdate { + return { + a: vector.a, + b: vector.b, + checkpoint: 0, + checkpoint_timestamp_ms: 0, + digest: "test", + event_digest: "test", + event_index: 0, + m: vector.m, + m_negative: vector.m_negative, + onchain_timestamp: 0, + oracle_id: "0xtest", + package: "0xtest", + rho: vector.rho, + rho_negative: vector.rho_negative, + sender: "0xtest", + sigma: vector.sigma, + tx_index: 0, + } +} + +describe("computeFairUpProbability vs oracle.move reference vectors", () => { + for (const vector of vectors as ReferenceVector[]) { + it(vector.label, () => { + const probability = computeFairUpProbability({ + forward: vector.forward, + strike: vector.strike, + svi: toSviUpdate(vector), + }) + + expect(probability).toBeDefined() + expect(Math.abs((probability ?? 0) - vector.expected)).toBeLessThan( + TOLERANCE + ) + }) + } + + it("returns undefined without svi params", () => { + expect( + computeFairUpProbability({ forward: 105000, strike: 105000, svi: null }) + ).toBeUndefined() + }) + + it("returns undefined for non-positive inputs", () => { + const vector = (vectors as ReferenceVector[])[0] + expect( + computeFairUpProbability({ + forward: 0, + strike: vector.strike, + svi: toSviUpdate(vector), + }) + ).toBeUndefined() + }) +}) diff --git a/web/src/lib/market-svi.vectors.json b/web/src/lib/market-svi.vectors.json new file mode 100644 index 0000000..b5ca39b --- /dev/null +++ b/web/src/lib/market-svi.vectors.json @@ -0,0 +1,106 @@ +[ + { + "label": "atm", + "a": 400000, + "b": 800000, + "rho": 300000000, + "rho_negative": true, + "m": 0, + "m_negative": false, + "sigma": 50000000, + "forward": 105000, + "strike": 105000, + "expected": 0.49581593477206115 + }, + { + "label": "otm_up", + "a": 400000, + "b": 800000, + "rho": 300000000, + "rho_negative": true, + "m": 0, + "m_negative": false, + "sigma": 50000000, + "forward": 105000, + "strike": 108000, + "expected": 0.08774549492823347 + }, + { + "label": "deep_otm_up", + "a": 400000, + "b": 800000, + "rho": 300000000, + "rho_negative": true, + "m": 0, + "m_negative": false, + "sigma": 50000000, + "forward": 105000, + "strike": 120000, + "expected": 5.539526615194745e-10 + }, + { + "label": "itm_up_dn_strike", + "a": 400000, + "b": 800000, + "rho": 300000000, + "rho_negative": true, + "m": 0, + "m_negative": false, + "sigma": 50000000, + "forward": 105000, + "strike": 95000, + "expected": 0.999994716016616 + }, + { + "label": "high_vol", + "a": 10000000, + "b": 20000000, + "rho": 500000000, + "rho_negative": true, + "m": 10000000, + "m_negative": false, + "sigma": 100000000, + "forward": 105000, + "strike": 110000, + "expected": 0.3144991470056856 + }, + { + "label": "pos_rho_neg_m", + "a": 600000, + "b": 1000000, + "rho": 400000000, + "rho_negative": false, + "m": 20000000, + "m_negative": true, + "sigma": 80000000, + "forward": 63000, + "strike": 61000, + "expected": 0.8902342407568469 + }, + { + "label": "tiny_var_near_atm", + "a": 10000, + "b": 20000, + "rho": 100000000, + "rho_negative": true, + "m": 0, + "m_negative": false, + "sigma": 20000000, + "forward": 63000, + "strike": 63005, + "expected": 0.48954024852161465 + }, + { + "label": "short_dated_crash", + "a": 200000, + "b": 500000, + "rho": 600000000, + "rho_negative": true, + "m": 0, + "m_negative": false, + "sigma": 40000000, + "forward": 63000, + "strike": 59500, + "expected": 0.999836234168183 + } +] From 9913f884f0b96cb4fc3429ba12e9947d0a8065a8 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Fri, 10 Jul 2026 23:36:42 +0100 Subject: [PATCH 03/33] feat(web): quote trades in two tiers and never sign a stale price --- .../market-detail/trading-ticket.tsx | 134 ++++++++++++++++-- web/src/components/shared/ticket/ticket.tsx | 8 +- web/src/lib/config.ts | 7 + 3 files changed, 136 insertions(+), 13 deletions(-) diff --git a/web/src/components/market-detail/trading-ticket.tsx b/web/src/components/market-detail/trading-ticket.tsx index 162c66b..1c703bf 100644 --- a/web/src/components/market-detail/trading-ticket.tsx +++ b/web/src/components/market-detail/trading-ticket.tsx @@ -1,5 +1,6 @@ import { useDynamicContext } from "@dynamic-labs/sdk-react-core" import { useEffect, useState } from "react" +import type { ReactNode } from "react" import { TicketCard, @@ -11,7 +12,12 @@ import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Tabs, TabsList } from "@/components/ui/tabs" import { formatUnitPrice, parseDecimalUnits } from "@/lib/amounts" -import { PREDICT_QUOTE_DECIMALS } from "@/lib/config" +import { + PREDICT_QUOTE_DECIMALS, + QUOTE_MOVE_TOLERANCE_BPS, + QUOTE_TTL_MS, +} from "@/lib/config" +import { computeFairUpProbability } from "@/lib/market-svi" import { executeSuiTransaction, preparePredictMintTransaction, @@ -131,6 +137,11 @@ function TradingTicketClient({ } }) const [quote, setQuote] = useState() + // Two-tier quoting: an instant local SVI estimate renders while the + // chain-authoritative devInspect quote is in flight; quotes expire after + // QUOTE_TTL_MS (quoteEpoch bump re-runs the quote effect). + const [quotedAtMs, setQuotedAtMs] = useState() + const [quoteEpoch, setQuoteEpoch] = useState(0) const [isQuoting, setIsQuoting] = useState(false) const [isSubmitting, setIsSubmitting] = useState(false) const [statusMessage, setStatusMessage] = useState() @@ -173,16 +184,62 @@ function TradingTicketClient({ market.fairUpProbability === undefined ? "--" : `${Math.round((isAbove ? market.fairUpProbability : 1 - market.fairUpProbability) * 100)}%` - const quotePriceValue = - !isRangeValid && ticketMode === "range" - ? "Invalid range" - : quotedQuote && selectedQuantity - ? `${formatUnitPrice(quotedQuote.mintCost, selectedQuantity)} DUSDC` - : quote?.status === "no_quote" - ? "No quote" - : isQuoting - ? "Quoting" - : "--" + // Instant local estimate (fair mid per contract from the oracle's own SVI, + // validated against on-chain pricing in market-svi.test.ts) shown while the + // executable devInspect quote is in flight. + const fairSideProbability = (() => { + if (!market.latestSvi || market.forwardPriceUsd <= 0) { + return undefined + } + if (ticketMode === "binary") { + const up = computeFairUpProbability({ + forward: market.forwardPriceUsd, + strike: ticketStrikePriceUsd, + svi: market.latestSvi, + }) + return up === undefined ? undefined : isAbove ? up : 1 - up + } + if (!isRangeValid) { + return undefined + } + const lower = computeFairUpProbability({ + forward: market.forwardPriceUsd, + strike: rangeStrikes.lower, + svi: market.latestSvi, + }) + const higher = computeFairUpProbability({ + forward: market.forwardPriceUsd, + strike: rangeStrikes.higher, + svi: market.latestSvi, + }) + return lower === undefined || higher === undefined + ? undefined + : Math.max(0, lower - higher) + })() + const estimateNode = + fairSideProbability === undefined ? undefined : ( + + ≈ {fairSideProbability.toFixed(2)} DUSDC est. + + ) + const quotePriceValue: ReactNode = + !isRangeValid && ticketMode === "range" ? ( + "Invalid range" + ) : quotedQuote && selectedQuantity ? ( + <> + {formatUnitPrice(quotedQuote.mintCost, selectedQuantity)} DUSDC{" "} + + ✓ live + + + ) : quote?.status === "no_quote" ? ( + "No quote" + ) : ( + (estimateNode ?? (isQuoting ? "Quoting" : "--")) + ) const premiumValue = quotedQuote ? formatDusdc(quotedQuote.mintCost) : "--" const potentialProfitValue = quotedQuote && selectedQuantity @@ -371,6 +428,7 @@ function TradingTicketClient({ if (!isStale) { setQuote(nextQuote) + setQuotedAtMs(Date.now()) setErrorMessage(formatPredictQuoteMessage(nextQuote)) } } finally { @@ -392,6 +450,7 @@ function TradingTicketClient({ isRangeValid, market, marketUnavailableMessage, + quoteEpoch, rangeStrikes, selectedQuantity, ticketStrikePriceUsd, @@ -399,6 +458,22 @@ function TradingTicketClient({ walletAddress, ]) + // Quote TTL: a displayed executable quote re-quotes automatically once it + // goes stale, so the ticket never shows an old price as current. + useEffect(() => { + if ( + !quotedQuote || + quotedAtMs === undefined || + isQuoting || + isSubmitting || + nowMs - quotedAtMs <= QUOTE_TTL_MS + ) { + return + } + + setQuoteEpoch((epoch) => epoch + 1) + }, [isQuoting, isSubmitting, nowMs, quotedAtMs, quotedQuote]) + async function handleTrade() { if (marketUnavailableMessage) { setErrorMessage(marketUnavailableMessage) @@ -454,6 +529,41 @@ function TradingTicketClient({ ticketMode, walletAddress, }) + // Sign-time re-quote: never let a stale displayed price get signed. If + // the executable cost moved beyond the tolerance, surface the new quote + // and make the user confirm again. + setStatusMessage("Confirming current price") + const freshQuote = await quotePredictTradeSafe(params) + + if (freshQuote.status !== "quoted") { + setStatusMessage(undefined) + setErrorMessage( + formatPredictQuoteMessage(freshQuote) ?? + "Quote unavailable. Try again." + ) + return + } + + const maxAcceptableCost = + quotedQuote.mintCost + + (quotedQuote.mintCost * QUOTE_MOVE_TOLERANCE_BPS) / 10_000n + + if (freshQuote.mintCost > maxAcceptableCost) { + setQuote(freshQuote) + setQuotedAtMs(Date.now()) + setStatusMessage(undefined) + setErrorMessage( + "Price moved. Review the updated quote and confirm again." + ) + return + } + + if (availableDusdcBalance < getTradeReserveAmount(freshQuote.mintCost)) { + setStatusMessage(undefined) + setErrorMessage("Available DUSDC is below the estimated trade reserve.") + return + } + const hadManager = Boolean(predictAccount.managerId) if (!hadManager) { @@ -468,7 +578,7 @@ function TradingTicketClient({ managerBalance: managerDusdcBalance, managerId, params, - quotedCost: quotedQuote.mintCost, + quotedCost: freshQuote.mintCost, }) setStatusMessage( diff --git a/web/src/components/shared/ticket/ticket.tsx b/web/src/components/shared/ticket/ticket.tsx index 18ccf85..9b5768f 100644 --- a/web/src/components/shared/ticket/ticket.tsx +++ b/web/src/components/shared/ticket/ticket.tsx @@ -32,7 +32,13 @@ export function TicketSection({ ) } -export function TicketRow({ label, value }: { label: string; value: string }) { +export function TicketRow({ + label, + value, +}: { + label: string + value: ReactNode +}) { return (
{label} diff --git a/web/src/lib/config.ts b/web/src/lib/config.ts index 5138945..69ea149 100644 --- a/web/src/lib/config.ts +++ b/web/src/lib/config.ts @@ -55,6 +55,13 @@ export const PROTECT_ORIGINAL_PACKAGE_ID = PROTECT_PACKAGE_ID export const SUI_GRPC_URL = "https://fullnode.testnet.sui.io:443" +// Trade-ticket quote freshness (plans/price-proof.md §C). A displayed quote +// older than the TTL re-quotes automatically, and the submit path re-quotes at +// sign time, aborting if the executable cost moved beyond the tolerance so a +// stale price is never signed. +export const QUOTE_TTL_MS = 15_000 +export const QUOTE_MOVE_TOLERANCE_BPS = 100n + // Gas-sponsorship server (self-hosted Onara). When set, trades/deposits/Arena // actions are sponsored (zero SUI for the user) via a scoped allow-list; on any // sponsor failure the app falls back to the wallet-paid path. Empty/unset = off From 56f6f0c0f203d3a9029e6c87cda23b6df05153c9 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 00:03:57 +0100 Subject: [PATCH 04/33] feat(operator): size vault hedges from the live pool book instead of fixed bps math --- services/operator/scripts/pool-book-spike.ts | 5 +- .../operator/scripts/record-model-fixture.ts | 104 ++++ .../operator/scripts/verify-deployment.ts | 2 +- services/operator/src/deploy.ts | 2 +- services/operator/src/model/density.test.ts | 106 ++++ services/operator/src/model/density.ts | 119 ++++ services/operator/src/model/fixture.test.ts | 115 ++++ .../src/model/fixtures/testnet-pool.json | 561 ++++++++++++++++++ services/operator/src/model/pool.test.ts | 111 ++++ services/operator/src/model/pool.ts | 102 ++++ services/operator/src/model/pricer.ts | 198 +++++++ services/operator/src/model/reads.ts | 223 +++++++ services/operator/src/model/sizer.test.ts | 118 ++++ services/operator/src/model/sizer.ts | 229 +++++++ services/operator/src/model/types.ts | 94 +++ services/operator/src/model/wash.test.ts | 94 +++ services/operator/src/model/wash.ts | 92 +++ services/operator/src/sui.ts | 7 + web/src/lib/config.ts | 2 +- web/src/lib/market-svi.golden.test.ts | 2 +- web/src/lib/market-svi.test.ts | 2 +- 21 files changed, 2280 insertions(+), 8 deletions(-) create mode 100644 services/operator/scripts/record-model-fixture.ts create mode 100644 services/operator/src/model/density.test.ts create mode 100644 services/operator/src/model/density.ts create mode 100644 services/operator/src/model/fixture.test.ts create mode 100644 services/operator/src/model/fixtures/testnet-pool.json create mode 100644 services/operator/src/model/pool.test.ts create mode 100644 services/operator/src/model/pool.ts create mode 100644 services/operator/src/model/pricer.ts create mode 100644 services/operator/src/model/reads.ts create mode 100644 services/operator/src/model/sizer.test.ts create mode 100644 services/operator/src/model/sizer.ts create mode 100644 services/operator/src/model/types.ts create mode 100644 services/operator/src/model/wash.test.ts create mode 100644 services/operator/src/model/wash.ts diff --git a/services/operator/scripts/pool-book-spike.ts b/services/operator/scripts/pool-book-spike.ts index 5f14dc4..15832f4 100644 --- a/services/operator/scripts/pool-book-spike.ts +++ b/services/operator/scripts/pool-book-spike.ts @@ -1,6 +1,5 @@ -// Strategy-model Phase 0 spike (plans/strategy-model.md §11 Phase 0). -// -// Proves, against live testnet, every read the model needs: +// Strategy-model data spike — proves, against live testnet, every on-chain +// read the model needs: // 1. Pool aggregates (balance / total_mtm / vault_value / total_max_payout) // 2. PLP total supply (treasury cap) // 3. Per-strike pool book q_up/q_dn via the vault's StrikeMatrix tables diff --git a/services/operator/scripts/record-model-fixture.ts b/services/operator/scripts/record-model-fixture.ts new file mode 100644 index 0000000..f1e15a9 --- /dev/null +++ b/services/operator/scripts/record-model-fixture.ts @@ -0,0 +1,104 @@ +// Record a live-testnet model fixture: pool +// aggregates + one oracle's strike book + real grid quotes, committed as JSON +// so the model pipeline has a deterministic real-data test. +// +// Run: cd services/operator && bun scripts/record-model-fixture.ts +import { readFileSync, writeFileSync } from "node:fs" +import { SuiGrpcClient } from "@mysten/sui/grpc" + +import { GridPricer } from "../src/model/pricer.ts" +import { readPoolAggregates, readStrikeBook } from "../src/model/reads.ts" +import type { SuiClient } from "../src/sui.ts" + +const GRPC_URL = "https://fullnode.testnet.sui.io:443" +const PREDICT_PACKAGE_ID = + "0xf5ea2b3749c65d6e56507cc35388719aadb28f9cab873696a2f8687f5c785138" +const PREDICT_OBJECT_ID = + "0xc8736204d12f0a7277c86388a68bf8a194b0a14c5538ad13f22cbd8e2a38028a" +const PREDICT_SERVER_URL = "https://predict-server.testnet.mystenlabs.com" +const CLOCK_ID = "0x6" +const PROBE_QUANTITY = 1_000_000n + +const client = new SuiGrpcClient({ + baseUrl: GRPC_URL, + network: "testnet", +}) as unknown as SuiClient + +const manifest = JSON.parse( + readFileSync(new URL("../deployment.testnet.json", import.meta.url), "utf8") +) as { deployer: string } + +interface OracleListing { + oracle_id: string + expiry: number + status: string +} + +const oraclesResponse = await fetch( + `${PREDICT_SERVER_URL}/predicts/${PREDICT_OBJECT_ID}/oracles` +) +const oracles = (await oraclesResponse.json()) as OracleListing[] +const active = oracles.filter( + (oracle) => oracle.status === "active" && oracle.expiry > Date.now() +) + +if (active.length === 0) { + throw new Error("no active unexpired oracle on testnet") +} + +const aggregates = await readPoolAggregates(client, PREDICT_OBJECT_ID) + +// Pick the active oracle with the deepest book. +let chosen: { oracleId: string; expiryMs: number } | undefined +let chosenBook: Awaited> | undefined + +for (const oracle of active) { + const result = await readStrikeBook(client, PREDICT_OBJECT_ID, oracle.oracle_id) + if (!result) continue + if (!chosenBook || result.book.strikes.length > chosenBook.book.strikes.length) { + chosen = { expiryMs: oracle.expiry, oracleId: oracle.oracle_id } + chosenBook = result + } +} + +if (!chosen || !chosenBook) { + throw new Error("no active oracle has a strike book") +} + +console.log( + `oracle ${chosen.oracleId.slice(0, 10)}… book strikes: ${chosenBook.book.strikes.length}` +) + +const pricer = new GridPricer(client, { + clockObjectId: CLOCK_ID, + predictObjectId: PREDICT_OBJECT_ID, + predictPackageId: PREDICT_PACKAGE_ID, +}) +const quotes = await pricer.quoteGrid({ + expiryMs: chosen.expiryMs, + isUp: true, + oracleId: chosen.oracleId, + quantity: PROBE_QUANTITY, + senderAddress: manifest.deployer, + strikes: chosenBook.book.strikes, +}) + +console.log(`quoted ${quotes.length}/${chosenBook.book.strikes.length} strikes`) + +const serialize = (_key: string, value: unknown) => + typeof value === "bigint" ? value.toString() : value + +const fixture = { + aggregates, + book: chosenBook.book, + grid: chosenBook.grid, + oracle: chosen, + probeQuantity: PROBE_QUANTITY, + quotes, + recordedNote: + "Live testnet snapshot for the deterministic model pipeline test. Regenerate with scripts/record-model-fixture.ts.", +} + +const outPath = new URL("../src/model/fixtures/testnet-pool.json", import.meta.url) +writeFileSync(outPath, `${JSON.stringify(fixture, serialize, 2)}\n`) +console.log(`wrote ${outPath.pathname}`) diff --git a/services/operator/scripts/verify-deployment.ts b/services/operator/scripts/verify-deployment.ts index 7fc97c9..8d42dce 100644 --- a/services/operator/scripts/verify-deployment.ts +++ b/services/operator/scripts/verify-deployment.ts @@ -1,4 +1,4 @@ -// Deployment drift guard (plans/tier0-honesty.md §0.2). +// Deployment drift guard. // // Asserts the three id sources never disagree: // 1. services/operator/deployment.testnet.json (the manifest every service reads) diff --git a/services/operator/src/deploy.ts b/services/operator/src/deploy.ts index 82b32f5..2761027 100644 --- a/services/operator/src/deploy.ts +++ b/services/operator/src/deploy.ts @@ -894,7 +894,7 @@ const CHAIN_IDS: Partial> = { testnet: TESTNET_CHAIN_ID // Mirror the freshly deployed package ids into every package's Published.toml // so the repo metadata can never drift from the manifest (verified by -// scripts/verify-deployment.ts and documented in DEPLOYMENT.md). +// scripts/verify-deployment.ts). async function writePublishedTomls(record: DeploymentRecord, network: Network) { const chainId = CHAIN_IDS[network] if (!chainId) { diff --git a/services/operator/src/model/density.test.ts b/services/operator/src/model/density.test.ts new file mode 100644 index 0000000..5954ad3 --- /dev/null +++ b/services/operator/src/model/density.test.ts @@ -0,0 +1,106 @@ +import { describe, expect, test } from "bun:test" + +import { buildDensity, cvar, densityScenarios } from "./density.ts" + +const K = (usd: number) => BigInt(usd) * 1_000_000_000n +const TICK = 1_000_000_000n + +describe("buildDensity", () => { + test("clean monotone mids produce a valid distribution", () => { + const density = buildDensity({ + strikes: [K(59_000), K(60_000), K(61_000), K(62_000)], + midUp: [0.9, 0.6, 0.3, 0.1], + }) + + expect(density.cdf).toEqual([ + 0.09999999999999998, 0.4, 0.7, 0.9, + ]) + expect(density.tailBelow).toBeCloseTo(0.1, 12) + expect(density.tailAbove).toBeCloseTo(0.1, 12) + expect(density.maxViolation).toBe(0) + + const totalMass = + density.tailBelow + + density.pmf.reduce((a, b) => a + b, 0) + + density.tailAbove + expect(totalMass).toBeCloseTo(1, 12) + }) + + test("inverted mids are isotonic-clamped and the violation is reported", () => { + // midUp INCREASES 0.6 -> 0.7 between strikes (butterfly violation of 0.1). + const density = buildDensity({ + strikes: [K(60_000), K(61_000), K(62_000)], + midUp: [0.6, 0.7, 0.2], + }) + + // F would be [0.4, 0.3, 0.8] raw; clamped to [0.4, 0.4, 0.8]. + expect(density.cdf).toEqual([0.4, 0.4, 0.8]) + expect(density.maxViolation).toBeCloseTo(0.1, 12) + expect(density.pmf[1]).toBe(0) + }) + + test("rejects malformed input", () => { + expect(() => buildDensity({ strikes: [], midUp: [] })).toThrow() + expect(() => + buildDensity({ strikes: [K(60_000), K(60_000)], midUp: [0.5, 0.4] }) + ).toThrow("ascending") + expect(() => + buildDensity({ strikes: [K(60_000)], midUp: [1.5] }) + ).toThrow("out of [0,1]") + }) +}) + +describe("densityScenarios", () => { + test("settlements sit strictly between strikes and mass sums to one", () => { + const density = buildDensity({ + strikes: [K(60_000), K(61_000)], + midUp: [0.8, 0.25], + }) + const scenarios = densityScenarios(density, TICK) + + // tailBelow (0.2), bucket between (0.55), tailAbove (0.25) + expect(scenarios).toHaveLength(3) + expect(scenarios[0]?.settlement).toBe(K(60_000) - TICK) + expect(scenarios[1]?.settlement).toBe((K(60_000) + K(61_000)) / 2n) + expect(scenarios[2]?.settlement).toBe(K(61_000) + TICK) + + const mass = scenarios.reduce((a, s) => a + s.probability, 0) + expect(mass).toBeCloseTo(1, 12) + // Settlements must never land exactly on a strike, so the strict vs + // at-or-below indicator conventions can't bite. + for (const scenario of scenarios) { + expect(density.strikes).not.toContain(scenario.settlement) + } + }) +}) + +describe("cvar", () => { + test("expected loss of the worst tail", () => { + // Loss 100 w.p. 0.05, loss 10 w.p. 0.05, loss 0 w.p. 0.9. + const outcomes = [ + { loss: 0, probability: 0.9 }, + { loss: 10, probability: 0.05 }, + { loss: 100, probability: 0.05 }, + ] + // alpha=0.95 -> tail mass 0.05 -> the single worst slice: CVaR = 100. + expect(cvar(outcomes, 0.95)).toBeCloseTo(100, 9) + // alpha=0.90 -> tail 0.10 -> (0.05*100 + 0.05*10)/0.10 = 55. + expect(cvar(outcomes, 0.9)).toBeCloseTo(55, 9) + }) + + test("hedged tail beats unhedged tail", () => { + const unhedged = [ + { loss: 0, probability: 0.95 }, + { loss: 50, probability: 0.05 }, + ] + const hedged = [ + { loss: 2, probability: 0.95 }, // paid premium everywhere + { loss: 10, probability: 0.05 }, // crash offset by payout + ] + expect(cvar(hedged, 0.95)).toBeLessThan(cvar(unhedged, 0.95)) + }) + + test("rejects bad alpha", () => { + expect(() => cvar([{ loss: 1, probability: 1 }], 1)).toThrow() + }) +}) diff --git a/services/operator/src/model/density.ts b/services/operator/src/model/density.ts new file mode 100644 index 0000000..5dc33b3 --- /dev/null +++ b/services/operator/src/model/density.ts @@ -0,0 +1,119 @@ +// Risk-neutral settlement density from the strike grid of UP-binary mids +// Pure math, no I/O. +// +// A cash-or-nothing UP binary at strike K prices at ~Q(S_T > K) (r≈0, short +// tenor), so the grid of mids IS the risk-neutral distribution: +// F(K) = P(S_T <= K) = 1 - midUp(K) +// Pool-adjusted mids can locally invert; we clamp F to be monotone +// non-decreasing (isotonic via running max) and report the largest violation, +// which doubles as a live butterfly-arbitrage signal. + +import type { DensityCurve, Scenario } from "./types.ts" + +export interface DensityInput { + /// Ascending strikes with their UP mids in [0, 1]. + strikes: bigint[] + midUp: number[] +} + +export function buildDensity({ strikes, midUp }: DensityInput): DensityCurve { + if (strikes.length === 0 || strikes.length !== midUp.length) { + throw new Error("density needs equal, non-empty strikes and mids") + } + for (let i = 1; i < strikes.length; i += 1) { + if (strikes[i]! <= strikes[i - 1]!) { + throw new Error("strikes must be strictly ascending") + } + } + + const cdf: number[] = new Array(strikes.length) + let running = 0 + let maxViolation = 0 + + for (let i = 0; i < strikes.length; i += 1) { + const mid = midUp[i]! + if (!Number.isFinite(mid) || mid < 0 || mid > 1) { + throw new Error(`mid out of [0,1] at strike index ${i}`) + } + const raw = 1 - mid + if (raw < running) { + maxViolation = Math.max(maxViolation, running - raw) + } + running = Math.max(running, raw) + cdf[i] = running + } + + const pmf: number[] = new Array(strikes.length) + pmf[0] = 0 // mass below strikes[0] is tailBelow; buckets start between strikes + for (let i = 1; i < strikes.length; i += 1) { + pmf[i] = cdf[i]! - cdf[i - 1]! + } + + return { + strikes, + cdf, + pmf, + tailBelow: cdf[0]!, + tailAbove: 1 - cdf[strikes.length - 1]!, + maxViolation, + } +} + +/// Discrete settlement scenarios for expectation / CVaR sums. Representative +/// settlements sit strictly BETWEEN strikes (and one tick beyond the edges) so +/// strict/at-or-below indicator conventions never bite on exact equality. +export function densityScenarios( + density: DensityCurve, + tickSize: bigint +): Scenario[] { + const { strikes, pmf, tailBelow, tailAbove } = density + const scenarios: Scenario[] = [] + + if (tailBelow > 0) { + scenarios.push({ + settlement: strikes[0]! - tickSize, + probability: tailBelow, + }) + } + for (let i = 1; i < strikes.length; i += 1) { + const mass = pmf[i]! + if (mass <= 0) continue + scenarios.push({ + settlement: (strikes[i - 1]! + strikes[i]!) / 2n, + probability: mass, + }) + } + if (tailAbove > 0) { + scenarios.push({ + settlement: strikes[strikes.length - 1]! + tickSize, + probability: tailAbove, + }) + } + + return scenarios +} + +/// CVaR_alpha of a loss distribution given as (loss, probability) pairs: +/// the expected loss in the worst (1 - alpha) tail. Losses in quote-unit +/// floats; alpha in (0, 1). +export function cvar( + outcomes: { loss: number; probability: number }[], + alpha: number +): number { + if (alpha <= 0 || alpha >= 1) { + throw new Error("alpha must be in (0, 1)") + } + const tailMass = 1 - alpha + const sorted = [...outcomes].sort((a, b) => b.loss - a.loss) + + let remaining = tailMass + let acc = 0 + for (const outcome of sorted) { + if (remaining <= 0) break + const take = Math.min(outcome.probability, remaining) + acc += take * outcome.loss + remaining -= take + } + + return acc / tailMass +} diff --git a/services/operator/src/model/fixture.test.ts b/services/operator/src/model/fixture.test.ts new file mode 100644 index 0000000..5815f49 --- /dev/null +++ b/services/operator/src/model/fixture.test.ts @@ -0,0 +1,115 @@ +import { describe, expect, test } from "bun:test" + +import fixtureJson from "./fixtures/testnet-pool.json" +import { buildDensity, cvar, densityScenarios } from "./density.ts" +import { buildLiabilityCurve, applyProspectiveMint } from "./pool.ts" +import { unitMidUp } from "./pricer.ts" +import type { GridQuote, PoolAggregates, PoolBook } from "./types.ts" + +// Deterministic end-to-end pipeline run over a RECORDED live-testnet snapshot +// reads → density → liability curve → CVaR all +// behave on real data, byte-identically on every run. + +interface RawFixture { + aggregates: Record + book: { strikes: string[]; qUp: string[]; qDn: string[]; rangeQty: string } + grid: Record + probeQuantity: string + quotes: { strike: string; mintCost: string; redeemPayout: string }[] +} + +const raw = fixtureJson as unknown as RawFixture + +const aggregates: PoolAggregates = { + balance: BigInt(raw.aggregates.balance!), + plpSupply: BigInt(raw.aggregates.plpSupply!), + totalMaxPayout: BigInt(raw.aggregates.totalMaxPayout!), + totalMtm: BigInt(raw.aggregates.totalMtm!), + vaultValue: BigInt(raw.aggregates.vaultValue!), +} +const book: PoolBook = { + qDn: raw.book.qDn.map(BigInt), + qUp: raw.book.qUp.map(BigInt), + rangeQty: BigInt(raw.book.rangeQty), + strikes: raw.book.strikes.map(BigInt), +} +const quotes: GridQuote[] = raw.quotes.map((quote) => ({ + mintCost: BigInt(quote.mintCost), + redeemPayout: BigInt(quote.redeemPayout), + strike: BigInt(quote.strike), +})) +const probeQuantity = BigInt(raw.probeQuantity) +const tickSize = BigInt(raw.grid.tickSize!) + +describe("model pipeline on the recorded testnet snapshot", () => { + test("fixture is non-trivial", () => { + expect(book.strikes.length).toBeGreaterThan(3) + expect(quotes.length).toBeGreaterThan(3) + expect(aggregates.balance).toBeGreaterThan(0n) + expect(aggregates.plpSupply).toBeGreaterThan(0n) + }) + + test("density from real quotes is a valid distribution", () => { + const density = buildDensity({ + midUp: quotes.map((quote) => unitMidUp(quote, probeQuantity)), + strikes: quotes.map((quote) => quote.strike), + }) + const scenarios = densityScenarios(density, tickSize) + const mass = scenarios.reduce((acc, scenario) => acc + scenario.probability, 0) + + expect(mass).toBeCloseTo(1, 9) + // A live pool-adjusted surface may carry small inversions; anything large + // would mean we misread the grid. + expect(density.maxViolation).toBeLessThan(0.2) + }) + + test("liability curve matches brute force on the real book", () => { + const curve = buildLiabilityCurve(book, aggregates) + const low = book.strikes[0]! - tickSize + const high = book.strikes[book.strikes.length - 1]! + tickSize + const step = (high - low) / 37n || 1n + + for (let settlement = low; settlement <= high; settlement += step) { + let gross = 0n + for (let i = 0; i < book.strikes.length; i += 1) { + if (settlement > book.strikes[i]!) gross += book.qUp[i]! + if (settlement <= book.strikes[i]!) gross += book.qDn[i]! + } + const net = gross - book.rangeQty + expect(curve.liabilityAt(settlement)).toBe(net > 0n ? net : 0n) + } + }) + + test("pool tail risk is computable end to end (CVaR of pool value)", () => { + const density = buildDensity({ + midUp: quotes.map((quote) => unitMidUp(quote, probeQuantity)), + strikes: quotes.map((quote) => quote.strike), + }) + const scenarios = densityScenarios(density, tickSize) + const curve = buildLiabilityCurve(book, aggregates) + + const outcomes = scenarios.map((scenario) => ({ + loss: Number( + aggregates.vaultValue - curve.poolValueAt(scenario.settlement) + ), + probability: scenario.probability, + })) + const tail = cvar(outcomes, 0.95) + + expect(Number.isFinite(tail)).toBe(true) + // The pool can never lose more than its whole liability book. + expect(tail).toBeLessThanOrEqual(Number(aggregates.totalMaxPayout)) + }) + + test("a prospective hedge mint deepens crash liability by exactly its size", () => { + const strike = book.strikes[0]! + const quantity = 5_000_000n + const before = buildLiabilityCurve(book, aggregates) + const next = applyProspectiveMint(book, aggregates, strike, quantity, 1_000_000n) + const after = buildLiabilityCurve(next.book, next.aggregates) + const crash = strike - tickSize + + expect(after.liabilityAt(crash) - before.liabilityAt(crash)).toBe(quantity) + expect(next.aggregates.balance - aggregates.balance).toBe(1_000_000n) + }) +}) diff --git a/services/operator/src/model/fixtures/testnet-pool.json b/services/operator/src/model/fixtures/testnet-pool.json new file mode 100644 index 0000000..53e7c0b --- /dev/null +++ b/services/operator/src/model/fixtures/testnet-pool.json @@ -0,0 +1,561 @@ +{ + "aggregates": { + "balance": "1018679256180", + "plpSupply": "1015770298697", + "totalMaxPayout": "2143361702", + "totalMtm": "859676872", + "vaultValue": "1017819579308" + }, + "book": { + "qDn": [ + "1001000", + "166666", + "166666", + "833333", + "10000", + "833333", + "166666", + "833333", + "166666", + "833333", + "0", + "10000", + "1000000", + "833333", + "1000000", + "166666", + "166666", + "833333", + "833333", + "0", + "166666", + "5000000", + "833333", + "833333", + "166666", + "166666", + "5000", + "0", + "833333", + "3000000", + "833333", + "166666", + "4000000", + "0", + "8000000", + "0", + "166666", + "833333", + "5123805", + "0", + "5121288", + "5121238", + "2305712", + "2304579", + "2304557", + "166666", + "40620000", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "53187548", + "132720021", + "2305712", + "2304579", + "132894092", + "2304557", + "0", + "0", + "0", + "8214" + ], + "qUp": [ + "2168416", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "8214", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "9100000", + "0", + "0", + "0", + "0", + "0", + "4000000", + "0", + "2444429", + "0", + "0", + "2305712", + "1000000", + "2304579", + "2304557", + "0", + "0", + "0", + "0", + "13310384", + "3399522", + "5683348", + "1000000", + "53187548", + "132720021", + "2305712", + "2304579", + "132894092", + "2304557", + "1937004", + "4833448", + "5123805", + "5121288", + "4839788", + "5121238", + "100000000", + "10795419", + "100000000", + "0" + ], + "rangeQty": "332639571", + "strikes": [ + "50000000000000", + "50419000000000", + "53005000000000", + "53037000000000", + "54396000000000", + "54909000000000", + "55591000000000", + "55908000000000", + "56286000000000", + "56781000000000", + "57036000000000", + "57401000000000", + "57407000000000", + "57433000000000", + "57778000000000", + "57821000000000", + "58176000000000", + "58652000000000", + "58958000000000", + "59263000000000", + "59356000000000", + "59536000000000", + "60482000000000", + "60524000000000", + "60762000000000", + "60892000000000", + "61726000000000", + "62000000000000", + "62007000000000", + "62336000000000", + "62396000000000", + "62427000000000", + "62498000000000", + "62529000000000", + "62572000000000", + "62672000000000", + "63348000000000", + "63532000000000", + "63575000000000", + "63601000000000", + "63614000000000", + "63635000000000", + "63825000000000", + "63864000000000", + "63885000000000", + "63962000000000", + "64000000000000", + "64107000000000", + "64124000000000", + "64154000000000", + "64254000000000", + "64306000000000", + "64325000000000", + "64364000000000", + "64374000000000", + "64385000000000", + "64504000000000", + "64556000000000", + "64575000000000", + "64614000000000", + "64624000000000", + "64635000000000", + "65000000000000", + "65275000000000", + "67000000000000", + "69711000000000" + ] + }, + "grid": { + "maxStrike": "150000000000000", + "minStrike": "50000000000000", + "mintedMax": "69711000000000", + "mintedMin": "50000000000000", + "tickSize": "1000000000" + }, + "oracle": { + "expiryMs": 1784275200000, + "oracleId": "0x05306d43afb006322e73aeadb217b1a83511aed57f773a2f4e7a181e0caae01d" + }, + "probeQuantity": "1000000", + "quotes": [ + { + "mintCost": "1000000", + "redeemPayout": "993812", + "strike": "50000000000000" + }, + { + "mintCost": "1000000", + "redeemPayout": "993559", + "strike": "50419000000000" + }, + { + "mintCost": "1000000", + "redeemPayout": "990354", + "strike": "53005000000000" + }, + { + "mintCost": "1000000", + "redeemPayout": "990287", + "strike": "53037000000000" + }, + { + "mintCost": "996394", + "redeemPayout": "986394", + "strike": "54396000000000" + }, + { + "mintCost": "994217", + "redeemPayout": "984217", + "strike": "54909000000000" + }, + { + "mintCost": "990465", + "redeemPayout": "980465", + "strike": "55591000000000" + }, + { + "mintCost": "988308", + "redeemPayout": "978308", + "strike": "55908000000000" + }, + { + "mintCost": "985319", + "redeemPayout": "975319", + "strike": "56286000000000" + }, + { + "mintCost": "980590", + "redeemPayout": "970590", + "strike": "56781000000000" + }, + { + "mintCost": "977731", + "redeemPayout": "967730", + "strike": "57036000000000" + }, + { + "mintCost": "973049", + "redeemPayout": "963048", + "strike": "57401000000000" + }, + { + "mintCost": "972965", + "redeemPayout": "962965", + "strike": "57407000000000" + }, + { + "mintCost": "972602", + "redeemPayout": "962602", + "strike": "57433000000000" + }, + { + "mintCost": "967371", + "redeemPayout": "957371", + "strike": "57778000000000" + }, + { + "mintCost": "966663", + "redeemPayout": "956663", + "strike": "57821000000000" + }, + { + "mintCost": "960283", + "redeemPayout": "950283", + "strike": "58176000000000" + }, + { + "mintCost": "950033", + "redeemPayout": "940033", + "strike": "58652000000000" + }, + { + "mintCost": "942235", + "redeemPayout": "932235", + "strike": "58958000000000" + }, + { + "mintCost": "933519", + "redeemPayout": "923203", + "strike": "59263000000000" + }, + { + "mintCost": "930668", + "redeemPayout": "920159", + "strike": "59356000000000" + }, + { + "mintCost": "924805", + "redeemPayout": "913914", + "strike": "59536000000000" + }, + { + "mintCost": "885059", + "redeemPayout": "871991", + "strike": "60482000000000" + }, + { + "mintCost": "882885", + "redeemPayout": "869715", + "strike": "60524000000000" + }, + { + "mintCost": "869794", + "redeemPayout": "856037", + "strike": "60762000000000" + }, + { + "mintCost": "862060", + "redeemPayout": "847977", + "strike": "60892000000000" + }, + { + "mintCost": "801119", + "redeemPayout": "784913", + "strike": "61726000000000" + }, + { + "mintCost": "776254", + "redeemPayout": "759365", + "strike": "62000000000000" + }, + { + "mintCost": "775585", + "redeemPayout": "758678", + "strike": "62007000000000" + }, + { + "mintCost": "742126", + "redeemPayout": "724436", + "strike": "62336000000000" + }, + { + "mintCost": "735598", + "redeemPayout": "717771", + "strike": "62396000000000" + }, + { + "mintCost": "732173", + "redeemPayout": "714277", + "strike": "62427000000000" + }, + { + "mintCost": "724196", + "redeemPayout": "706143", + "strike": "62498000000000" + }, + { + "mintCost": "720655", + "redeemPayout": "702534", + "strike": "62529000000000" + }, + { + "mintCost": "715685", + "redeemPayout": "697471", + "strike": "62572000000000" + }, + { + "mintCost": "703864", + "redeemPayout": "685442", + "strike": "62672000000000" + }, + { + "mintCost": "614837", + "redeemPayout": "595284", + "strike": "63348000000000" + }, + { + "mintCost": "588177", + "redeemPayout": "568424", + "strike": "63532000000000" + }, + { + "mintCost": "581825", + "redeemPayout": "562033", + "strike": "63575000000000" + }, + { + "mintCost": "577964", + "redeemPayout": "558150", + "strike": "63601000000000" + }, + { + "mintCost": "576027", + "redeemPayout": "556203", + "strike": "63614000000000" + }, + { + "mintCost": "572892", + "redeemPayout": "553051", + "strike": "63635000000000" + }, + { + "mintCost": "544128", + "redeemPayout": "524175", + "strike": "63825000000000" + }, + { + "mintCost": "538148", + "redeemPayout": "518180", + "strike": "63864000000000" + }, + { + "mintCost": "534918", + "redeemPayout": "514943", + "strike": "63885000000000" + }, + { + "mintCost": "523027", + "redeemPayout": "503034", + "strike": "63962000000000" + }, + { + "mintCost": "517134", + "redeemPayout": "497136", + "strike": "64000000000000" + }, + { + "mintCost": "500466", + "redeemPayout": "480470", + "strike": "64107000000000" + }, + { + "mintCost": "497691", + "redeemPayout": "477697", + "strike": "64124000000000" + }, + { + "mintCost": "493000", + "redeemPayout": "473011", + "strike": "64154000000000" + }, + { + "mintCost": "477338", + "redeemPayout": "457381", + "strike": "64254000000000" + }, + { + "mintCost": "469187", + "redeemPayout": "449254", + "strike": "64306000000000" + }, + { + "mintCost": "466209", + "redeemPayout": "446286", + "strike": "64325000000000" + }, + { + "mintCost": "460098", + "redeemPayout": "440197", + "strike": "64364000000000" + }, + { + "mintCost": "458531", + "redeemPayout": "438637", + "strike": "64374000000000" + }, + { + "mintCost": "456808", + "redeemPayout": "436922", + "strike": "64385000000000" + }, + { + "mintCost": "438208", + "redeemPayout": "418414", + "strike": "64504000000000" + }, + { + "mintCost": "430110", + "redeemPayout": "410366", + "strike": "64556000000000" + }, + { + "mintCost": "427157", + "redeemPayout": "407432", + "strike": "64575000000000" + }, + { + "mintCost": "421107", + "redeemPayout": "401425", + "strike": "64614000000000" + }, + { + "mintCost": "419559", + "redeemPayout": "399887", + "strike": "64624000000000" + }, + { + "mintCost": "417857", + "redeemPayout": "398198", + "strike": "64635000000000" + }, + { + "mintCost": "362468", + "redeemPayout": "343353", + "strike": "65000000000000" + }, + { + "mintCost": "322697", + "redeemPayout": "304142", + "strike": "65275000000000" + }, + { + "mintCost": "134485", + "redeemPayout": "121130", + "strike": "67000000000000" + }, + { + "mintCost": "27649", + "redeemPayout": "17649", + "strike": "69711000000000" + } + ], + "recordedNote": "Live testnet snapshot for the deterministic model pipeline test. Regenerate with scripts/record-model-fixture.ts." +} diff --git a/services/operator/src/model/pool.test.ts b/services/operator/src/model/pool.test.ts new file mode 100644 index 0000000..a526ddb --- /dev/null +++ b/services/operator/src/model/pool.test.ts @@ -0,0 +1,111 @@ +import { describe, expect, test } from "bun:test" + +import { applyProspectiveMint, buildLiabilityCurve } from "./pool.ts" +import type { PoolAggregates, PoolBook } from "./types.ts" + +const K = (usd: number) => BigInt(usd) * 1_000_000_000n +const C = (contracts: number) => BigInt(contracts) * 1_000_000n + +const book: PoolBook = { + strikes: [K(59_500), K(60_000), K(61_000)], + qUp: [C(13), C(31), 0n], + qDn: [0n, C(1), C(17)], + rangeQty: 0n, +} +const aggregates: PoolAggregates = { + balance: C(1_000_000), + totalMtm: C(1), + vaultValue: C(999_999), + totalMaxPayout: C(62), + plpSupply: C(1_000_000), +} + +describe("buildLiabilityCurve", () => { + const curve = buildLiabilityCurve(book, aggregates) + + test("crash: below every strike only DN pays (at-or-below wins)", () => { + expect(curve.liabilityAt(K(59_000))).toBe(C(18)) // all q_dn + }) + + test("moon: above every strike only UP pays", () => { + expect(curve.liabilityAt(K(62_000))).toBe(C(44)) // all q_up + }) + + test("mid: UP below S, DN at-or-above S", () => { + // S=60500: up pays 13+31, dn pays 17 (strike 61000 >= S) + expect(curve.liabilityAt(K(60_500))).toBe(C(44 + 17)) + }) + + test("exactly on a strike: DN at the strike still pays (at-or-below)", () => { + // S=60000: up pays 13 (59500 < S), dn pays 1 (60000 >= S) + 17 + expect(curve.liabilityAt(K(60_000))).toBe(C(13 + 18)) + }) + + test("range_qty is subtracted and the result never goes negative", () => { + const ranged = buildLiabilityCurve( + { ...book, rangeQty: C(10) }, + aggregates + ) + expect(ranged.liabilityAt(K(59_000))).toBe(C(8)) + const overRanged = buildLiabilityCurve( + { ...book, rangeQty: C(100) }, + aggregates + ) + expect(overRanged.liabilityAt(K(59_000))).toBe(0n) + }) + + test("pool value = balance - liability", () => { + expect(curve.poolValueAt(K(59_000))).toBe(C(1_000_000) - C(18)) + }) + + test("matches brute force across a settlement sweep", () => { + for (let usd = 59_000; usd <= 62_000; usd += 250) { + const settlement = K(usd) + let expected = 0n + for (let i = 0; i < book.strikes.length; i += 1) { + if (settlement > book.strikes[i]!) expected += book.qUp[i]! + if (settlement <= book.strikes[i]!) expected += book.qDn[i]! + } + expect(curve.liabilityAt(settlement)).toBe(expected) + } + }) +}) + +describe("applyProspectiveMint", () => { + test("existing strike: DN inventory and balance grow", () => { + const next = applyProspectiveMint(book, aggregates, K(60_000), C(5), C(1)) + expect(next.book.strikes).toHaveLength(3) + expect(next.book.qDn[1]).toBe(C(6)) + expect(next.aggregates.balance).toBe(aggregates.balance + C(1)) + expect(next.aggregates.totalMaxPayout).toBe( + aggregates.totalMaxPayout + C(5) + ) + }) + + test("new strike: inserted in sorted position", () => { + const next = applyProspectiveMint(book, aggregates, K(60_500), C(5), C(1)) + expect(next.book.strikes).toEqual([ + K(59_500), + K(60_000), + K(60_500), + K(61_000), + ]) + expect(next.book.qDn[2]).toBe(C(5)) + expect(next.book.qUp[2]).toBe(0n) + }) + + test("the wash is visible: our own mint raises our crash liability share", () => { + // Before: crash liability 18. After minting 5 DN @ 60000 for premium 1: + // crash liability 23, balance +1 -> the pool (which we partly own) pays + // more in the crash than the premium it collected. + const next = applyProspectiveMint(book, aggregates, K(60_000), C(5), C(1)) + const curve = buildLiabilityCurve(next.book, next.aggregates) + expect(curve.liabilityAt(K(59_000))).toBe(C(23)) + expect(next.aggregates.balance - aggregates.balance).toBe(C(1)) + }) + + test("does not mutate the input book", () => { + applyProspectiveMint(book, aggregates, K(60_000), C(5), C(1)) + expect(book.qDn[1]).toBe(C(1)) + }) +}) diff --git a/services/operator/src/model/pool.ts b/services/operator/src/model/pool.ts new file mode 100644 index 0000000..55af0ec --- /dev/null +++ b/services/operator/src/model/pool.ts @@ -0,0 +1,102 @@ +// Pool liability curve + prospective accounting. +// Pure math, no I/O. +// +// Settlement semantics mirror predict's compute_price / evaluate_settled: +// at settlement S the pool pays UP holders at strikes k < S (S > k) and DN +// holders at strikes k >= S (DN wins at-or-below), minus the aggregate +// range-mint adjustment (see strike_matrix.move docs on range_qty). + +import type { PoolAggregates, PoolBook } from "./types.ts" + +export interface LiabilityCurve { + /// Pool payout (quote units) if settlement lands at S. + liabilityAt: (settlement: bigint) => bigint + /// Pool value at settlement: balance - liability. + poolValueAt: (settlement: bigint) => bigint +} + +export function buildLiabilityCurve( + book: PoolBook, + aggregates: Pick +): LiabilityCurve { + const { strikes, qUp, qDn, rangeQty } = book + const count = strikes.length + + // Prefix sums: upBelow[i] = total q_up for strikes[0..i-1], + // dnFrom[i] = total q_dn for strikes[i..count-1]. + const upBelow: bigint[] = new Array(count + 1) + upBelow[0] = 0n + for (let i = 0; i < count; i += 1) { + upBelow[i + 1] = upBelow[i]! + qUp[i]! + } + const dnFrom: bigint[] = new Array(count + 1) + dnFrom[count] = 0n + for (let i = count - 1; i >= 0; i -= 1) { + dnFrom[i] = dnFrom[i + 1]! + qDn[i]! + } + + // First index with strike >= S (binary search). + function lowerBound(settlement: bigint): number { + let lo = 0 + let hi = count + while (lo < hi) { + const mid = (lo + hi) >> 1 + if (strikes[mid]! < settlement) { + lo = mid + 1 + } else { + hi = mid + } + } + return lo + } + + function liabilityAt(settlement: bigint): bigint { + const index = lowerBound(settlement) + // UP pays where strike < S; DN pays where strike >= S (at-or-below win). + const gross = upBelow[index]! + dnFrom[index]! + const net = gross - rangeQty + return net > 0n ? net : 0n + } + + function poolValueAt(settlement: bigint): bigint { + return aggregates.balance - liabilityAt(settlement) + } + + return { liabilityAt, poolValueAt } +} + +/// Prospective accounting for OUR OWN hedge mint (§2): premium flows INTO the +/// pool balance and the DN inventory at the hedge strike grows by the hedge +/// quantity, so the self-referential wash is captured exactly by valuation. +export function applyProspectiveMint( + book: PoolBook, + aggregates: PoolAggregates, + strike: bigint, + quantity: bigint, + premium: bigint +): { book: PoolBook; aggregates: PoolAggregates } { + const index = book.strikes.findIndex((k) => k >= strike) + const insertAt = index === -1 ? book.strikes.length : index + const exists = book.strikes[insertAt] === strike + + const strikes = [...book.strikes] + const qUp = [...book.qUp] + const qDn = [...book.qDn] + + if (exists) { + qDn[insertAt] = qDn[insertAt]! + quantity + } else { + strikes.splice(insertAt, 0, strike) + qUp.splice(insertAt, 0, 0n) + qDn.splice(insertAt, 0, quantity) + } + + return { + book: { strikes, qUp, qDn, rangeQty: book.rangeQty }, + aggregates: { + ...aggregates, + balance: aggregates.balance + premium, + totalMaxPayout: aggregates.totalMaxPayout + quantity, + }, + } +} diff --git a/services/operator/src/model/pricer.ts b/services/operator/src/model/pricer.ts new file mode 100644 index 0000000..7097033 --- /dev/null +++ b/services/operator/src/model/pricer.ts @@ -0,0 +1,198 @@ +// Batched grid quoter: +// price many strikes of one oracle in as few devInspect simulations as +// possible. Predict's get_trade_amounts ABORTS on saturated/unmintable +// strikes, and one abort fails the whole batch — so failed batches bisect down +// to single strikes and saturated singles are skipped. + +import { bcs } from "@mysten/sui/bcs" +import { Transaction } from "@mysten/sui/transactions" + +import type { SuiClient } from "../sui.ts" +import type { GridQuote } from "./types.ts" + +export interface PricerTarget { + predictPackageId: string + predictObjectId: string + clockObjectId: string +} + +export interface GridQuoteRequest { + oracleId: string + expiryMs: number + strikes: bigint[] + /// Probe quantity per strike, quote units (1_000_000n = one $1 contract). + quantity: bigint + isUp: boolean + /// Any valid address; simulation runs with checks disabled. + senderAddress: string +} + +const MAX_STRIKES_PER_SIMULATION = 48 +const CACHE_TTL_MS = 2_000 + +interface CacheEntry { + quote: GridQuote | undefined // undefined = known-unmintable + expiresAtMs: number +} + +interface CommandOutput { + bcs: Uint8Array +} + +interface CommandResult { + returnValues?: CommandOutput[] +} + +function readU64(output: CommandOutput | undefined): bigint | undefined { + if (!output) { + return undefined + } + + return BigInt(bcs.U64.parse(output.bcs)) +} + +function buildGridQuoteTransaction( + target: PricerTarget, + request: GridQuoteRequest, + strikes: bigint[] +): Transaction { + const tx = new Transaction() + tx.setSender(request.senderAddress) + + for (const strike of strikes) { + const key = tx.moveCall({ + arguments: [ + tx.pure.id(request.oracleId), + tx.pure.u64(BigInt(request.expiryMs)), + tx.pure.u64(strike), + tx.pure.bool(request.isUp), + ], + target: `${target.predictPackageId}::market_key::new`, + }) + tx.moveCall({ + arguments: [ + tx.object(target.predictObjectId), + tx.object(request.oracleId), + key, + tx.pure.u64(request.quantity), + tx.object(target.clockObjectId), + ], + target: `${target.predictPackageId}::predict::get_trade_amounts`, + }) + } + + return tx +} + +export class GridPricer { + private readonly cache = new Map() + + constructor( + private readonly client: SuiClient, + private readonly target: PricerTarget + ) {} + + /// Quote every strike; unmintable (aborting) strikes are omitted from the + /// result rather than failing the sweep. + async quoteGrid(request: GridQuoteRequest): Promise { + const now = Date.now() + const fresh: GridQuote[] = [] + const missing: bigint[] = [] + + for (const strike of request.strikes) { + const entry = this.cache.get(this.cacheKey(request, strike)) + if (entry && entry.expiresAtMs > now) { + if (entry.quote) { + fresh.push(entry.quote) + } + } else { + missing.push(strike) + } + } + + for (let i = 0; i < missing.length; i += MAX_STRIKES_PER_SIMULATION) { + const page = missing.slice(i, i + MAX_STRIKES_PER_SIMULATION) + const quotes = await this.quoteBatch(request, page) + fresh.push(...quotes) + } + + return fresh.sort((a, b) => (a.strike < b.strike ? -1 : 1)) + } + + private cacheKey(request: GridQuoteRequest, strike: bigint): string { + return `${request.oracleId}:${request.isUp ? "u" : "d"}:${strike}:${request.quantity}` + } + + private store( + request: GridQuoteRequest, + strike: bigint, + quote: GridQuote | undefined + ) { + this.cache.set(this.cacheKey(request, strike), { + expiresAtMs: Date.now() + CACHE_TTL_MS, + quote, + }) + } + + /// Simulate one batch; on failure bisect down to single strikes so one + /// saturated strike can't hide the rest of the grid. + private async quoteBatch( + request: GridQuoteRequest, + strikes: bigint[] + ): Promise { + if (strikes.length === 0) { + return [] + } + + const transaction = buildGridQuoteTransaction(this.target, request, strikes) + const result = await this.client.simulateTransaction({ + checksEnabled: false, + include: { commandResults: true }, + transaction, + }) + + if (result.$kind === "Transaction") { + // commandResults sits at the TOP LEVEL of the simulate result, next to + // $kind/Transaction, not inside the Transaction payload. + const commandResults = + (result as { commandResults?: CommandResult[] }).commandResults ?? [] + const quotes: GridQuote[] = [] + + strikes.forEach((strike, index) => { + // Commands interleave (market_key::new, get_trade_amounts); the quote + // for strike i is command 2i + 1. + const output = commandResults[2 * index + 1]?.returnValues + const mintCost = readU64(output?.[0]) + const redeemPayout = readU64(output?.[1]) + + if (mintCost === undefined || redeemPayout === undefined) { + this.store(request, strike, undefined) + return + } + + const quote: GridQuote = { mintCost, redeemPayout, strike } + this.store(request, strike, quote) + quotes.push(quote) + }) + + return quotes + } + + if (strikes.length === 1) { + // Single saturated/unmintable strike: remember and skip. + this.store(request, strikes[0]!, undefined) + return [] + } + + const midpoint = strikes.length >> 1 + const left = await this.quoteBatch(request, strikes.slice(0, midpoint)) + const right = await this.quoteBatch(request, strikes.slice(midpoint)) + + return [...left, ...right] + } +} + +/// Per-contract UP mid in [0, 1] from a probe quote. +export function unitMidUp(quote: GridQuote, quantity: bigint): number { + return Number(quote.mintCost + quote.redeemPayout) / (2 * Number(quantity)) +} diff --git a/services/operator/src/model/reads.ts b/services/operator/src/model/reads.ts new file mode 100644 index 0000000..6b1a4ba --- /dev/null +++ b/services/operator/src/model/reads.ts @@ -0,0 +1,223 @@ +// On-chain reads for the strategy model — the +// only I/O module. Field paths and the page→strike slot mapping were proven +// live by scripts/pool-book-spike.ts. + +import type { SuiClient } from "../sui.ts" +import type { PoolAggregates, PoolBook } from "./types.ts" + +export type ReadSource = "chain" + +interface JsonObject { + [key: string]: unknown +} + +async function objectJson(client: SuiClient, objectId: string): Promise { + const { object } = await client.getObject({ objectId, include: { json: true } }) + const json = (object as { json?: unknown }).json + + if (json === null || typeof json !== "object") { + throw new Error(`object ${objectId} returned no json content`) + } + + return json as JsonObject +} + +function bigintField(source: JsonObject, field: string, context: string): bigint { + const value = source[field] + + if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") { + throw new Error(`${context}.${field} missing or non-numeric`) + } + + return BigInt(value) +} + +function tableId(source: JsonObject, field: string, context: string): string { + const value = source[field] + + if (value === null || typeof value !== "object" || typeof (value as JsonObject).id !== "string") { + throw new Error(`${context}.${field} is not a table reference`) + } + + return (value as { id: string }).id +} + +/// Decode a dynamic-field name's BCS byte map ({"0": 25, "1": 88, ...}). +function bcsBytes(name: unknown): number[] { + const bcs = (name as { bcs?: Record } | null)?.bcs + + if (!bcs || typeof bcs !== "object") { + throw new Error("dynamic field name has no bcs bytes") + } + + return Object.keys(bcs) + .map(Number) + .sort((a, b) => a - b) + .map((index) => bcs[String(index)]!) +} + +function bytesToHex(bytes: number[]): string { + return `0x${bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("")}` +} + +function bytesToU64LittleEndian(bytes: number[]): bigint { + return bytes.reduce((acc, byte, index) => acc + (BigInt(byte) << BigInt(8 * index)), 0n) +} + +async function listAllDynamicFields(client: SuiClient, parentId: string) { + const fields: { fieldId: string; nameBytes: number[] }[] = [] + let cursor: string | undefined + + do { + const page = await client.listDynamicFields({ cursor, parentId }) + for (const field of page.dynamicFields) { + fields.push({ + fieldId: field.fieldId as string, + nameBytes: bcsBytes(field.name), + }) + } + cursor = page.hasNextPage ? ((page.cursor ?? undefined) as string | undefined) : undefined + } while (cursor) + + return fields +} + +/// Pool aggregates + PLP share supply from the Predict shared object. +export async function readPoolAggregates( + client: SuiClient, + predictObjectId: string +): Promise { + const predict = await objectJson(client, predictObjectId) + const vault = predict.vault + + if (vault === null || typeof vault !== "object") { + throw new Error("predict object has no vault field") + } + + const vaultJson = vault as JsonObject + const balance = bigintField(vaultJson, "balance", "vault") + const totalMtm = bigintField(vaultJson, "total_mtm", "vault") + const treasury = predict.treasury_cap as { total_supply?: { value?: unknown } } | undefined + const supplyValue = treasury?.total_supply?.value + + if (typeof supplyValue !== "string" && typeof supplyValue !== "number") { + throw new Error("predict.treasury_cap.total_supply.value missing") + } + + return { + balance, + plpSupply: BigInt(supplyValue), + totalMaxPayout: bigintField(vaultJson, "total_max_payout", "vault"), + totalMtm, + vaultValue: balance - totalMtm, + } +} + +export interface StrikeBookResult { + book: PoolBook + grid: { + tickSize: bigint + minStrike: bigint + maxStrike: bigint + mintedMin: bigint + mintedMax: bigint + } +} + +/// Per-strike pool inventory for one oracle, decoded from the vault's +/// StrikeMatrix table pages. Returns undefined when the oracle has no matrix +/// (never traded). +export async function readStrikeBook( + client: SuiClient, + predictObjectId: string, + oracleId: string +): Promise { + const predict = await objectJson(client, predictObjectId) + const matricesTableId = tableId(predict.vault as JsonObject, "oracle_matrices", "vault") + const matrixFields = await listAllDynamicFields(client, matricesTableId) + const normalizedOracle = oracleId.toLowerCase() + const matrixField = matrixFields.find( + (field) => bytesToHex(field.nameBytes) === normalizedOracle + ) + + if (!matrixField) { + return undefined + } + + const field = await objectJson(client, matrixField.fieldId) + const matrix = field.value + + if (matrix === null || typeof matrix !== "object") { + throw new Error("strike matrix field has no value") + } + + const matrixJson = matrix as JsonObject + const tickSize = bigintField(matrixJson, "tick_size", "matrix") + const minStrike = bigintField(matrixJson, "min_strike", "matrix") + const grid = { + maxStrike: bigintField(matrixJson, "max_strike", "matrix"), + minStrike, + mintedMax: bigintField(matrixJson, "minted_max_strike", "matrix"), + mintedMin: bigintField(matrixJson, "minted_min_strike", "matrix"), + tickSize, + } + const rangeQty = bigintField(matrixJson, "range_qty", "matrix") + + const pagesTableId = tableId(matrixJson, "pages", "matrix") + const pages = await listAllDynamicFields(client, pagesTableId) + + const rows: { strike: bigint; qUp: bigint; qDn: bigint }[] = [] + let pageSize = 0n + + for (const page of pages) { + const pageField = await objectJson(client, page.fieldId) + const nodes = pageField.value + + if (!Array.isArray(nodes)) { + throw new Error("strike matrix page has no node vector") + } + if (pageSize === 0n) { + pageSize = BigInt(nodes.length) + } + + const pageIndex = bytesToU64LittleEndian(page.nameBytes) + + nodes.forEach((node, slot) => { + const nodeJson = node as JsonObject + const qUp = bigintField(nodeJson, "q_up", "node") + const qDn = bigintField(nodeJson, "q_dn", "node") + + if (qUp === 0n && qDn === 0n) { + return + } + + rows.push({ + qDn, + qUp, + strike: minStrike + (pageIndex * pageSize + BigInt(slot)) * tickSize, + }) + }) + } + + rows.sort((a, b) => (a.strike < b.strike ? -1 : a.strike > b.strike ? 1 : 0)) + + return { + book: { + qDn: rows.map((row) => row.qDn), + qUp: rows.map((row) => row.qUp), + rangeQty, + strikes: rows.map((row) => row.strike), + }, + grid, + } +} + +/// Our strategy's PLP holdings (populated during a round; 0 between rounds). +export async function readOurPlpBalance( + client: SuiClient, + strategyId: string +): Promise { + const strategy = await objectJson(client, strategyId) + + return bigintField(strategy, "plp", "strategy") +} diff --git a/services/operator/src/model/sizer.test.ts b/services/operator/src/model/sizer.test.ts new file mode 100644 index 0000000..6ecc389 --- /dev/null +++ b/services/operator/src/model/sizer.test.ts @@ -0,0 +1,118 @@ +import { describe, expect, test } from "bun:test" + +import { buildLiabilityCurve } from "./pool.ts" +import { sizeHedge } from "./sizer.ts" +import type { HedgeCandidate, SizerConfig } from "./sizer.ts" +import type { PoolAggregates, PoolBook, Scenario } from "./types.ts" + +const K = (usd: number) => BigInt(usd) * 1_000_000_000n +const C = (contracts: number) => BigInt(contracts) * 1_000_000n + +// A pool that is heavily short the downside: big UP inventory below spot means +// a crash costs the pool (and its LPs) real money. +const book: PoolBook = { + qDn: [0n, 0n, C(5)], + qUp: [C(400), C(300), 0n], + rangeQty: 0n, + strikes: [K(60_000), K(62_000), K(64_000)], +} +const aggregates: PoolAggregates = { + balance: C(10_000), + plpSupply: C(10_000), + totalMaxPayout: C(705), + totalMtm: 0n, + vaultValue: C(10_000), +} +const curve = buildLiabilityCurve(book, aggregates) + +// Crash 10%, flat 85%, rally 5%. +const scenarios: Scenario[] = [ + { probability: 0.1, settlement: K(59_000) }, + { probability: 0.85, settlement: K(63_000) }, + { probability: 0.05, settlement: K(65_000) }, +] + +// Wait — for an LP, the pool LOSES when UP inventory pays, i.e. on the RALLY +// side here. Give the crash scenario the pool loss instead by flipping the +// book: pool is short DN (traders bought DN), so a crash makes it pay. +const crashBook: PoolBook = { + qDn: [C(400), C(300), 0n], + qUp: [0n, 0n, C(5)], + rangeQty: 0n, + strikes: [K(60_000), K(62_000), K(64_000)], +} +const crashCurve = buildLiabilityCurve(crashBook, aggregates) + +const candidates: HedgeCandidate[] = [ + { strike: K(60_000), unitAsk: 0.08 }, + { strike: K(62_000), unitAsk: 0.2 }, +] +const config: SizerConfig = { + alphaBps: 9_500, + budget: C(50), + minImprovement: C(1), + washMinMBps: 2_500, +} +const f = 0.05 // we own 5% of the pool + +describe("sizeHedge", () => { + test("buys a downside hedge that cuts tail loss, within budget", () => { + const result = sizeHedge(scenarios, crashCurve, aggregates.vaultValue, f, candidates, config) + + expect(result.hedge).toBeDefined() + expect(result.cvarAfter).toBeLessThan(result.cvarBefore) + expect(result.hedge!.premium).toBeLessThanOrEqual(config.budget) + expect(result.hedge!.quantity % 1_000_000n).toBe(0n) // whole contracts + }) + + test("skips as a wash when we own (almost) the whole pool", () => { + const result = sizeHedge( + scenarios, + crashCurve, + aggregates.vaultValue, + 0.9, + candidates, + config + ) + + expect(result.hedge).toBeUndefined() + expect(result.skippedReason).toBe("wash") + }) + + test("skips on zero budget", () => { + const result = sizeHedge(scenarios, crashCurve, aggregates.vaultValue, f, candidates, { + ...config, + budget: 0n, + }) + + expect(result.skippedReason).toBe("budget") + }) + + test("skips with no viable candidates", () => { + const result = sizeHedge(scenarios, crashCurve, aggregates.vaultValue, f, [], config) + + expect(result.skippedReason).toBe("no_viable_strike") + }) + + test("declines a hedge that cannot improve the tail", () => { + // Pool loses on RALLIES here (short UP book); a downside hedge is useless. + const result = sizeHedge(scenarios, curve, aggregates.vaultValue, f, candidates, config) + + expect(result.hedge).toBeUndefined() + expect(["negligible_improvement", "no_viable_strike"]).toContain( + result.skippedReason ?? "missing" + ) + }) + + test("overpriced insurance is refused", () => { + // Ask so far above fair value that buying it worsens expected loss AND + // cannot beat the improvement threshold. + const pricey: HedgeCandidate[] = [{ strike: K(60_000), unitAsk: 0.95 }] + const result = sizeHedge(scenarios, crashCurve, aggregates.vaultValue, f, pricey, { + ...config, + minImprovement: C(5), + }) + + expect(result.hedge).toBeUndefined() + }) +}) diff --git a/services/operator/src/model/sizer.ts b/services/operator/src/model/sizer.ts new file mode 100644 index 0000000..55526f6 --- /dev/null +++ b/services/operator/src/model/sizer.ts @@ -0,0 +1,229 @@ +// Hedge sizer: choose the downside strike and quantity that minimize the +// vault's tail risk, with the self-referential wash internalized exactly. +// Pure math, no I/O. +// +// Round P&L for LP share f, hedge (K, h) at unit ask a, premium P = h * a: +// pnl(S) = f * (V(S) - V_now) LP leg on the ORIGINAL pool book +// + (1 - f) * (h * 1{S <= K} - P) hedge leg net of pool recycling +// (Our premium raises the pool balance we own f of, and a crash payout is f +// ours to pay — both close to the (1 - f) factor above; u(k) stays diagnostic.) +// The sizer minimizes CVaR_alpha of -pnl over the risk-neutral scenarios, +// subject to the premium budget, and refuses to hedge when it can't help. + +import { cvar } from "./density.ts" +import type { LiabilityCurve } from "./pool.ts" +import type { HedgeSkipReason, Scenario } from "./types.ts" + +export interface HedgeCandidate { + strike: bigint + /// Executable DN ask per contract in [0, 1] (probe-quote derived). + unitAsk: number +} + +export interface SizerConfig { + alphaBps: number + budget: bigint + /// Skip hedging when (1 - f) falls below this (bps) — the wash guard. + washMinMBps: number + /// Skip hedging when the CVaR improvement is below this many quote units. + minImprovement: bigint +} + +export interface SizerResult { + hedge?: { strike: bigint; quantity: bigint; premium: bigint } + skippedReason?: HedgeSkipReason + cvarBefore: number + cvarAfter: number + expectedLossBefore: number + expectedLossAfter: number +} + +const QUANTITY_STEP = 1_000_000n // whole contracts + +interface Outcome { + loss: number + probability: number +} + +function roundOutcomes( + scenarios: Scenario[], + curve: LiabilityCurve, + vaultValueNow: bigint, + f: number, + candidate: HedgeCandidate | undefined, + quantity: bigint +): Outcome[] { + const multiplier = 1 - f + const premium = candidate + ? Number(quantity) * candidate.unitAsk + : 0 + + return scenarios.map((scenario) => { + const lpLeg = + f * Number(curve.poolValueAt(scenario.settlement) - vaultValueNow) + const hedgePayout = + candidate && scenario.settlement <= candidate.strike + ? Number(quantity) + : 0 + const hedgeLeg = multiplier * (hedgePayout - premium) + + return { loss: -(lpLeg + hedgeLeg), probability: scenario.probability } + }) +} + +function tailLoss(outcomes: Outcome[], alphaBps: number): number { + return cvar(outcomes, alphaBps / 10_000) +} + +function expectedLoss(outcomes: Outcome[]): number { + return outcomes.reduce( + (acc, outcome) => acc + outcome.loss * outcome.probability, + 0 + ) +} + +/// Ternary search over the (convex-in-h) tail objective on whole contracts. +function bestQuantityFor( + candidate: HedgeCandidate, + scenarios: Scenario[], + curve: LiabilityCurve, + vaultValueNow: bigint, + f: number, + config: SizerConfig +): { quantity: bigint; cvarAfter: number } { + const maxQuantity = + candidate.unitAsk > 0 + ? BigInt(Math.floor(Number(config.budget) / candidate.unitAsk)) + : 0n + const maxSteps = maxQuantity / QUANTITY_STEP + + const evaluate = (steps: bigint) => + tailLoss( + roundOutcomes( + scenarios, + curve, + vaultValueNow, + f, + candidate, + steps * QUANTITY_STEP + ), + config.alphaBps + ) + + let lo = 0n + let hi = maxSteps + while (hi - lo > 2n) { + const third = (hi - lo) / 3n + const m1 = lo + third + const m2 = hi - third + if (evaluate(m1) <= evaluate(m2)) { + hi = m2 + } else { + lo = m1 + } + } + + let best = { cvarAfter: evaluate(lo), quantity: lo * QUANTITY_STEP } + for (let steps = lo + 1n; steps <= hi; steps += 1n) { + const value = evaluate(steps) + if (value < best.cvarAfter) { + best = { cvarAfter: value, quantity: steps * QUANTITY_STEP } + } + } + + return best +} + +export function sizeHedge( + scenarios: Scenario[], + curve: LiabilityCurve, + vaultValueNow: bigint, + f: number, + candidates: HedgeCandidate[], + config: SizerConfig +): SizerResult { + const baselineOutcomes = roundOutcomes( + scenarios, + curve, + vaultValueNow, + f, + undefined, + 0n + ) + const cvarBefore = tailLoss(baselineOutcomes, config.alphaBps) + const expectedLossBefore = expectedLoss(baselineOutcomes) + const unhedged: SizerResult = { + cvarAfter: cvarBefore, + cvarBefore, + expectedLossAfter: expectedLossBefore, + expectedLossBefore, + } + + if (scenarios.length === 0 || candidates.length === 0) { + return { ...unhedged, skippedReason: "no_viable_strike" } + } + if (effective(f) * 10_000 < config.washMinMBps) { + return { ...unhedged, skippedReason: "wash" } + } + if (config.budget < QUANTITY_STEP / 100n) { + return { ...unhedged, skippedReason: "budget" } + } + + let best: + | { candidate: HedgeCandidate; quantity: bigint; cvarAfter: number } + | undefined + + for (const candidate of candidates) { + if (candidate.unitAsk <= 0 || candidate.unitAsk >= 1) { + continue + } + const result = bestQuantityFor( + candidate, + scenarios, + curve, + vaultValueNow, + f, + config + ) + if (result.quantity <= 0n) { + continue + } + if (!best || result.cvarAfter < best.cvarAfter) { + best = { candidate, cvarAfter: result.cvarAfter, quantity: result.quantity } + } + } + + if (!best) { + return { ...unhedged, skippedReason: "no_viable_strike" } + } + if (cvarBefore - best.cvarAfter < Number(config.minImprovement)) { + return { ...unhedged, skippedReason: "negligible_improvement" } + } + + const premiumFloat = Number(best.quantity) * best.candidate.unitAsk + const premium = BigInt(Math.ceil(premiumFloat)) + const hedgedOutcomes = roundOutcomes( + scenarios, + curve, + vaultValueNow, + f, + best.candidate, + best.quantity + ) + + return { + cvarAfter: best.cvarAfter, + cvarBefore, + expectedLossAfter: expectedLoss(hedgedOutcomes), + expectedLossBefore, + hedge: { + premium, + quantity: best.quantity, + strike: best.candidate.strike, + }, + } +} + +function effective(f: number): number { + return Math.min(1, Math.max(0, 1 - f)) +} diff --git a/services/operator/src/model/types.ts b/services/operator/src/model/types.ts new file mode 100644 index 0000000..21e5b4c --- /dev/null +++ b/services/operator/src/model/types.ts @@ -0,0 +1,94 @@ +// Strategy-model types. +// +// Unit conventions (get these wrong and everything is wrong): +// - quote amounts: bigint in DUSDC micro units (1 contract = 1_000_000 pays $1) +// - strikes: bigint at the on-chain 1e9 price scale +// - probabilities / CVaR: number in [0, 1] / quote-unit floats at the boundary + +export const QUOTE_UNIT = 1_000_000n +export const PRICE_SCALE = 1_000_000_000n + +export interface OracleGrid { + tickSize: bigint + minStrike: bigint + maxStrike: bigint + mintedMin: bigint + mintedMax: bigint +} + +/// Pool-wide open interest per strike for ONE oracle, sorted ascending by +/// strike. Only strikes with any inventory are present. +export interface PoolBook { + strikes: bigint[] + qUp: bigint[] + qDn: bigint[] + /// Aggregate range-mint adjustment; the vault's liability subtracts this + /// (see strike_matrix.move docs). + rangeQty: bigint +} + +export interface PoolAggregates { + balance: bigint + totalMtm: bigint + vaultValue: bigint + totalMaxPayout: bigint + plpSupply: bigint +} + +/// Risk-neutral settlement distribution recovered from the strike grid of +/// UP-binary mids: cdf[i] = P(S_T <= strikes[i]), isotonic-clamped. +export interface DensityCurve { + strikes: bigint[] + cdf: number[] + /// Probability mass BETWEEN strikes[i-1] and strikes[i] (pmf[0] pairs with + /// tailBelow at the low edge). + pmf: number[] + tailBelow: number + tailAbove: number + /// Largest monotonicity violation clamped away (butterfly-arb signal). + maxViolation: number +} + +/// One settlement scenario: a representative price (never exactly on a strike) +/// and its probability mass. +export interface Scenario { + settlement: bigint + probability: number +} + +export interface GridQuote { + strike: bigint + /// Executable cost / redeem for the probe quantity, in quote units. + mintCost: bigint + redeemPayout: bigint +} + +export interface HedgeDecisionDiagnostics { + f: number + uAtStrike?: number + mAtStrike?: number + fCapApplied: boolean + cvarBefore: number + cvarAfter: number + expectedLossBefore: number + expectedLossAfter: number + budgetBps: number + alphaBps: number + safeDepositHint: bigint + /// Hash of the decision inputs so anyone can reproduce the decision. + inputsHash: string +} + +export type HedgeSkipReason = + | "wash" + | "budget" + | "no_viable_strike" + | "no_book_data" + | "negligible_improvement" + +export interface HedgeDecision { + plpSupplyAmount: bigint + hedge?: { strike: bigint; quantity: bigint; premium: bigint } + skippedReason?: HedgeSkipReason + diagnostics: HedgeDecisionDiagnostics +} diff --git a/services/operator/src/model/wash.test.ts b/services/operator/src/model/wash.test.ts new file mode 100644 index 0000000..44ebeac --- /dev/null +++ b/services/operator/src/model/wash.test.ts @@ -0,0 +1,94 @@ +import { describe, expect, test } from "bun:test" + +import { + effectiveMultiplier, + lpShare, + prospectiveLpShare, + safeSupplyCap, + uAtStrike, +} from "./wash.ts" +import type { PoolBook } from "./types.ts" + +const C = (contracts: number) => BigInt(contracts) * 1_000_000n + +describe("lpShare", () => { + test("zero supply means zero share", () => { + expect(lpShare(0n, 0n)).toBe(0) + }) + + test("fraction of total supply", () => { + expect(lpShare(C(25), C(1_000))).toBeCloseTo(0.025, 12) + }) +}) + +describe("prospectiveLpShare", () => { + test("no amount keeps the current share", () => { + expect(prospectiveLpShare(C(25), C(1_000), C(1_000), 0n)).toBeCloseTo( + 0.025, + 12 + ) + }) + + test("supplying grows the share with proportional minting", () => { + // Pool value 1000, supply 1000 shares, we hold 0 and add 1000 quote: + // minted 1000 shares -> f = 1000/2000 = 0.5. + expect(prospectiveLpShare(0n, C(1_000), C(1_000), C(1_000))).toBeCloseTo( + 0.5, + 12 + ) + }) + + test("first supplier owns the pool", () => { + expect(prospectiveLpShare(0n, 0n, 0n, C(10))).toBe(1) + }) +}) + +describe("effectiveMultiplier", () => { + test("small f keeps the hedge nearly whole", () => { + expect(effectiveMultiplier(0.000005)).toBeCloseTo(1, 4) + }) + + test("f = 1 makes the hedge a pure wash", () => { + expect(effectiveMultiplier(1)).toBe(0) + }) +}) + +describe("uAtStrike", () => { + const book: PoolBook = { + qDn: [C(10)], + qUp: [0n], + rangeQty: 0n, + strikes: [60_000_000_000_000n], + } + + test("sole DN holder at an empty strike", () => { + expect(uAtStrike(book, 61_000_000_000_000n, 0n, C(5))).toBe(1) + }) + + test("share of an occupied strike", () => { + // Others hold 10, we add 5: u = 5/15. + expect(uAtStrike(book, 60_000_000_000_000n, 0n, C(5))).toBeCloseTo( + 1 / 3, + 12 + ) + }) +}) + +describe("safeSupplyCap", () => { + test("cap keeps the prospective share at fMax", () => { + const cap = safeSupplyCap(0n, C(1_000_000), C(1_000_000), 2_000) + const f = prospectiveLpShare(0n, C(1_000_000), C(1_000_000), cap) + expect(f).toBeLessThanOrEqual(0.2) + expect(f).toBeGreaterThan(0.199) // tight, not lazily small + }) + + test("already over the cap returns zero", () => { + expect(safeSupplyCap(C(300_000), C(1_000_000), C(1_000_000), 2_000)).toBe( + 0n + ) + }) + + test("rejects a nonsense cap", () => { + expect(() => safeSupplyCap(0n, C(1), C(1), 10_000)).toThrow() + }) +}) diff --git a/services/operator/src/model/wash.ts b/services/operator/src/model/wash.ts new file mode 100644 index 0000000..4151e4f --- /dev/null +++ b/services/operator/src/model/wash.ts @@ -0,0 +1,92 @@ +// LP-share math and self-referential-hedge guards. Pure math, no I/O. +// +// A vault that supplies PLP and buys its hedge FROM THE SAME POOL recycles its +// own flows: the premium it pays lands (share f) in its own pool balance and a +// crash payout is (share f) its own liability. With exact accounting the net +// hedge effect scales by (1 - f); as f -> 1 the hedge becomes a wash no matter +// its size. These helpers compute f, the effective multiplier, the strike-local +// ownership diagnostic u(k), and the safe-supply cap that keeps hedging real. + +import type { PoolBook } from "./types.ts" + +/// Our LP share fraction given our PLP shares and the total supply. +export function lpShare(ourShares: bigint, totalSupply: bigint): number { + if (totalSupply <= 0n) { + return 0 + } + + return Number(ourShares) / Number(totalSupply) +} + +/// Our prospective LP share AFTER supplying `amount` quote units, mirroring +/// predict::supply's proportional mint (shares = amount * supply / vaultValue). +export function prospectiveLpShare( + ourShares: bigint, + totalSupply: bigint, + vaultValue: bigint, + amount: bigint +): number { + if (amount <= 0n) { + return lpShare(ourShares, totalSupply) + } + if (totalSupply <= 0n || vaultValue <= 0n) { + return 1 // first supplier owns the pool + } + + const minted = (amount * totalSupply) / vaultValue + + return Number(ourShares + minted) / Number(totalSupply + minted) +} + +/// Effective hedge multiplier: the fraction of each hedge dollar that is NOT +/// recycled through our own pool share. +export function effectiveMultiplier(f: number): number { + return Math.min(1, Math.max(0, 1 - f)) +} + +/// Strike-local DN-ownership share after our prospective mint — a disclosure +/// diagnostic (the exact objective already internalizes the wash). +export function uAtStrike( + book: PoolBook, + strike: bigint, + ourExistingDn: bigint, + hedgeQuantity: bigint +): number { + const index = book.strikes.findIndex((k) => k === strike) + const poolDn = index === -1 ? 0n : book.qDn[index]! + const total = poolDn + hedgeQuantity + + if (total <= 0n) { + return 1 + } + + return Number(ourExistingDn + hedgeQuantity) / Number(total) +} + +/// Largest additional PLP supply (quote units) keeping our prospective share +/// at or under fMaxBps. This is the "safe deposit size" disclosure. +export function safeSupplyCap( + ourShares: bigint, + totalSupply: bigint, + vaultValue: bigint, + fMaxBps: number +): bigint { + if (fMaxBps <= 0 || fMaxBps >= 10_000) { + throw new Error("fMaxBps must be in (0, 10000)") + } + if (totalSupply <= 0n || vaultValue <= 0n) { + return 0n + } + + const fMax = BigInt(Math.trunc(fMaxBps)) + // Solve for minted m: (our + m) / (supply + m) <= fMax/10000 + // m <= (fMax * supply - 10000 * our) / (10000 - fMax) + const numerator = fMax * totalSupply - 10_000n * ourShares + if (numerator <= 0n) { + return 0n // already at or over the cap + } + const mintedCap = numerator / (10_000n - fMax) + + // Convert share cap back to a quote amount (shares = amount * supply / value). + return (mintedCap * vaultValue) / totalSupply +} diff --git a/services/operator/src/sui.ts b/services/operator/src/sui.ts index a036a7e..4e83e87 100644 --- a/services/operator/src/sui.ts +++ b/services/operator/src/sui.ts @@ -13,6 +13,7 @@ type WaitForTransaction = SuiGrpcClient["waitForTransaction"] export interface SuiClient { getObject: SuiGrpcClient["getObject"] + listDynamicFields: SuiGrpcClient["listDynamicFields"] signAndExecuteTransaction: SignAndExecuteTransaction simulateTransaction: SimulateTransaction waitForTransaction: WaitForTransaction @@ -47,6 +48,12 @@ class RotatingSuiClient implements SuiClient { readonly getObject: SuiGrpcClient["getObject"] = ((input) => this.withEndpointRetry((client) => client.getObject(input), "getObject")) as SuiGrpcClient["getObject"] + readonly listDynamicFields: SuiGrpcClient["listDynamicFields"] = ((input) => + this.withEndpointRetry( + (client) => client.listDynamicFields(input), + "listDynamicFields" + )) as SuiGrpcClient["listDynamicFields"] + readonly signAndExecuteTransaction: SignAndExecuteTransaction = ((input) => this.withEndpointRetry( (client) => client.signAndExecuteTransaction(input), diff --git a/web/src/lib/config.ts b/web/src/lib/config.ts index 69ea149..a343272 100644 --- a/web/src/lib/config.ts +++ b/web/src/lib/config.ts @@ -55,7 +55,7 @@ export const PROTECT_ORIGINAL_PACKAGE_ID = PROTECT_PACKAGE_ID export const SUI_GRPC_URL = "https://fullnode.testnet.sui.io:443" -// Trade-ticket quote freshness (plans/price-proof.md §C). A displayed quote +// Trade-ticket quote freshness. A displayed quote // older than the TTL re-quotes automatically, and the submit path re-quotes at // sign time, aborting if the executable cost moved beyond the tolerance so a // stale price is never signed. diff --git a/web/src/lib/market-svi.golden.test.ts b/web/src/lib/market-svi.golden.test.ts index 17d1b4a..84f98c4 100644 --- a/web/src/lib/market-svi.golden.test.ts +++ b/web/src/lib/market-svi.golden.test.ts @@ -4,7 +4,7 @@ import { computeFairUpProbability } from "./market-svi" import { getOracleState, getPredictOracles } from "@/services/predict-client" import { quotePredictTradeSafe } from "@/services/predict-quotes" -// Live golden test (plans/price-proof.md §B): our client fair value must +// Live golden test: our client fair value must // reconcile to the CHAIN's own quoted mid within a cent per $1 contract. // // chain mid = (mint_cost + redeem_payout) / (2 * quantity) via devInspect diff --git a/web/src/lib/market-svi.test.ts b/web/src/lib/market-svi.test.ts index c63a7d3..49eeb0c 100644 --- a/web/src/lib/market-svi.test.ts +++ b/web/src/lib/market-svi.test.ts @@ -4,7 +4,7 @@ import { computeFairUpProbability } from "./market-svi" import vectors from "./market-svi.vectors.json" import type { OracleSviUpdate } from "@/lib/types/predict" -// Reference vectors for the SVI -> N(d2) fair-value math (plans/price-proof.md §A). +// Reference vectors for the SVI -> N(d2) fair-value math. // // Expected values are computed with Python's float64 math.erf (~1e-16 accurate) // over the EXACT formula in Predict's oracle.move `compute_nd2`: From 0d56bcf7ed4c6b9e0030de2ccbcdf92d0255d385 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 12:21:35 +0100 Subject: [PATCH 05/33] feat(operator): decide hedges from live pool risk with shadow and cvar rollout modes --- services/operator/src/config.ts | 47 +++- services/operator/src/model/decide.ts | 258 ++++++++++++++++++ services/operator/src/model/reads.ts | 34 ++- .../operator/src/strategies/hedged-plp.ts | 59 ++++ 4 files changed, 391 insertions(+), 7 deletions(-) create mode 100644 services/operator/src/model/decide.ts diff --git a/services/operator/src/config.ts b/services/operator/src/config.ts index 8b499df..6934349 100644 --- a/services/operator/src/config.ts +++ b/services/operator/src/config.ts @@ -26,11 +26,21 @@ export interface HedgedPlpConfig { hedgeQuantityBpsOfNav: number keeperCapId: string managerId: string + model: "bps" | "shadow" | "cvar" packageId: string strikeSpotBps: number strategyId: string } +export interface ModelConfig { + alphaBps: number + budgetBps: number + fMaxBps: number + minImprovementBps: number + minOtmTicks: number + washMinMBps: number +} + export interface RangeLadderConfig { enabled: boolean keeperCapId: string @@ -68,6 +78,7 @@ export interface OperatorConfig { bullishUpside: BullishUpsideConfig dryRun: boolean hedgedPlp: HedgedPlpConfig + model: ModelConfig plpCollar: DualLegConfig pollSeconds: number predict: PredictConfig @@ -90,6 +101,15 @@ function envString(defaultValue: string) { ) } +// On-chain ids must be clean 0x-hex: a stray interior space (seen in the wild +// in a hand-edited .env) silently corrupts every read that uses the id. +function envObjectId(defaultValue: string) { + return z.preprocess( + (value) => (typeof value === "string" && value.trim() !== "" ? value.trim() : defaultValue), + z.string().regex(/^0x[0-9a-fA-F]{1,64}$/, "must be a 0x-hex object id with no whitespace") + ) +} + function envNumber(defaultValue: number) { return z.preprocess((value) => { if (typeof value !== "string" || value.trim() === "") { @@ -136,9 +156,9 @@ const envSchema = z ), SUI_RPC_URL: envString("https://fullnode.testnet.sui.io:443"), SUI_RPC_URLS: optionalRpcUrls, - CLOCK_OBJECT_ID: envString("0x6"), - PREDICT_PACKAGE_ID: envString("0xf5ea2b3749c65d6e56507cc35388719aadb28f9cab873696a2f8687f5c785138"), - PREDICT_OBJECT_ID: envString("0xc8736204d12f0a7277c86388a68bf8a194b0a14c5538ad13f22cbd8e2a38028a"), + CLOCK_OBJECT_ID: envObjectId("0x6"), + PREDICT_PACKAGE_ID: envObjectId("0xf5ea2b3749c65d6e56507cc35388719aadb28f9cab873696a2f8687f5c785138"), + PREDICT_OBJECT_ID: envObjectId("0xc8736204d12f0a7277c86388a68bf8a194b0a14c5538ad13f22cbd8e2a38028a"), PREDICT_QUOTE_ASSET: envString( "0xe95040085976bfd54a1a07225cd46c8a2b4e8e2b6732f140a0fc49850ba73e1a::dusdc::DUSDC" ), @@ -155,6 +175,18 @@ const envSchema = z HEDGED_PLP_ENABLED: envBoolean(true), HEDGED_PLP_HEDGE_QUANTITY_BPS_OF_NAV: envNumber(250), HEDGED_PLP_STRIKE_SPOT_BPS: envNumber(9_900), + // Rollout stages for the exposure model: bps (legacy sizing, default) -> + // shadow (model computes + logs, bps executes) -> cvar (model executes). + HEDGED_PLP_MODEL: z + .enum(["bps", "shadow", "cvar"]) + .default("bps") + .catch("bps"), + MODEL_CVAR_ALPHA_BPS: envNumber(9_500), + MODEL_BUDGET_BPS: envNumber(100), + MODEL_WASH_MIN_M_BPS: envNumber(2_500), + MODEL_MIN_IMPROVEMENT_BPS: envNumber(10), + MODEL_F_MAX_BPS: envNumber(2_000), + MODEL_MIN_OTM_TICKS: envNumber(1), RANGE_LADDER_ENABLED: envBoolean(true), RANGE_QUANTITY_BPS_OF_NAV: envNumber(250), RANGE_RUNG_COUNT: envNumber(2), @@ -321,10 +353,19 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): OperatorConfig hedgeQuantityBpsOfNav: parsed.HEDGED_PLP_HEDGE_QUANTITY_BPS_OF_NAV, keeperCapId: deployment.hedgedPlp.keeperCapId, managerId: deployment.hedgedPlp.managerId, + model: parsed.HEDGED_PLP_MODEL, packageId: deployment.hedgedPlp.packageId, strikeSpotBps: parsed.HEDGED_PLP_STRIKE_SPOT_BPS, strategyId: deployment.hedgedPlp.strategyId, }, + model: { + alphaBps: parsed.MODEL_CVAR_ALPHA_BPS, + budgetBps: parsed.MODEL_BUDGET_BPS, + fMaxBps: parsed.MODEL_F_MAX_BPS, + minImprovementBps: parsed.MODEL_MIN_IMPROVEMENT_BPS, + minOtmTicks: parsed.MODEL_MIN_OTM_TICKS, + washMinMBps: parsed.MODEL_WASH_MIN_M_BPS, + }, suiNetwork: parsed.SUI_NETWORK, suiRpcUrl, suiRpcUrls: dedupe([...(parsed.SUI_RPC_URLS ?? []), suiRpcUrl]), diff --git a/services/operator/src/model/decide.ts b/services/operator/src/model/decide.ts new file mode 100644 index 0000000..90c151e --- /dev/null +++ b/services/operator/src/model/decide.ts @@ -0,0 +1,258 @@ +// Strategy-facing model façade: read the live pool, recover the risk-neutral +// settlement density from real quotes, and size the downside hedge by tail +// risk. Never throws on data problems — it returns a skipped decision so the +// driver can fall back to legacy sizing. + +import { createHash } from "node:crypto" + +import { bpsAmount, floorToGrid } from "../grid.ts" +import type { OperatorConfig } from "../config.ts" +import type { OracleInfo } from "../predict.ts" +import type { SuiClient } from "../sui.ts" +import { buildDensity, densityScenarios } from "./density.ts" +import { buildLiabilityCurve } from "./pool.ts" +import { GridPricer, unitMidUp } from "./pricer.ts" +import { readPoolAggregates, readStrikeBook } from "./reads.ts" +import { sizeHedge } from "./sizer.ts" +import type { HedgeCandidate } from "./sizer.ts" +import type { HedgeDecision, PoolBook } from "./types.ts" +import { + effectiveMultiplier, + prospectiveLpShare, + safeSupplyCap, + uAtStrike, +} from "./wash.ts" + +const PROBE_QUANTITY = 1_000_000n +const ATM_LADDER_BPS = [25, 50, 100, 200, 400, 800] +const MAX_DENSITY_STRIKES = 80 +const MAX_HEDGE_CANDIDATES = 10 +const MIN_DENSITY_QUOTES = 3 +// Density strikes are quoted only inside this band around spot: essentially +// all risk-neutral mass lives here, and far-from-spot strikes mostly abort +// the quote call (saturated), costing a bisect cascade to discover. The +// liability curve still uses the FULL book — only the quoted grid is banded. +const DENSITY_BAND_BPS = 1_000n + +export interface DecideHedgedPlpInput { + client: SuiClient + config: OperatorConfig + nav: bigint + oracle: OracleInfo + ourPlpShares: bigint + sender: string + spot: bigint +} + +const EMPTY_BOOK: PoolBook = { qDn: [], qUp: [], rangeQty: 0n, strikes: [] } + +function skipped( + reason: HedgeDecision["skippedReason"], + nav: bigint, + budgetBps: number, + alphaBps: number +): HedgeDecision { + return { + diagnostics: { + alphaBps, + budgetBps, + cvarAfter: 0, + cvarBefore: 0, + expectedLossAfter: 0, + expectedLossBefore: 0, + f: 0, + fCapApplied: false, + inputsHash: "", + safeDepositHint: 0n, + }, + plpSupplyAmount: nav, + skippedReason: reason, + } +} + +function hashInputs(payload: unknown): string { + const json = JSON.stringify(payload, (_key, value: unknown) => + typeof value === "bigint" ? value.toString() : value + ) + + return createHash("sha256").update(json).digest("hex") +} + +/// Candidate density strikes: the pool book's breakpoints plus an ATM ladder +/// around spot, snapped to the oracle grid, capped by distance from spot. +function densityStrikes( + book: PoolBook, + oracle: OracleInfo, + spot: bigint +): bigint[] { + const bandLow = (spot * (10_000n - DENSITY_BAND_BPS)) / 10_000n + const bandHigh = (spot * (10_000n + DENSITY_BAND_BPS)) / 10_000n + const unique = new Set( + book.strikes.filter((strike) => strike >= bandLow && strike <= bandHigh) + ) + + for (const bps of ATM_LADDER_BPS) { + for (const sign of [-1, 1]) { + const target = (spot * BigInt(10_000 + sign * bps)) / 10_000n + const snapped = floorToGrid(target, oracle.minStrike, oracle.tickSize) + if (snapped > 0n) { + unique.add(snapped) + } + } + } + + const sorted = [...unique].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)) + if (sorted.length <= MAX_DENSITY_STRIKES) { + return sorted + } + + return sorted + .map((strike) => ({ + distance: strike > spot ? strike - spot : spot - strike, + strike, + })) + .sort((a, b) => (a.distance < b.distance ? -1 : 1)) + .slice(0, MAX_DENSITY_STRIKES) + .map((entry) => entry.strike) + .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)) +} + +export async function decideHedgedPlp( + input: DecideHedgedPlpInput +): Promise { + const { client, config, nav, oracle, ourPlpShares, sender, spot } = input + const { alphaBps, budgetBps, fMaxBps, minImprovementBps, minOtmTicks, washMinMBps } = + config.model + + let aggregates + let bookResult + try { + aggregates = await readPoolAggregates(client, config.predict.sharedObjectId) + bookResult = await readStrikeBook( + client, + config.predict.sharedObjectId, + oracle.oracleId + ) + } catch { + return skipped("no_book_data", nav, budgetBps, alphaBps) + } + + const book = bookResult?.book ?? EMPTY_BOOK + + // An empty book means the pool carries no liability on this oracle: the LP + // leg is flat and no hedge can improve it. Skip before spending ~100 quote + // simulations discovering that the hard way. + if (book.strikes.length === 0) { + return skipped("no_book_data", nav, budgetBps, alphaBps) + } + + const pricer = new GridPricer(client, { + clockObjectId: config.predict.clockObjectId, + predictObjectId: config.predict.sharedObjectId, + predictPackageId: config.predict.packageId, + }) + + const strikes = densityStrikes(book, oracle, spot) + const upQuotes = await pricer.quoteGrid({ + expiryMs: Number(oracle.expiryMs), + isUp: true, + oracleId: oracle.oracleId, + quantity: PROBE_QUANTITY, + senderAddress: sender, + strikes, + }) + if (upQuotes.length < MIN_DENSITY_QUOTES) { + return skipped("no_book_data", nav, budgetBps, alphaBps) + } + + const density = buildDensity({ + midUp: upQuotes.map((quote) => unitMidUp(quote, PROBE_QUANTITY)), + strikes: upQuotes.map((quote) => quote.strike), + }) + const scenarios = densityScenarios(density, oracle.tickSize) + const curve = buildLiabilityCurve(book, aggregates) + + // Conservative prospective LP share: assume the whole NAV supplies PLP this + // round (the on-chain policy allocates at most that). + const f = prospectiveLpShare( + ourPlpShares, + aggregates.plpSupply, + aggregates.vaultValue, + nav + ) + + // Hedge candidates: on-grid strikes strictly below spot by the OTM floor. + const otmCeiling = spot - BigInt(minOtmTicks) * oracle.tickSize + const candidateStrikes = strikes + .filter((strike) => strike <= otmCeiling) + .slice(-MAX_HEDGE_CANDIDATES) + const dnQuotes = await pricer.quoteGrid({ + expiryMs: Number(oracle.expiryMs), + isUp: false, + oracleId: oracle.oracleId, + quantity: PROBE_QUANTITY, + senderAddress: sender, + strikes: candidateStrikes, + }) + const candidates: HedgeCandidate[] = dnQuotes + .map((quote) => ({ + strike: quote.strike, + unitAsk: Number(quote.mintCost) / Number(PROBE_QUANTITY), + })) + .filter((candidate) => candidate.unitAsk > 0 && candidate.unitAsk < 1) + + const budget = bpsAmount(nav, budgetBps) + const result = sizeHedge(scenarios, curve, aggregates.vaultValue, f, candidates, { + alphaBps, + budget, + minImprovement: bpsAmount(nav, minImprovementBps), + washMinMBps, + }) + + const inputsHash = hashInputs({ + aggregates, + book, + config: config.model, + f, + mids: upQuotes.map((quote) => unitMidUp(quote, PROBE_QUANTITY)), + nav, + oracleId: oracle.oracleId, + strikes: upQuotes.map((quote) => quote.strike), + }) + + return { + diagnostics: { + alphaBps, + budgetBps, + cvarAfter: result.cvarAfter, + cvarBefore: result.cvarBefore, + expectedLossAfter: result.expectedLossAfter, + expectedLossBefore: result.expectedLossBefore, + f, + fCapApplied: false, + inputsHash, + mAtStrike: result.hedge ? effectiveMultiplier(f) : undefined, + safeDepositHint: safeSupplyCap( + ourPlpShares, + aggregates.plpSupply, + aggregates.vaultValue, + fMaxBps + ), + uAtStrike: result.hedge + ? uAtStrike(book, result.hedge.strike, 0n, result.hedge.quantity) + : undefined, + }, + hedge: result.hedge, + plpSupplyAmount: nav, + skippedReason: result.skippedReason, + } +} + +/// Bigint-safe log projection of a decision (pino drops bigints otherwise). +export function decisionLogFields(decision: HedgeDecision): Record { + return JSON.parse( + JSON.stringify(decision, (_key, value: unknown) => + typeof value === "bigint" ? value.toString() : value + ) + ) as Record +} diff --git a/services/operator/src/model/reads.ts b/services/operator/src/model/reads.ts index 6b1a4ba..8fc5030 100644 --- a/services/operator/src/model/reads.ts +++ b/services/operator/src/model/reads.ts @@ -64,6 +64,30 @@ function bytesToU64LittleEndian(bytes: number[]): bigint { return bytes.reduce((acc, byte, index) => acc + (BigInt(byte) << BigInt(8 * index)), 0n) } +/// Run tasks with bounded concurrency, preserving input order in the results. +async function mapConcurrent( + items: T[], + limit: number, + task: (item: T) => Promise +): Promise { + const results = new Array(items.length) + let next = 0 + + async function worker() { + while (next < items.length) { + const index = next + next += 1 + results[index] = await task(items[index]!) + } + } + + await Promise.all( + Array.from({ length: Math.min(limit, items.length) }, () => worker()) + ) + + return results +} + async function listAllDynamicFields(client: SuiClient, parentId: string) { const fields: { fieldId: string; nameBytes: number[] }[] = [] let cursor: string | undefined @@ -167,11 +191,13 @@ export async function readStrikeBook( const pages = await listAllDynamicFields(client, pagesTableId) const rows: { strike: bigint; qUp: bigint; qDn: bigint }[] = [] + const pageFields = await mapConcurrent(pages, 8, (page) => + objectJson(client, page.fieldId) + ) let pageSize = 0n - for (const page of pages) { - const pageField = await objectJson(client, page.fieldId) - const nodes = pageField.value + pages.forEach((page, pageOrdinal) => { + const nodes = pageFields[pageOrdinal]!.value if (!Array.isArray(nodes)) { throw new Error("strike matrix page has no node vector") @@ -197,7 +223,7 @@ export async function readStrikeBook( strike: minStrike + (pageIndex * pageSize + BigInt(slot)) * tickSize, }) }) - } + }) rows.sort((a, b) => (a.strike < b.strike ? -1 : a.strike > b.strike ? 1 : 0)) diff --git a/services/operator/src/strategies/hedged-plp.ts b/services/operator/src/strategies/hedged-plp.ts index dc22178..ff74e48 100644 --- a/services/operator/src/strategies/hedged-plp.ts +++ b/services/operator/src/strategies/hedged-plp.ts @@ -3,6 +3,7 @@ import { Transaction } from "@mysten/sui/transactions" import type { OperatorConfig } from "../config.ts" import { bpsAmount, chooseDownsideStrike } from "../grid.ts" import { toLogFields } from "../logger.ts" +import { decideHedgedPlp, decisionLogFields } from "../model/decide.ts" import type { OracleInfo } from "../predict.ts" import { simulateTransaction } from "../sui.ts" import { readHedgedPlpStrategy, type HedgedPlpStrategyState } from "../strategy-state.ts" @@ -109,6 +110,64 @@ export const hedgedPlpDriver: StrategyDriver = { async selectStartCandidate(context, state): Promise { const { client, config, log, oracle, sender, spot } = context + // Exposure model rollout: shadow computes + logs the model's decision but + // executes the legacy sizing below; cvar executes the model's hedge and + // only falls back to legacy sizing when the decision is skipped or the + // chosen legs fail simulation (never brick the round). + if (config.hedgedPlp.model !== "bps") { + const decision = await decideHedgedPlp({ + client, + config, + nav: state.nav, + oracle, + ourPlpShares: state.plpAmount, + sender, + spot, + }) + log.info( + { decision: decisionLogFields(decision), mode: config.hedgedPlp.model }, + "model decision" + ) + + if (config.hedgedPlp.model === "cvar") { + if (decision.hedge) { + const transaction = buildStartRoundTx( + config, + state, + oracle, + decision.hedge.strike, + decision.hedge.quantity, + sender + ) + const simulation = await simulateTransaction(client, transaction) + + if (simulation.ok) { + return { + logFields: { + expiryMs: oracle.expiryMs, + model: "cvar", + oracleId: oracle.oracleId, + quantity: decision.hedge.quantity, + spot, + strike: decision.hedge.strike, + }, + simulation, + transaction, + } + } + log.warn( + toLogFields({ error: simulation.error, strike: decision.hedge.strike }), + "model hedge failed simulation; falling back to legacy sizing" + ) + } else { + log.info( + { reason: decision.skippedReason }, + "model skipped the hedge; falling back to legacy sizing" + ) + } + } + } + const quantity = bpsAmount(state.nav, config.hedgedPlp.hedgeQuantityBpsOfNav) if (quantity <= 0n) { log.info("start skipped: computed hedge quantity is zero") From 8a212711813d6b2db1b25016e1d4e5a266768bf4 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 12:33:32 +0100 Subject: [PATCH 06/33] feat(operator): pause strategies on daily loss, price drift, or a kill switch --- .gitignore | 4 + services/operator/src/config.ts | 18 ++ services/operator/src/guards.test.ts | 145 ++++++++++++++ services/operator/src/guards.ts | 238 +++++++++++++++++++++++ services/operator/src/strategy/engine.ts | 82 ++++++++ 5 files changed, 487 insertions(+) create mode 100644 services/operator/src/guards.test.ts create mode 100644 services/operator/src/guards.ts diff --git a/.gitignore b/.gitignore index 2c84dc0..83b0802 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,7 @@ traces .coverage* Pub.*.toml web-old + +# operator runtime guard state (kill switch + pause/loss accumulator) +services/operator/guards-state.json +services/operator/operator.kill diff --git a/services/operator/src/config.ts b/services/operator/src/config.ts index 6934349..d7bcb8c 100644 --- a/services/operator/src/config.ts +++ b/services/operator/src/config.ts @@ -41,6 +41,13 @@ export interface ModelConfig { washMinMBps: number } +export interface GuardsConfig { + dailyLossBps: number + killFile: string + navDriftBps: number + stateFile: string +} + export interface RangeLadderConfig { enabled: boolean keeperCapId: string @@ -77,6 +84,7 @@ export interface OperatorConfig { baseVault: BaseVaultConfig bullishUpside: BullishUpsideConfig dryRun: boolean + guards: GuardsConfig hedgedPlp: HedgedPlpConfig model: ModelConfig plpCollar: DualLegConfig @@ -187,6 +195,10 @@ const envSchema = z MODEL_MIN_IMPROVEMENT_BPS: envNumber(10), MODEL_F_MAX_BPS: envNumber(2_000), MODEL_MIN_OTM_TICKS: envNumber(1), + GUARD_DAILY_LOSS_BPS: envNumber(1_000), + GUARD_NAV_DRIFT_BPS: envNumber(50), + GUARD_KILL_FILE: envString("operator.kill"), + GUARD_STATE_FILE: envString("guards-state.json"), RANGE_LADDER_ENABLED: envBoolean(true), RANGE_QUANTITY_BPS_OF_NAV: envNumber(250), RANGE_RUNG_COUNT: envNumber(2), @@ -358,6 +370,12 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): OperatorConfig strikeSpotBps: parsed.HEDGED_PLP_STRIKE_SPOT_BPS, strategyId: deployment.hedgedPlp.strategyId, }, + guards: { + dailyLossBps: parsed.GUARD_DAILY_LOSS_BPS, + killFile: parsed.GUARD_KILL_FILE, + navDriftBps: parsed.GUARD_NAV_DRIFT_BPS, + stateFile: parsed.GUARD_STATE_FILE, + }, model: { alphaBps: parsed.MODEL_CVAR_ALPHA_BPS, budgetBps: parsed.MODEL_BUDGET_BPS, diff --git a/services/operator/src/guards.test.ts b/services/operator/src/guards.test.ts new file mode 100644 index 0000000..855f621 --- /dev/null +++ b/services/operator/src/guards.test.ts @@ -0,0 +1,145 @@ +import { afterEach, describe, expect, test } from "bun:test" +import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs" +import os from "node:os" +import path from "node:path" + +import { + checkDrift, + clearGuardPause, + guardPausedReason, + killSwitchActive, + noteSettle, + sharePrice1e9, +} from "./guards.ts" +import type { GuardsConfig } from "./config.ts" + +const tempDirs: string[] = [] + +function makeConfig(overrides: Partial = {}): GuardsConfig { + const dir = mkdtempSync(path.join(os.tmpdir(), "guards-")) + tempDirs.push(dir) + + return { + dailyLossBps: 1_000, + killFile: path.join(dir, "operator.kill"), + navDriftBps: 50, + stateFile: path.join(dir, "guards-state.json"), + ...overrides, + } +} + +afterEach(() => { + while (tempDirs.length > 0) { + rmSync(tempDirs.pop()!, { force: true, recursive: true }) + } +}) + +const PAR = 1_000_000_000n + +describe("killSwitchActive", () => { + test("off without the file, on with it, off again when deleted", () => { + const config = makeConfig() + expect(killSwitchActive(config)).toBe(false) + + writeFileSync(config.killFile, "") + expect(killSwitchActive(config)).toBe(true) + + rmSync(config.killFile) + expect(killSwitchActive(config)).toBe(false) + }) +}) + +describe("sharePrice1e9", () => { + test("par at zero supply, proportional otherwise", () => { + expect(sharePrice1e9(0n, 0n)).toBe(PAR) + expect(sharePrice1e9(2_000_000n, 1_000_000n)).toBe(2n * PAR) + }) +}) + +describe("checkDrift", () => { + test("first observation sets the baseline without tripping", () => { + const config = makeConfig() + const result = checkDrift(config, "hedged_plp", PAR) + + expect(result.driftBps).toBe(0) + expect(result.pausedReason).toBeNull() + }) + + test("two consecutive drifts pause; a settle resets the strikes", () => { + const config = makeConfig() + checkDrift(config, "hedged_plp", PAR) + + // +1% drift without a settle: first strike, not yet paused. + const drifted = (PAR * 101n) / 100n + const first = checkDrift(config, "hedged_plp", drifted) + expect(first.driftBps).toBeGreaterThan(50) + expect(first.pausedReason).toBeNull() + + // Second consecutive detection pauses. + const second = checkDrift(config, "hedged_plp", drifted) + expect(second.pausedReason).toContain("drifted") + expect(guardPausedReason(config, "hedged_plp")).toContain("drifted") + }) + + test("a clean reading clears the strike counter", () => { + const config = makeConfig() + checkDrift(config, "hedged_plp", PAR) + checkDrift(config, "hedged_plp", (PAR * 101n) / 100n) // strike 1... baseline stays PAR + const clean = checkDrift(config, "hedged_plp", PAR) // back to baseline + expect(clean.pausedReason).toBeNull() + + const driftAgain = checkDrift(config, "hedged_plp", (PAR * 101n) / 100n) + expect(driftAgain.pausedReason).toBeNull() // counter restarted at 1 + }) +}) + +describe("noteSettle", () => { + test("accumulates daily losses and pauses on breach", () => { + const config = makeConfig({ dailyLossBps: 500 }) + + // 3% round loss: recorded, under the 5% daily limit. + const first = noteSettle(config, "strangle", PAR, (PAR * 97n) / 100n) + expect(first.roundLossBps).toBe(300) + expect(first.pausedReason).toBeNull() + + // Another 3%: cumulative 6% breaches the 5% limit. + const second = noteSettle( + config, + "strangle", + (PAR * 97n) / 100n, + (PAR * 94n) / 100n + ) + expect(second.dayLossBps).toBeGreaterThan(500) + expect(second.pausedReason).toContain("daily loss") + }) + + test("gains do not count as losses", () => { + const config = makeConfig() + const outcome = noteSettle(config, "strangle", PAR, (PAR * 110n) / 100n) + + expect(outcome.roundLossBps).toBe(0) + expect(outcome.pausedReason).toBeNull() + }) + + test("settle resets the drift baseline to the post-settle price", () => { + const config = makeConfig() + checkDrift(config, "hedged_plp", PAR) + noteSettle(config, "hedged_plp", PAR, (PAR * 99n) / 100n) + + // Post-settle price is the new baseline: no drift reported against it. + const result = checkDrift(config, "hedged_plp", (PAR * 99n) / 100n) + expect(result.driftBps).toBe(0) + }) +}) + +describe("clearGuardPause", () => { + test("a human resume clears the pause and the strikes", () => { + const config = makeConfig({ dailyLossBps: 100 }) + noteSettle(config, "strangle", PAR, (PAR * 95n) / 100n) + expect(guardPausedReason(config, "strangle")).not.toBeNull() + + clearGuardPause(config, "strangle") + expect(guardPausedReason(config, "strangle")).toBeNull() + expect(existsSync(config.stateFile)).toBe(true) + }) +}) diff --git a/services/operator/src/guards.ts b/services/operator/src/guards.ts new file mode 100644 index 0000000..4732c36 --- /dev/null +++ b/services/operator/src/guards.ts @@ -0,0 +1,238 @@ +// Operator safety guards, checked around every strategy action: +// +// 1. Kill switch — a flag file whose existence halts all transaction actions +// on every strategy. No automated path clears it; a human deletes the +// file to resume. +// 2. Daily-loss auto-pause — realized share-price loss per strategy is +// accumulated per UTC day; breaching the configured bps pauses that +// strategy's round starts (settles stay allowed so capital is never +// stranded mid-round). +// 3. Share-price drift — a strategy's share price can only move when WE +// settle a round (deposits/withdrawals convert between rounds at par to +// the current price). A price that moved without our settle means a bug +// or foreign interference: two consecutive detections pause the strategy. +// +// Guard state persists in a small JSON file next to the operator so pauses +// survive restarts; the kill switch is file-existence only. + +import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs" +import path from "node:path" + +import type { GuardsConfig, OperatorConfig } from "./config.ts" +import type { SuiClient } from "./sui.ts" + +const PRICE_SCALE = 1_000_000_000n + +interface StrategyGuardState { + day: string + dayLossBps: number + driftStrikes: number + lastSharePrice1e9: string | null + pausedReason: string | null +} + +interface GuardsFileState { + strategies: Record +} + +function killFilePath(config: GuardsConfig): string { + return path.resolve(config.killFile) +} + +function stateFilePath(config: GuardsConfig): string { + return path.resolve(config.stateFile) +} + +function emptyStrategyState(): StrategyGuardState { + return { + day: currentUtcDay(), + dayLossBps: 0, + driftStrikes: 0, + lastSharePrice1e9: null, + pausedReason: null, + } +} + +function loadState(config: GuardsConfig): GuardsFileState { + try { + const parsed = JSON.parse( + readFileSync(stateFilePath(config), "utf8") + ) as GuardsFileState + return { strategies: parsed.strategies ?? {} } + } catch { + return { strategies: {} } + } +} + +function saveState(config: GuardsConfig, state: GuardsFileState) { + const file = stateFilePath(config) + mkdirSync(path.dirname(file), { recursive: true }) + writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`) +} + +function currentUtcDay(): string { + return new Date().toISOString().slice(0, 10) +} + +function strategyState( + state: GuardsFileState, + kind: string +): StrategyGuardState { + const existing = state.strategies[kind] + if (existing) { + // Roll the daily accumulator on day change; pauses persist across days. + if (existing.day !== currentUtcDay()) { + existing.day = currentUtcDay() + existing.dayLossBps = 0 + } + return existing + } + + const fresh = emptyStrategyState() + state.strategies[kind] = fresh + return fresh +} + +/// The kill switch halts every transaction action until a human removes the file. +export function killSwitchActive(config: GuardsConfig): boolean { + return existsSync(killFilePath(config)) +} + +export function guardPausedReason( + config: GuardsConfig, + kind: string +): string | null { + return loadState(config).strategies[kind]?.pausedReason ?? null +} + +/// Share price at the 1e9 scale (zero supply reads as par). +export function sharePrice1e9(nav: bigint, supply: bigint): bigint { + if (supply <= 0n) { + return PRICE_SCALE + } + + return (nav * PRICE_SCALE) / supply +} + +/// A strategy's share token supply, read straight off the strategy object. +export async function readShareSupply( + client: SuiClient, + strategyId: string +): Promise { + const { object } = await client.getObject({ + include: { json: true }, + objectId: strategyId, + }) + const json = (object as { json?: unknown }).json + const value = ( + json as { treasury?: { total_supply?: { value?: unknown } } } | null + )?.treasury?.total_supply?.value + + if (typeof value !== "string" && typeof value !== "number") { + throw new Error(`strategy ${strategyId} has no treasury supply`) + } + + return BigInt(value) +} + +export function strategyIdFor(kind: string, config: OperatorConfig): string { + switch (kind) { + case "hedged_plp": + return config.hedgedPlp.strategyId + case "range_ladder": + return config.rangeLadder.strategyId + case "bullish_upside": + return config.bullishUpside.strategyId + case "strangle": + return config.strangle.strategyId + case "plp_collar": + return config.plpCollar.strategyId + default: + throw new Error(`unknown strategy kind ${kind}`) + } +} + +export interface DriftCheckResult { + pausedReason: string | null + driftBps: number +} + +/// Detect a share price that moved without our settle. Two consecutive +/// detections pause the strategy. +export function checkDrift( + config: GuardsConfig, + kind: string, + currentPrice1e9: bigint +): DriftCheckResult { + const state = loadState(config) + const guard = strategyState(state, kind) + const baseline = guard.lastSharePrice1e9 + + if (baseline === null) { + guard.lastSharePrice1e9 = currentPrice1e9.toString() + saveState(config, state) + return { driftBps: 0, pausedReason: guard.pausedReason } + } + + const before = BigInt(baseline) + const delta = currentPrice1e9 > before ? currentPrice1e9 - before : before - currentPrice1e9 + const driftBps = before > 0n ? Number((delta * 10_000n) / before) : 0 + + if (driftBps > config.navDriftBps) { + guard.driftStrikes += 1 + if (guard.driftStrikes >= 2 && guard.pausedReason === null) { + guard.pausedReason = `share price drifted ${driftBps}bps without a settle (2 consecutive checks)` + } + } else { + guard.driftStrikes = 0 + } + + saveState(config, state) + return { driftBps, pausedReason: guard.pausedReason } +} + +export interface SettleOutcome { + dayLossBps: number + pausedReason: string | null + roundLossBps: number +} + +/// Record a settle's realized share-price move; pause on daily-loss breach and +/// reset the drift baseline to the post-settle price. +export function noteSettle( + config: GuardsConfig, + kind: string, + priceBefore1e9: bigint, + priceAfter1e9: bigint +): SettleOutcome { + const state = loadState(config) + const guard = strategyState(state, kind) + + const loss = priceBefore1e9 > priceAfter1e9 ? priceBefore1e9 - priceAfter1e9 : 0n + const roundLossBps = + priceBefore1e9 > 0n ? Number((loss * 10_000n) / priceBefore1e9) : 0 + + guard.dayLossBps += roundLossBps + guard.lastSharePrice1e9 = priceAfter1e9.toString() + guard.driftStrikes = 0 + + if (guard.dayLossBps > config.dailyLossBps && guard.pausedReason === null) { + guard.pausedReason = `daily loss ${guard.dayLossBps}bps breached the ${config.dailyLossBps}bps limit` + } + + saveState(config, state) + return { + dayLossBps: guard.dayLossBps, + pausedReason: guard.pausedReason, + roundLossBps, + } +} + +/// Clear a guard pause (explicit human action, e.g. a CLI resume command). +export function clearGuardPause(config: GuardsConfig, kind: string) { + const state = loadState(config) + const guard = strategyState(state, kind) + guard.pausedReason = null + guard.driftStrikes = 0 + saveState(config, state) +} diff --git a/services/operator/src/strategy/engine.ts b/services/operator/src/strategy/engine.ts index 8dc1e71..a43c09d 100644 --- a/services/operator/src/strategy/engine.ts +++ b/services/operator/src/strategy/engine.ts @@ -3,6 +3,15 @@ import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519" import type { Logger } from "pino" import type { OperatorConfig } from "../config.ts" +import { + checkDrift, + guardPausedReason, + killSwitchActive, + noteSettle, + readShareSupply, + sharePrice1e9, + strategyIdFor, +} from "../guards.ts" import { logger, toLogFields } from "../logger.ts" import { findOracle, getOracleState, selectRoundOracle, type OracleInfo } from "../predict.ts" import { @@ -74,6 +83,16 @@ export async function runStrategyTick( return } + // Emergency stop: the kill file halts every transaction action on every + // strategy until a human deletes it. + if (killSwitchActive(config.guards)) { + log.error( + { killFile: config.guards.killFile }, + "kill switch active: refusing all transaction actions" + ) + return + } + if (!keypair) { throw new Error(`SUI_KEEPER_KEY is required for ${driver.kind} transaction actions`) } @@ -116,6 +135,35 @@ async function runStart( return } + // Guard gate: daily-loss / drift pauses block new rounds (settles stay + // allowed so capital is never stranded mid-round), and the share price is + // drift-checked — it can only legitimately move when we settle. + const pausedReason = guardPausedReason(config.guards, driver.kind) + if (pausedReason) { + log.warn({ reason: pausedReason }, "start skipped: guard pause active") + return + } + try { + const supply = await readShareSupply(client, strategyIdFor(driver.kind, config)) + const drift = checkDrift( + config.guards, + driver.kind, + sharePrice1e9(driver.nav(state), supply) + ) + if (drift.pausedReason) { + log.error( + { driftBps: drift.driftBps, reason: drift.pausedReason }, + "start skipped: share price drift guard tripped" + ) + return + } + } catch (error) { + log.warn( + { error: error instanceof Error ? error.message : String(error) }, + "drift check unavailable; continuing" + ) + } + const oracle = await selectRoundOracle(config.predict) if (!oracle) { log.info("start skipped: no eligible round oracle") @@ -169,6 +217,40 @@ async function runSettle( const tx = driver.buildSettleTx(config, state, oracleId, keypair.toSuiAddress()) await maybeExecute(client, keypair, tx, "settle_round", dryRun, log) + + if (dryRun) { + return + } + + // Record the realized share-price move: feeds the daily-loss pause and + // resets the drift baseline to the post-settle price. + try { + const strategyId = strategyIdFor(driver.kind, config) + const supply = await readShareSupply(client, strategyId) + const priceBefore = sharePrice1e9(driver.nav(state), supply) + const settledState = await driver.readState(client, config) + const supplyAfter = await readShareSupply(client, strategyId) + const priceAfter = sharePrice1e9(driver.nav(settledState), supplyAfter) + const outcome = noteSettle(config.guards, driver.kind, priceBefore, priceAfter) + + log.info( + { + dayLossBps: outcome.dayLossBps, + priceAfter: priceAfter.toString(), + priceBefore: priceBefore.toString(), + roundLossBps: outcome.roundLossBps, + }, + "settle outcome recorded" + ) + if (outcome.pausedReason) { + log.error({ reason: outcome.pausedReason }, "daily loss guard paused the strategy") + } + } catch (error) { + log.warn( + { error: error instanceof Error ? error.message : String(error) }, + "settle outcome recording failed" + ) + } } async function runRealize( From 3370376696524497011013ef9f9c5f356b8d4c12 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 12:41:10 +0100 Subject: [PATCH 07/33] feat(operator): size the collar's legs from live pool risk --- services/operator/src/config.ts | 8 + services/operator/src/model/decide.ts | 355 +++++++++++++------ services/operator/src/model/sizer.test.ts | 69 +++- services/operator/src/model/sizer.ts | 181 ++++++++-- services/operator/src/strategies/dual-leg.ts | 72 +++- 5 files changed, 544 insertions(+), 141 deletions(-) diff --git a/services/operator/src/config.ts b/services/operator/src/config.ts index d7bcb8c..6a67bdd 100644 --- a/services/operator/src/config.ts +++ b/services/operator/src/config.ts @@ -74,6 +74,8 @@ export interface DualLegConfig { enabled: boolean keeperCapId: string managerId: string + /// Exposure-model rollout stage; only the collar consumes it today. + model: "bps" | "shadow" | "cvar" packageId: string quantityBpsOfNav: number strikeWidthBps: number @@ -189,6 +191,10 @@ const envSchema = z .enum(["bps", "shadow", "cvar"]) .default("bps") .catch("bps"), + PLP_COLLAR_MODEL: z + .enum(["bps", "shadow", "cvar"]) + .default("bps") + .catch("bps"), MODEL_CVAR_ALPHA_BPS: envNumber(9_500), MODEL_BUDGET_BPS: envNumber(100), MODEL_WASH_MIN_M_BPS: envNumber(2_500), @@ -322,6 +328,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): OperatorConfig enabled: parsed.PLP_COLLAR_ENABLED, keeperCapId: deployment.plpCollar.keeperCapId, managerId: deployment.plpCollar.managerId, + model: parsed.PLP_COLLAR_MODEL, packageId: deployment.plpCollar.packageId, quantityBpsOfNav: parsed.PLP_COLLAR_QUANTITY_BPS_OF_NAV, strikeWidthBps: parsed.PLP_COLLAR_STRIKE_WIDTH_BPS, @@ -331,6 +338,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): OperatorConfig enabled: parsed.STRANGLE_ENABLED, keeperCapId: deployment.strangle.keeperCapId, managerId: deployment.strangle.managerId, + model: "bps", packageId: deployment.strangle.packageId, quantityBpsOfNav: parsed.STRANGLE_QUANTITY_BPS_OF_NAV, strikeWidthBps: parsed.STRANGLE_STRIKE_WIDTH_BPS, diff --git a/services/operator/src/model/decide.ts b/services/operator/src/model/decide.ts index 90c151e..e631a35 100644 --- a/services/operator/src/model/decide.ts +++ b/services/operator/src/model/decide.ts @@ -1,7 +1,7 @@ // Strategy-facing model façade: read the live pool, recover the risk-neutral -// settlement density from real quotes, and size the downside hedge by tail -// risk. Never throws on data problems — it returns a skipped decision so the -// driver can fall back to legacy sizing. +// settlement density from real quotes, and size hedge legs by tail risk. +// Never throws on data problems — it returns a skipped decision so drivers +// can fall back to legacy sizing. import { createHash } from "node:crypto" @@ -10,12 +10,19 @@ import type { OperatorConfig } from "../config.ts" import type { OracleInfo } from "../predict.ts" import type { SuiClient } from "../sui.ts" import { buildDensity, densityScenarios } from "./density.ts" -import { buildLiabilityCurve } from "./pool.ts" +import { buildLiabilityCurve, type LiabilityCurve } from "./pool.ts" import { GridPricer, unitMidUp } from "./pricer.ts" import { readPoolAggregates, readStrikeBook } from "./reads.ts" -import { sizeHedge } from "./sizer.ts" +import { sizeCollar, sizeHedge } from "./sizer.ts" import type { HedgeCandidate } from "./sizer.ts" -import type { HedgeDecision, PoolBook } from "./types.ts" +import type { + HedgeDecision, + HedgeDecisionDiagnostics, + HedgeSkipReason, + PoolAggregates, + PoolBook, + Scenario, +} from "./types.ts" import { effectiveMultiplier, prospectiveLpShare, @@ -34,7 +41,7 @@ const MIN_DENSITY_QUOTES = 3 // liability curve still uses the FULL book — only the quoted grid is banded. const DENSITY_BAND_BPS = 1_000n -export interface DecideHedgedPlpInput { +export interface DecideInput { client: SuiClient config: OperatorConfig nav: bigint @@ -44,29 +51,33 @@ export interface DecideHedgedPlpInput { spot: bigint } +export interface CollarDecision { + plpSupplyAmount: bigint + legs?: { + dn: { strike: bigint; quantity: bigint; premium: bigint } + up: { strike: bigint; quantity: bigint; premium: bigint } + } + skippedReason?: HedgeSkipReason + diagnostics: HedgeDecisionDiagnostics +} + const EMPTY_BOOK: PoolBook = { qDn: [], qUp: [], rangeQty: 0n, strikes: [] } -function skipped( - reason: HedgeDecision["skippedReason"], - nav: bigint, +function emptyDiagnostics( budgetBps: number, alphaBps: number -): HedgeDecision { +): HedgeDecisionDiagnostics { return { - diagnostics: { - alphaBps, - budgetBps, - cvarAfter: 0, - cvarBefore: 0, - expectedLossAfter: 0, - expectedLossBefore: 0, - f: 0, - fCapApplied: false, - inputsHash: "", - safeDepositHint: 0n, - }, - plpSupplyAmount: nav, - skippedReason: reason, + alphaBps, + budgetBps, + cvarAfter: 0, + cvarBefore: 0, + expectedLossAfter: 0, + expectedLossBefore: 0, + f: 0, + fCapApplied: false, + inputsHash: "", + safeDepositHint: 0n, } } @@ -78,8 +89,8 @@ function hashInputs(payload: unknown): string { return createHash("sha256").update(json).digest("hex") } -/// Candidate density strikes: the pool book's breakpoints plus an ATM ladder -/// around spot, snapped to the oracle grid, capped by distance from spot. +/// Candidate density strikes: the pool book's breakpoints inside the spot band +/// plus an ATM ladder, snapped to the oracle grid, capped by distance to spot. function densityStrikes( book: PoolBook, oracle: OracleInfo, @@ -117,33 +128,44 @@ function densityStrikes( .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)) } -export async function decideHedgedPlp( - input: DecideHedgedPlpInput -): Promise { +interface ModelContext { + aggregates: PoolAggregates + book: PoolBook + curve: LiabilityCurve + f: number + mids: number[] + pricer: GridPricer + scenarios: Scenario[] + strikes: bigint[] +} + +/// Shared preparation for every decider: pool reads, density from live quotes, +/// liability curve, prospective LP share. Returns a skip reason on data +/// problems instead of throwing. +async function buildModelContext( + input: DecideInput +): Promise { const { client, config, nav, oracle, ourPlpShares, sender, spot } = input - const { alphaBps, budgetBps, fMaxBps, minImprovementBps, minOtmTicks, washMinMBps } = - config.model - let aggregates - let bookResult + let aggregates: PoolAggregates + let book: PoolBook try { aggregates = await readPoolAggregates(client, config.predict.sharedObjectId) - bookResult = await readStrikeBook( + const bookResult = await readStrikeBook( client, config.predict.sharedObjectId, oracle.oracleId ) + book = bookResult?.book ?? EMPTY_BOOK } catch { - return skipped("no_book_data", nav, budgetBps, alphaBps) + return "no_book_data" } - const book = bookResult?.book ?? EMPTY_BOOK - // An empty book means the pool carries no liability on this oracle: the LP // leg is flat and no hedge can improve it. Skip before spending ~100 quote // simulations discovering that the hard way. if (book.strikes.length === 0) { - return skipped("no_book_data", nav, budgetBps, alphaBps) + return "no_book_data" } const pricer = new GridPricer(client, { @@ -162,94 +184,223 @@ export async function decideHedgedPlp( strikes, }) if (upQuotes.length < MIN_DENSITY_QUOTES) { - return skipped("no_book_data", nav, budgetBps, alphaBps) + return "no_book_data" } + const mids = upQuotes.map((quote) => unitMidUp(quote, PROBE_QUANTITY)) const density = buildDensity({ - midUp: upQuotes.map((quote) => unitMidUp(quote, PROBE_QUANTITY)), + midUp: mids, strikes: upQuotes.map((quote) => quote.strike), }) - const scenarios = densityScenarios(density, oracle.tickSize) - const curve = buildLiabilityCurve(book, aggregates) - - // Conservative prospective LP share: assume the whole NAV supplies PLP this - // round (the on-chain policy allocates at most that). - const f = prospectiveLpShare( - ourPlpShares, - aggregates.plpSupply, - aggregates.vaultValue, - nav - ) - // Hedge candidates: on-grid strikes strictly below spot by the OTM floor. - const otmCeiling = spot - BigInt(minOtmTicks) * oracle.tickSize - const candidateStrikes = strikes - .filter((strike) => strike <= otmCeiling) - .slice(-MAX_HEDGE_CANDIDATES) - const dnQuotes = await pricer.quoteGrid({ - expiryMs: Number(oracle.expiryMs), - isUp: false, - oracleId: oracle.oracleId, + return { + aggregates, + book, + curve: buildLiabilityCurve(book, aggregates), + // Conservative prospective LP share: assume the whole NAV supplies PLP + // this round (the on-chain policy allocates at most that). + f: prospectiveLpShare( + ourPlpShares, + aggregates.plpSupply, + aggregates.vaultValue, + nav + ), + mids, + pricer, + scenarios: densityScenarios(density, oracle.tickSize), + strikes: upQuotes.map((quote) => quote.strike), + } +} + +/// Quote executable asks for hedge candidates on one side of spot. +async function hedgeCandidates( + context: ModelContext, + input: DecideInput, + side: "dn" | "up" +): Promise { + const { config, oracle, sender, spot } = input + const otmTicks = BigInt(config.model.minOtmTicks) * oracle.tickSize + const strikes = + side === "dn" + ? context.strikes.filter((strike) => strike <= spot - otmTicks).slice(-MAX_HEDGE_CANDIDATES) + : context.strikes.filter((strike) => strike >= spot + otmTicks).slice(0, MAX_HEDGE_CANDIDATES) + + const quotes = await context.pricer.quoteGrid({ + expiryMs: Number(input.oracle.expiryMs), + isUp: side === "up", + oracleId: input.oracle.oracleId, quantity: PROBE_QUANTITY, senderAddress: sender, - strikes: candidateStrikes, + strikes, }) - const candidates: HedgeCandidate[] = dnQuotes + + return quotes .map((quote) => ({ + side, strike: quote.strike, unitAsk: Number(quote.mintCost) / Number(PROBE_QUANTITY), })) .filter((candidate) => candidate.unitAsk > 0 && candidate.unitAsk < 1) +} - const budget = bpsAmount(nav, budgetBps) - const result = sizeHedge(scenarios, curve, aggregates.vaultValue, f, candidates, { - alphaBps, - budget, - minImprovement: bpsAmount(nav, minImprovementBps), - washMinMBps, - }) +function diagnosticsFor( + input: DecideInput, + context: ModelContext, + result: { + cvarAfter: number + cvarBefore: number + expectedLossAfter: number + expectedLossBefore: number + }, + hedgeStrike: bigint | undefined, + hedgeQuantity: bigint | undefined +): HedgeDecisionDiagnostics { + const { config, nav, oracle, ourPlpShares } = input - const inputsHash = hashInputs({ - aggregates, - book, - config: config.model, - f, - mids: upQuotes.map((quote) => unitMidUp(quote, PROBE_QUANTITY)), - nav, - oracleId: oracle.oracleId, - strikes: upQuotes.map((quote) => quote.strike), - }) + return { + alphaBps: config.model.alphaBps, + budgetBps: config.model.budgetBps, + cvarAfter: result.cvarAfter, + cvarBefore: result.cvarBefore, + expectedLossAfter: result.expectedLossAfter, + expectedLossBefore: result.expectedLossBefore, + f: context.f, + fCapApplied: false, + inputsHash: hashInputs({ + aggregates: context.aggregates, + book: context.book, + config: config.model, + f: context.f, + mids: context.mids, + nav, + oracleId: oracle.oracleId, + strikes: context.strikes, + }), + mAtStrike: hedgeStrike === undefined ? undefined : effectiveMultiplier(context.f), + safeDepositHint: safeSupplyCap( + ourPlpShares, + context.aggregates.plpSupply, + context.aggregates.vaultValue, + config.model.fMaxBps + ), + uAtStrike: + hedgeStrike === undefined || hedgeQuantity === undefined + ? undefined + : uAtStrike(context.book, hedgeStrike, 0n, hedgeQuantity), + } +} + +export async function decideHedgedPlp(input: DecideInput): Promise { + const { config, nav } = input + const context = await buildModelContext(input) + + if (typeof context === "string") { + return { + diagnostics: emptyDiagnostics(config.model.budgetBps, config.model.alphaBps), + plpSupplyAmount: nav, + skippedReason: context, + } + } + + const candidates = await hedgeCandidates(context, input, "dn") + const result = sizeHedge( + context.scenarios, + context.curve, + context.aggregates.vaultValue, + context.f, + candidates, + { + alphaBps: config.model.alphaBps, + budget: bpsAmount(nav, config.model.budgetBps), + minImprovement: bpsAmount(nav, config.model.minImprovementBps), + washMinMBps: config.model.washMinMBps, + } + ) return { - diagnostics: { - alphaBps, - budgetBps, - cvarAfter: result.cvarAfter, - cvarBefore: result.cvarBefore, - expectedLossAfter: result.expectedLossAfter, - expectedLossBefore: result.expectedLossBefore, - f, - fCapApplied: false, - inputsHash, - mAtStrike: result.hedge ? effectiveMultiplier(f) : undefined, - safeDepositHint: safeSupplyCap( - ourPlpShares, - aggregates.plpSupply, - aggregates.vaultValue, - fMaxBps - ), - uAtStrike: result.hedge - ? uAtStrike(book, result.hedge.strike, 0n, result.hedge.quantity) - : undefined, - }, + diagnostics: diagnosticsFor( + input, + context, + result, + result.hedge?.strike, + result.hedge?.quantity + ), hedge: result.hedge, plpSupplyAmount: nav, skippedReason: result.skippedReason, } } +/// The collar buys BOTH a downside floor and an upside cover from the pool it +/// supplies; per-leg budgets mirror the on-chain policy's split. +export async function decideCollar(input: DecideInput): Promise { + const { config, nav } = input + const context = await buildModelContext(input) + + if (typeof context === "string") { + return { + diagnostics: emptyDiagnostics(config.model.budgetBps, config.model.alphaBps), + plpSupplyAmount: nav, + skippedReason: context, + } + } + + const [dnCandidates, upCandidates] = await Promise.all([ + hedgeCandidates(context, input, "dn"), + hedgeCandidates(context, input, "up"), + ]) + const perLegBudget = bpsAmount(nav, config.model.budgetBps) + const result = sizeCollar( + context.scenarios, + context.curve, + context.aggregates.vaultValue, + context.f, + dnCandidates, + upCandidates, + { + alphaBps: config.model.alphaBps, + dnBudget: perLegBudget, + minImprovement: bpsAmount(nav, config.model.minImprovementBps), + upBudget: perLegBudget, + washMinMBps: config.model.washMinMBps, + } + ) + + return { + diagnostics: diagnosticsFor( + input, + context, + result, + result.legs?.dn.candidate.strike, + result.legs?.dn.quantity + ), + legs: result.legs + ? { + dn: { + premium: BigInt( + Math.ceil(Number(result.legs.dn.quantity) * result.legs.dn.candidate.unitAsk) + ), + quantity: result.legs.dn.quantity, + strike: result.legs.dn.candidate.strike, + }, + up: { + premium: BigInt( + Math.ceil(Number(result.legs.up.quantity) * result.legs.up.candidate.unitAsk) + ), + quantity: result.legs.up.quantity, + strike: result.legs.up.candidate.strike, + }, + } + : undefined, + plpSupplyAmount: nav, + skippedReason: result.skippedReason, + } +} + /// Bigint-safe log projection of a decision (pino drops bigints otherwise). -export function decisionLogFields(decision: HedgeDecision): Record { +export function decisionLogFields( + decision: HedgeDecision | CollarDecision +): Record { return JSON.parse( JSON.stringify(decision, (_key, value: unknown) => typeof value === "bigint" ? value.toString() : value diff --git a/services/operator/src/model/sizer.test.ts b/services/operator/src/model/sizer.test.ts index 6ecc389..2ba93f0 100644 --- a/services/operator/src/model/sizer.test.ts +++ b/services/operator/src/model/sizer.test.ts @@ -1,7 +1,7 @@ import { describe, expect, test } from "bun:test" import { buildLiabilityCurve } from "./pool.ts" -import { sizeHedge } from "./sizer.ts" +import { sizeCollar, sizeHedge } from "./sizer.ts" import type { HedgeCandidate, SizerConfig } from "./sizer.ts" import type { PoolAggregates, PoolBook, Scenario } from "./types.ts" @@ -116,3 +116,70 @@ describe("sizeHedge", () => { expect(result.hedge).toBeUndefined() }) }) + +describe("sizeCollar", () => { + // Two-sided exposure: the pool owes big on BOTH a crash (q_dn) and a rally + // (q_up), so both collar legs earn their keep. + const twoSidedBook: PoolBook = { + qDn: [C(400), 0n, 0n], + qUp: [0n, 0n, C(400)], + rangeQty: 0n, + strikes: [K(60_000), K(62_000), K(64_000)], + } + const twoSidedCurve = buildLiabilityCurve(twoSidedBook, aggregates) + const dnCandidates: HedgeCandidate[] = [{ side: "dn", strike: K(60_000), unitAsk: 0.1 }] + const upCandidates: HedgeCandidate[] = [{ side: "up", strike: K(64_000), unitAsk: 0.1 }] + const budgets = { + alphaBps: 9_000, + dnBudget: C(30), + minImprovement: C(1), + upBudget: C(30), + washMinMBps: 2_500, + } + + test("buys both legs and cuts the tail", () => { + const result = sizeCollar( + scenarios, + twoSidedCurve, + aggregates.vaultValue, + f, + dnCandidates, + upCandidates, + budgets + ) + + expect(result.legs).toBeDefined() + expect(result.legs!.dn.quantity).toBeGreaterThan(0n) + expect(result.legs!.up.quantity).toBeGreaterThan(0n) + expect(result.cvarAfter).toBeLessThan(result.cvarBefore) + }) + + test("skips entirely when one side has no viable leg (contract needs both)", () => { + const result = sizeCollar( + scenarios, + twoSidedCurve, + aggregates.vaultValue, + f, + dnCandidates, + [{ side: "up", strike: K(64_000), unitAsk: 0.99 }], // effectively unbuyable + budgets + ) + + expect(result.legs).toBeUndefined() + expect(result.skippedReason).toBeDefined() + }) + + test("wash guard applies to the collar too", () => { + const result = sizeCollar( + scenarios, + twoSidedCurve, + aggregates.vaultValue, + 0.9, + dnCandidates, + upCandidates, + budgets + ) + + expect(result.skippedReason).toBe("wash") + }) +}) diff --git a/services/operator/src/model/sizer.ts b/services/operator/src/model/sizer.ts index 55526f6..bd36d11 100644 --- a/services/operator/src/model/sizer.ts +++ b/services/operator/src/model/sizer.ts @@ -16,8 +16,11 @@ import type { HedgeSkipReason, Scenario } from "./types.ts" export interface HedgeCandidate { strike: bigint - /// Executable DN ask per contract in [0, 1] (probe-quote derived). + /// Executable ask per contract in [0, 1] (probe-quote derived). unitAsk: number + /// Payout side: dn pays when settlement <= strike (at-or-below wins), + /// up pays when settlement > strike. Defaults to dn (the downside hedge). + side?: "dn" | "up" } export interface SizerConfig { @@ -45,26 +48,38 @@ interface Outcome { probability: number } +export interface SizedLeg { + candidate: HedgeCandidate + quantity: bigint +} + +function legInTheMoney(leg: SizedLeg, settlement: bigint): boolean { + return (leg.candidate.side ?? "dn") === "dn" + ? settlement <= leg.candidate.strike + : settlement > leg.candidate.strike +} + function roundOutcomes( scenarios: Scenario[], curve: LiabilityCurve, vaultValueNow: bigint, f: number, - candidate: HedgeCandidate | undefined, - quantity: bigint + legs: SizedLeg[] ): Outcome[] { const multiplier = 1 - f - const premium = candidate - ? Number(quantity) * candidate.unitAsk - : 0 + const premium = legs.reduce( + (acc, leg) => acc + Number(leg.quantity) * leg.candidate.unitAsk, + 0 + ) return scenarios.map((scenario) => { const lpLeg = f * Number(curve.poolValueAt(scenario.settlement) - vaultValueNow) - const hedgePayout = - candidate && scenario.settlement <= candidate.strike - ? Number(quantity) - : 0 + const hedgePayout = legs.reduce( + (acc, leg) => + acc + (legInTheMoney(leg, scenario.settlement) ? Number(leg.quantity) : 0), + 0 + ) const hedgeLeg = multiplier * (hedgePayout - premium) return { loss: -(lpLeg + hedgeLeg), probability: scenario.probability } @@ -83,13 +98,15 @@ function expectedLoss(outcomes: Outcome[]): number { } /// Ternary search over the (convex-in-h) tail objective on whole contracts. +/// `fixedLegs` lets a second leg be sized GIVEN an already-chosen first leg. function bestQuantityFor( candidate: HedgeCandidate, scenarios: Scenario[], curve: LiabilityCurve, vaultValueNow: bigint, f: number, - config: SizerConfig + config: SizerConfig, + fixedLegs: SizedLeg[] = [] ): { quantity: bigint; cvarAfter: number } { const maxQuantity = candidate.unitAsk > 0 @@ -99,14 +116,10 @@ function bestQuantityFor( const evaluate = (steps: bigint) => tailLoss( - roundOutcomes( - scenarios, - curve, - vaultValueNow, - f, - candidate, - steps * QUANTITY_STEP - ), + roundOutcomes(scenarios, curve, vaultValueNow, f, [ + ...fixedLegs, + { candidate, quantity: steps * QUANTITY_STEP }, + ]), config.alphaBps ) @@ -142,14 +155,7 @@ export function sizeHedge( candidates: HedgeCandidate[], config: SizerConfig ): SizerResult { - const baselineOutcomes = roundOutcomes( - scenarios, - curve, - vaultValueNow, - f, - undefined, - 0n - ) + const baselineOutcomes = roundOutcomes(scenarios, curve, vaultValueNow, f, []) const cvarBefore = tailLoss(baselineOutcomes, config.alphaBps) const expectedLossBefore = expectedLoss(baselineOutcomes) const unhedged: SizerResult = { @@ -202,14 +208,9 @@ export function sizeHedge( const premiumFloat = Number(best.quantity) * best.candidate.unitAsk const premium = BigInt(Math.ceil(premiumFloat)) - const hedgedOutcomes = roundOutcomes( - scenarios, - curve, - vaultValueNow, - f, - best.candidate, - best.quantity - ) + const hedgedOutcomes = roundOutcomes(scenarios, curve, vaultValueNow, f, [ + { candidate: best.candidate, quantity: best.quantity }, + ]) return { cvarAfter: best.cvarAfter, @@ -227,3 +228,113 @@ export function sizeHedge( function effective(f: number): number { return Math.min(1, Math.max(0, 1 - f)) } + +export interface CollarBudgets { + alphaBps: number + dnBudget: bigint + upBudget: bigint + washMinMBps: number + minImprovement: bigint +} + +export interface CollarResult { + legs?: { dn: SizedLeg; up: SizedLeg } + skippedReason?: HedgeSkipReason + cvarBefore: number + cvarAfter: number + expectedLossBefore: number + expectedLossAfter: number +} + +/// Size a two-sided collar (long DN floor + long UP cover) greedily: the DN +/// leg is chosen against the raw tail first, then the UP leg given the DN leg +/// fixed. The collar contract requires BOTH legs positive, so if either side +/// cannot justify a leg the whole decision is skipped (the driver falls back +/// to its legacy sizing). +export function sizeCollar( + scenarios: Scenario[], + curve: LiabilityCurve, + vaultValueNow: bigint, + f: number, + dnCandidates: HedgeCandidate[], + upCandidates: HedgeCandidate[], + budgets: CollarBudgets +): CollarResult { + const baselineOutcomes = roundOutcomes(scenarios, curve, vaultValueNow, f, []) + const cvarBefore = tailLoss(baselineOutcomes, budgets.alphaBps) + const expectedLossBefore = expectedLoss(baselineOutcomes) + const unhedged: CollarResult = { + cvarAfter: cvarBefore, + cvarBefore, + expectedLossAfter: expectedLossBefore, + expectedLossBefore, + } + + if (scenarios.length === 0 || dnCandidates.length === 0 || upCandidates.length === 0) { + return { ...unhedged, skippedReason: "no_viable_strike" } + } + if (effective(f) * 10_000 < budgets.washMinMBps) { + return { ...unhedged, skippedReason: "wash" } + } + if (budgets.dnBudget <= 0n || budgets.upBudget <= 0n) { + return { ...unhedged, skippedReason: "budget" } + } + + function bestLeg( + candidates: HedgeCandidate[], + budget: bigint, + fixedLegs: SizedLeg[] + ): SizedLeg | undefined { + let best: { leg: SizedLeg; cvarAfter: number } | undefined + + for (const candidate of candidates) { + if (candidate.unitAsk <= 0 || candidate.unitAsk >= 1) { + continue + } + const result = bestQuantityFor( + candidate, + scenarios, + curve, + vaultValueNow, + f, + { alphaBps: budgets.alphaBps, budget, minImprovement: 0n, washMinMBps: 0 }, + fixedLegs + ) + if (result.quantity <= 0n) { + continue + } + if (!best || result.cvarAfter < best.cvarAfter) { + best = { + cvarAfter: result.cvarAfter, + leg: { candidate, quantity: result.quantity }, + } + } + } + + return best?.leg + } + + const dn = bestLeg(dnCandidates, budgets.dnBudget, []) + if (!dn) { + return { ...unhedged, skippedReason: "no_viable_strike" } + } + const up = bestLeg(upCandidates, budgets.upBudget, [dn]) + if (!up) { + return { ...unhedged, skippedReason: "no_viable_strike" } + } + + const collarOutcomes = roundOutcomes(scenarios, curve, vaultValueNow, f, [dn, up]) + const cvarAfter = tailLoss(collarOutcomes, budgets.alphaBps) + + if (cvarBefore - cvarAfter < Number(budgets.minImprovement)) { + return { ...unhedged, skippedReason: "negligible_improvement" } + } + + return { + cvarAfter, + cvarBefore, + expectedLossAfter: expectedLoss(collarOutcomes), + expectedLossBefore, + legs: { dn, up }, + } +} diff --git a/services/operator/src/strategies/dual-leg.ts b/services/operator/src/strategies/dual-leg.ts index df74ae8..d208814 100644 --- a/services/operator/src/strategies/dual-leg.ts +++ b/services/operator/src/strategies/dual-leg.ts @@ -3,6 +3,7 @@ import { Transaction } from "@mysten/sui/transactions" import type { DualLegConfig, OperatorConfig } from "../config.ts" import { bpsAmount, chooseDownsideStrike, chooseUpsideStrike } from "../grid.ts" import { toLogFields } from "../logger.ts" +import { decideCollar, decisionLogFields } from "../model/decide.ts" import type { OracleInfo } from "../predict.ts" import { simulateTransaction } from "../sui.ts" import { readStrategyState, type StrategyState } from "../strategy-state.ts" @@ -31,7 +32,8 @@ function buildStartRoundTx( oracle: OracleInfo, downStrike: bigint, upStrike: bigint, - quantity: bigint, + downQuantity: bigint, + upQuantity: bigint, sender: string ) { const tx = new Transaction() @@ -47,9 +49,9 @@ function buildStartRoundTx( tx.object(state.managerId), tx.object(oracle.oracleId), tx.pure.u64(downStrike), - tx.pure.u64(quantity), + tx.pure.u64(downQuantity), tx.pure.u64(upStrike), - tx.pure.u64(quantity), + tx.pure.u64(upQuantity), tx.object(config.predict.clockObjectId), ], }) @@ -108,6 +110,69 @@ export function createDualLegDriver( const { client, config, log, oracle, sender, spot } = context const cfg = select(config) + // Exposure-model rollout (collar only): shadow logs the decision and + // executes legacy sizing; cvar executes the model's legs, falling back + // to legacy sizing when skipped or unexecutable (never brick the round). + if (kind === "plp_collar" && cfg.model !== "bps") { + const decision = await decideCollar({ + client, + config, + nav: state.nav, + oracle, + ourPlpShares: state.plpAmount ?? 0n, + sender, + spot, + }) + log.info( + { decision: decisionLogFields(decision), mode: cfg.model }, + "model decision" + ) + + if (cfg.model === "cvar") { + if (decision.legs) { + const transaction = buildStartRoundTx( + cfg.packageId, + config, + cfg, + state, + oracle, + decision.legs.dn.strike, + decision.legs.up.strike, + decision.legs.dn.quantity, + decision.legs.up.quantity, + sender + ) + const simulation = await simulateTransaction(client, transaction) + + if (simulation.ok) { + return { + logFields: { + downQuantity: decision.legs.dn.quantity, + downStrike: decision.legs.dn.strike, + expiryMs: oracle.expiryMs, + model: "cvar", + oracleId: oracle.oracleId, + spot, + upQuantity: decision.legs.up.quantity, + upStrike: decision.legs.up.strike, + }, + simulation, + transaction, + } + } + log.warn( + toLogFields({ error: simulation.error }), + "model collar failed simulation; falling back to legacy sizing" + ) + } else { + log.info( + { reason: decision.skippedReason }, + "model skipped the collar; falling back to legacy sizing" + ) + } + } + } + const quantity = bpsAmount(state.nav, cfg.quantityBpsOfNav) if (quantity <= 0n) { log.info("start skipped: computed leg quantity is zero") @@ -137,6 +202,7 @@ export function createDualLegDriver( downStrike, upStrike, quantity, + quantity, sender ) const simulation = await simulateTransaction(client, transaction) From d46763e148688432291701acc9450d76ff3a812b Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 13:08:44 +0100 Subject: [PATCH 08/33] feat: surface each vault's live hedge decision from operator to app --- .../backend/drizzle/0005_gray_eternals.sql | 11 + .../backend/drizzle/meta/0005_snapshot.json | 1319 +++++++++++++++++ services/backend/drizzle/meta/_journal.json | 7 + services/backend/src/api.ts | 48 + services/backend/src/config.ts | 5 + services/backend/src/db/repo.ts | 23 + services/backend/src/db/schema.ts | 23 +- services/operator/src/config.ts | 14 + services/operator/src/model/decide.ts | 37 + services/operator/src/strategies/dual-leg.ts | 3 +- .../operator/src/strategies/hedged-plp.ts | 9 +- .../strategies/model-decision-card.tsx | 162 ++ .../components/strategies/strategy-detail.tsx | 176 ++- web/src/lib/strategies/model-decision.ts | 150 ++ 14 files changed, 1954 insertions(+), 33 deletions(-) create mode 100644 services/backend/drizzle/0005_gray_eternals.sql create mode 100644 services/backend/drizzle/meta/0005_snapshot.json create mode 100644 web/src/components/strategies/model-decision-card.tsx create mode 100644 web/src/lib/strategies/model-decision.ts diff --git a/services/backend/drizzle/0005_gray_eternals.sql b/services/backend/drizzle/0005_gray_eternals.sql new file mode 100644 index 0000000..683eb0e --- /dev/null +++ b/services/backend/drizzle/0005_gray_eternals.sql @@ -0,0 +1,11 @@ +CREATE TABLE "model_decisions" ( + "created_at_ms" bigint NOT NULL, + "decision_json" text NOT NULL, + "id" serial PRIMARY KEY NOT NULL, + "inputs_hash" text NOT NULL, + "mode" text NOT NULL, + "oracle_id" text NOT NULL, + "strategy_kind" text NOT NULL +); +--> statement-breakpoint +CREATE INDEX "model_decisions_kind_time_idx" ON "model_decisions" USING btree ("strategy_kind","created_at_ms"); \ No newline at end of file diff --git a/services/backend/drizzle/meta/0005_snapshot.json b/services/backend/drizzle/meta/0005_snapshot.json new file mode 100644 index 0000000..e0e639f --- /dev/null +++ b/services/backend/drizzle/meta/0005_snapshot.json @@ -0,0 +1,1319 @@ +{ + "id": "44c1d057-f5b5-44fa-a204-95e9026cbaff", + "prevId": "f2dcb723-f9c2-4940-ac9f-501fe1874e14", + "version": "7", + "dialect": "postgresql", + "tables": { + "public.arena_activity": { + "name": "arena_activity", + "schema": "", + "columns": { + "actor": { + "name": "actor", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "call_label": { + "name": "call_label", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "kind": { + "name": "kind", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "timestamp_ms": { + "name": "timestamp_ms", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "arena_activity_call_idx": { + "name": "arena_activity_call_idx", + "columns": [ + { + "expression": "call_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "arena_activity_event_id_unique": { + "name": "arena_activity_event_id_unique", + "nullsNotDistinct": false, + "columns": [ + "event_id" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_bond_claimed_events": { + "name": "arena_bond_claimed_events", + "schema": "", + "columns": { + "bond_plp_amount": { + "name": "bond_plp_amount", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "claimed_at_ms": { + "name": "claimed_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "digest": { + "name": "digest", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_index": { + "name": "event_index", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "oracle_id": { + "name": "oracle_id", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_bond_reclaimed_events": { + "name": "arena_bond_reclaimed_events", + "schema": "", + "columns": { + "bond_plp_amount": { + "name": "bond_plp_amount", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "digest": { + "name": "digest", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_index": { + "name": "event_index", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "reclaimed_at_ms": { + "name": "reclaimed_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_call_backed_events": { + "name": "arena_call_backed_events", + "schema": "", + "columns": { + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "cost": { + "name": "cost", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "digest": { + "name": "digest", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_index": { + "name": "event_index", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "manager_id": { + "name": "manager_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "participant": { + "name": "participant", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "quantity": { + "name": "quantity", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "recorded_at_ms": { + "name": "recorded_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "refund_amount": { + "name": "refund_amount", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_call_faded_events": { + "name": "arena_call_faded_events", + "schema": "", + "columns": { + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "cost": { + "name": "cost", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "digest": { + "name": "digest", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_index": { + "name": "event_index", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "manager_id": { + "name": "manager_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "participant": { + "name": "participant", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "quantity": { + "name": "quantity", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "recorded_at_ms": { + "name": "recorded_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "refund_amount": { + "name": "refund_amount", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_call_launched_events": { + "name": "arena_call_launched_events", + "schema": "", + "columns": { + "arena_id": { + "name": "arena_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "bond_plp_amount": { + "name": "bond_plp_amount", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "created_at_ms": { + "name": "created_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "creator": { + "name": "creator", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "digest": { + "name": "digest", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_index": { + "name": "event_index", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "expiry": { + "name": "expiry", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "is_up": { + "name": "is_up", + "type": "boolean", + "primaryKey": false, + "notNull": true + }, + "oracle_id": { + "name": "oracle_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "predict_id": { + "name": "predict_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "strike": { + "name": "strike", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_calls": { + "name": "arena_calls", + "schema": "", + "columns": { + "backers": { + "name": "backers", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 0 + }, + "bond_plp_amount": { + "name": "bond_plp_amount", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "bond_claimed": { + "name": "bond_claimed", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "created_at_ms": { + "name": "created_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "creator": { + "name": "creator", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "expiry": { + "name": "expiry", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "faders": { + "name": "faders", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 0 + }, + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "is_up": { + "name": "is_up", + "type": "boolean", + "primaryKey": false, + "notNull": true + }, + "oracle_id": { + "name": "oracle_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "predict_id": { + "name": "predict_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "strike": { + "name": "strike", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "arena_calls_creator_idx": { + "name": "arena_calls_creator_idx", + "columns": [ + { + "expression": "creator", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "arena_calls_call_id_unique": { + "name": "arena_calls_call_id_unique", + "nullsNotDistinct": false, + "columns": [ + "call_id" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_creators": { + "name": "arena_creators", + "schema": "", + "columns": { + "address": { + "name": "address", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "bonded_plp": { + "name": "bonded_plp", + "type": "text", + "primaryKey": false, + "notNull": true, + "default": "'0'" + }, + "call_count": { + "name": "call_count", + "type": "integer", + "primaryKey": false, + "notNull": true, + "default": 0 + }, + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "arena_creators_address_unique": { + "name": "arena_creators_address_unique", + "nullsNotDistinct": false, + "columns": [ + "address" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.arena_participations": { + "name": "arena_participations", + "schema": "", + "columns": { + "call_id": { + "name": "call_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "cost": { + "name": "cost", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "participant": { + "name": "participant", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "quantity": { + "name": "quantity", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "recorded_at_ms": { + "name": "recorded_at_ms", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "side": { + "name": "side", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "arena_participations_call_idx": { + "name": "arena_participations_call_idx", + "columns": [ + { + "expression": "call_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "arena_participations_participant_idx": { + "name": "arena_participations_participant_idx", + "columns": [ + { + "expression": "participant", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "arena_participations_event_id_unique": { + "name": "arena_participations_event_id_unique", + "nullsNotDistinct": false, + "columns": [ + "event_id" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.ingest_cursors": { + "name": "ingest_cursors", + "schema": "", + "columns": { + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "pipeline": { + "name": "pipeline", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "updated_at": { + "name": "updated_at", + "type": "bigint", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.metadata": { + "name": "metadata", + "schema": "", + "columns": { + "content_json": { + "name": "content_json", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "content_type": { + "name": "content_type", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "created_at": { + "name": "created_at", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "hash": { + "name": "hash", + "type": "text", + "primaryKey": true, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.model_decisions": { + "name": "model_decisions", + "schema": "", + "columns": { + "created_at_ms": { + "name": "created_at_ms", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "decision_json": { + "name": "decision_json", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "id": { + "name": "id", + "type": "serial", + "primaryKey": true, + "notNull": true + }, + "inputs_hash": { + "name": "inputs_hash", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "mode": { + "name": "mode", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "oracle_id": { + "name": "oracle_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "strategy_kind": { + "name": "strategy_kind", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "model_decisions_kind_time_idx": { + "name": "model_decisions_kind_time_idx", + "columns": [ + { + "expression": "strategy_kind", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "created_at_ms", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.raw_events": { + "name": "raw_events", + "schema": "", + "columns": { + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "checkpoint_timestamp_ms": { + "name": "checkpoint_timestamp_ms", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "contents": { + "name": "contents", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "digest": { + "name": "digest", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "event_id": { + "name": "event_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "event_index": { + "name": "event_index", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "event_type": { + "name": "event_type", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "inserted_at": { + "name": "inserted_at", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "json": { + "name": "json", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "module": { + "name": "module", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "package_id": { + "name": "package_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "sender": { + "name": "sender", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "tx_index": { + "name": "tx_index", + "type": "integer", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "raw_events_checkpoint_idx": { + "name": "raw_events_checkpoint_idx", + "columns": [ + { + "expression": "checkpoint", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "raw_events_package_idx": { + "name": "raw_events_package_idx", + "columns": [ + { + "expression": "package_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.strategy_fold_state": { + "name": "strategy_fold_state", + "schema": "", + "columns": { + "last_round": { + "name": "last_round", + "type": "integer", + "primaryKey": false, + "notNull": false + }, + "strategy_id": { + "name": "strategy_id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "supply": { + "name": "supply", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "updated_checkpoint": { + "name": "updated_checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.strategy_perf_snapshot": { + "name": "strategy_perf_snapshot", + "schema": "", + "columns": { + "checkpoint": { + "name": "checkpoint", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "event_seq": { + "name": "event_seq", + "type": "integer", + "primaryKey": false, + "notNull": true + }, + "kind": { + "name": "kind", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "nav": { + "name": "nav", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "share_price": { + "name": "share_price", + "type": "double precision", + "primaryKey": false, + "notNull": true + }, + "strategy_id": { + "name": "strategy_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "timestamp_ms": { + "name": "timestamp_ms", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "total_shares": { + "name": "total_shares", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "tx_digest": { + "name": "tx_digest", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "strategy_perf_strategy_timestamp_idx": { + "name": "strategy_perf_strategy_timestamp_idx", + "columns": [ + { + "expression": "strategy_id", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "timestamp_ms", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + }, + "strategy_perf_tx_event_unique": { + "name": "strategy_perf_tx_event_unique", + "columns": [ + { + "expression": "tx_digest", + "isExpression": false, + "asc": true, + "nulls": "last" + }, + { + "expression": "event_seq", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": true, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": {}, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.users": { + "name": "users", + "schema": "", + "columns": { + "avatar_url": { + "name": "avatar_url", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "created_at": { + "name": "created_at", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "display_name": { + "name": "display_name", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "dynamic_user_id": { + "name": "dynamic_user_id", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "email": { + "name": "email", + "type": "text", + "primaryKey": false, + "notNull": false + }, + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "updated_at": { + "name": "updated_at", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "username": { + "name": "username", + "type": "text", + "primaryKey": false, + "notNull": false + } + }, + "indexes": {}, + "foreignKeys": {}, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "users_dynamic_user_id_unique": { + "name": "users_dynamic_user_id_unique", + "nullsNotDistinct": false, + "columns": [ + "dynamic_user_id" + ] + }, + "users_email_unique": { + "name": "users_email_unique", + "nullsNotDistinct": false, + "columns": [ + "email" + ] + }, + "users_username_unique": { + "name": "users_username_unique", + "nullsNotDistinct": false, + "columns": [ + "username" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + }, + "public.wallets": { + "name": "wallets", + "schema": "", + "columns": { + "address": { + "name": "address", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "chain": { + "name": "chain", + "type": "text", + "primaryKey": false, + "notNull": true + }, + "id": { + "name": "id", + "type": "text", + "primaryKey": true, + "notNull": true + }, + "is_primary": { + "name": "is_primary", + "type": "boolean", + "primaryKey": false, + "notNull": true, + "default": false + }, + "linked_at": { + "name": "linked_at", + "type": "bigint", + "primaryKey": false, + "notNull": true + }, + "user_id": { + "name": "user_id", + "type": "text", + "primaryKey": false, + "notNull": true + } + }, + "indexes": { + "wallets_user_idx": { + "name": "wallets_user_idx", + "columns": [ + { + "expression": "user_id", + "isExpression": false, + "asc": true, + "nulls": "last" + } + ], + "isUnique": false, + "concurrently": false, + "method": "btree", + "with": {} + } + }, + "foreignKeys": { + "wallets_user_id_users_id_fk": { + "name": "wallets_user_id_users_id_fk", + "tableFrom": "wallets", + "tableTo": "users", + "columnsFrom": [ + "user_id" + ], + "columnsTo": [ + "id" + ], + "onDelete": "no action", + "onUpdate": "no action" + } + }, + "compositePrimaryKeys": {}, + "uniqueConstraints": { + "wallets_address_unique": { + "name": "wallets_address_unique", + "nullsNotDistinct": false, + "columns": [ + "address" + ] + } + }, + "policies": {}, + "checkConstraints": {}, + "isRLSEnabled": false + } + }, + "enums": {}, + "schemas": {}, + "sequences": {}, + "roles": {}, + "policies": {}, + "views": {}, + "_meta": { + "columns": {}, + "schemas": {}, + "tables": {} + } +} \ No newline at end of file diff --git a/services/backend/drizzle/meta/_journal.json b/services/backend/drizzle/meta/_journal.json index f195abf..bfe5dde 100644 --- a/services/backend/drizzle/meta/_journal.json +++ b/services/backend/drizzle/meta/_journal.json @@ -36,6 +36,13 @@ "when": 1782381687176, "tag": "0004_marvelous_zarek", "breakpoints": true + }, + { + "idx": 5, + "version": "7", + "when": 1783770308783, + "tag": "0005_gray_eternals", + "breakpoints": true } ] } \ No newline at end of file diff --git a/services/backend/src/api.ts b/services/backend/src/api.ts index 6e82fdc..a3029ef 100644 --- a/services/backend/src/api.ts +++ b/services/backend/src/api.ts @@ -69,6 +69,14 @@ const profileBodySchema = z.object({ username: usernameSchema.optional(), }) +const modelDecisionPostSchema = z.object({ + decision: z.unknown(), + inputs_hash: z.string().min(1), + mode: z.enum(["shadow", "cvar"]), + oracle_id: z.string().min(1), + strategy_kind: z.string().min(1), +}) + const performanceRangeSchema = z.enum(["ALL", "30D", "7D"]).default("ALL") interface ProfileResponse { @@ -377,6 +385,46 @@ export function buildApi(config: Config, repo: Repository) { window_days: annualized?.windowDays ?? null, } }) + // Latest exposure-model decision for a strategy kind (hedged_plp / + // plp_collar). Public read; rows are posted by the operator below. + .get("/strategies/:id/model-decision", async ({ params, set }) => { + const row = await repo.latestModelDecision(params.id.toLowerCase()) + if (!row) { + set.status = 404 + return { error: "no model decision recorded for this strategy" } + } + return { + created_at_ms: row.createdAtMs, + decision: JSON.parse(row.decisionJson) as unknown, + inputs_hash: row.inputsHash, + mode: row.mode, + oracle_id: row.oracleId, + strategy_kind: row.strategyKind, + } + }) + // Operator-only write path, gated by a shared token. Disabled entirely + // when no token is configured. + .post("/internal/model-decisions", async ({ body, headers, set }) => { + if (config.modelDecisionsToken === "") { + set.status = 503 + return { error: "model decision ingestion is not configured" } + } + if (headers.authorization !== `Bearer ${config.modelDecisionsToken}`) { + set.status = 401 + return { error: "unauthorized" } + } + + const parsed = modelDecisionPostSchema.parse(body) + await repo.insertModelDecision({ + createdAtMs: Date.now(), + decisionJson: JSON.stringify(parsed.decision), + inputsHash: parsed.inputs_hash, + mode: parsed.mode, + oracleId: parsed.oracle_id, + strategyKind: parsed.strategy_kind.toLowerCase(), + }) + return { ok: true } + }) .get( "/arena/creators/:addressOrHandle", async ({ params, set }): Promise => { diff --git a/services/backend/src/config.ts b/services/backend/src/config.ts index ae2f0c3..e72e9de 100644 --- a/services/backend/src/config.ts +++ b/services/backend/src/config.ts @@ -13,6 +13,9 @@ export interface Config { ingestStartCheckpoint: bigint | null; jwtSecret: string; jwtTtlSeconds: number; + /// Shared secret the operator presents when posting model decisions. + /// Empty disables the internal write route. + modelDecisionsToken: string; port: number; predictObjectId: string; predictPackageId: string; @@ -120,6 +123,7 @@ const configSchema = z INGEST_POLL_SECONDS: envPositiveInteger(15), INGEST_START_CHECKPOINT: optionalBigintString, JWT_SECRET: requiredEnvString, + MODEL_DECISIONS_TOKEN: envString(""), JWT_TTL_SECONDS: envPositiveInteger(86400), PORT: envPositiveInteger(8080), PREDICT_OBJECT_ID: requiredEnvString, @@ -164,6 +168,7 @@ const configSchema = z ingestPollSeconds: env.INGEST_POLL_SECONDS, ingestStartCheckpoint: env.INGEST_START_CHECKPOINT, jwtSecret: env.JWT_SECRET, + modelDecisionsToken: env.MODEL_DECISIONS_TOKEN, jwtTtlSeconds: env.JWT_TTL_SECONDS, port: env.PORT, predictObjectId: env.PREDICT_OBJECT_ID, diff --git a/services/backend/src/db/repo.ts b/services/backend/src/db/repo.ts index 39b4c99..ee79ae2 100644 --- a/services/backend/src/db/repo.ts +++ b/services/backend/src/db/repo.ts @@ -15,6 +15,7 @@ import { arenaParticipations, ingestCursors, metadata, + modelDecisions, rawEvents, strategyFoldState, strategyPerfSnapshots, @@ -25,6 +26,7 @@ import type { ArenaCallRow, ArenaCreatorRow, MetadataRow, + ModelDecisionRow, RawEventRow, StrategyPerfSnapshotRow, UserRow, @@ -117,6 +119,27 @@ export class Repository { // ----- metadata -------------------------------------------------------- + async insertModelDecision(row: { + createdAtMs: number + decisionJson: string + inputsHash: string + mode: string + oracleId: string + strategyKind: string + }): Promise { + await this.database.db.insert(modelDecisions).values(row) + } + + async latestModelDecision(strategyKind: string): Promise { + const rows = await this.database.db + .select() + .from(modelDecisions) + .where(eq(modelDecisions.strategyKind, strategyKind)) + .orderBy(desc(modelDecisions.createdAtMs)) + .limit(1) + return rows[0] ?? null + } + async storeMetadata(hash: string, contentJson: string, contentType: string): Promise { await this.database.db .insert(metadata) diff --git a/services/backend/src/db/schema.ts b/services/backend/src/db/schema.ts index a792824..d5a2f61 100644 --- a/services/backend/src/db/schema.ts +++ b/services/backend/src/db/schema.ts @@ -1,4 +1,4 @@ -import { bigint, boolean, doublePrecision, index, integer, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core" +import { bigint, boolean, doublePrecision, index, integer, pgTable, serial, text, uniqueIndex } from "drizzle-orm/pg-core" import type { InferSelectModel } from "drizzle-orm" // NOTE on u64 storage: Move u64 max (2^64-1) exceeds Postgres bigint @@ -78,6 +78,26 @@ export const strategyPerfSnapshots = pgTable( // Identity (Dynamic -> backend user + linked wallets) // --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// Strategy model decisions (operator-posted, one row per round decision) +// --------------------------------------------------------------------------- + +export const modelDecisions = pgTable( + "model_decisions", + { + createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(), + decisionJson: text("decision_json").notNull(), + id: serial("id").primaryKey(), + inputsHash: text("inputs_hash").notNull(), + mode: text("mode").notNull(), + oracleId: text("oracle_id").notNull(), + strategyKind: text("strategy_kind").notNull(), + }, + (table) => ({ + kindTimeIdx: index("model_decisions_kind_time_idx").on(table.strategyKind, table.createdAtMs), + }) +) + export const users = pgTable("users", { avatarUrl: text("avatar_url"), createdAt: bigint("created_at", { mode: "number" }).notNull(), @@ -248,6 +268,7 @@ export type ArenaCallRow = InferSelectModel export type ArenaCreatorRow = InferSelectModel export type ArenaParticipationRow = InferSelectModel export type MetadataRow = InferSelectModel +export type ModelDecisionRow = InferSelectModel export type RawEventRow = InferSelectModel export type StrategyFoldStateRow = InferSelectModel export type StrategyPerfSnapshotRow = InferSelectModel diff --git a/services/operator/src/config.ts b/services/operator/src/config.ts index 6a67bdd..53b41ee 100644 --- a/services/operator/src/config.ts +++ b/services/operator/src/config.ts @@ -41,6 +41,13 @@ export interface ModelConfig { washMinMBps: number } +export interface ReportingConfig { + /// Backend base URL for posting model decisions; empty disables posting. + backendUrl: string + /// Shared token the backend expects on the internal write route. + modelDecisionsToken: string +} + export interface GuardsConfig { dailyLossBps: number killFile: string @@ -89,6 +96,7 @@ export interface OperatorConfig { guards: GuardsConfig hedgedPlp: HedgedPlpConfig model: ModelConfig + reporting: ReportingConfig plpCollar: DualLegConfig pollSeconds: number predict: PredictConfig @@ -205,6 +213,8 @@ const envSchema = z GUARD_NAV_DRIFT_BPS: envNumber(50), GUARD_KILL_FILE: envString("operator.kill"), GUARD_STATE_FILE: envString("guards-state.json"), + OPERATOR_BACKEND_URL: envString(""), + MODEL_DECISIONS_TOKEN: envString(""), RANGE_LADDER_ENABLED: envBoolean(true), RANGE_QUANTITY_BPS_OF_NAV: envNumber(250), RANGE_RUNG_COUNT: envNumber(2), @@ -384,6 +394,10 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): OperatorConfig navDriftBps: parsed.GUARD_NAV_DRIFT_BPS, stateFile: parsed.GUARD_STATE_FILE, }, + reporting: { + backendUrl: parsed.OPERATOR_BACKEND_URL.replace(/\/$/, ""), + modelDecisionsToken: parsed.MODEL_DECISIONS_TOKEN, + }, model: { alphaBps: parsed.MODEL_CVAR_ALPHA_BPS, budgetBps: parsed.MODEL_BUDGET_BPS, diff --git a/services/operator/src/model/decide.ts b/services/operator/src/model/decide.ts index e631a35..090e7d1 100644 --- a/services/operator/src/model/decide.ts +++ b/services/operator/src/model/decide.ts @@ -407,3 +407,40 @@ export function decisionLogFields( ) ) as Record } + +/// Fire-and-forget post of a decision to the backend so the app can display +/// it. Never throws and never blocks the round; posting is disabled unless +/// both the backend URL and the shared token are configured. +export async function postModelDecision( + config: OperatorConfig, + strategyKind: string, + mode: "shadow" | "cvar", + oracleId: string, + decision: HedgeDecision | CollarDecision +): Promise { + const { backendUrl, modelDecisionsToken } = config.reporting + if (backendUrl === "" || modelDecisionsToken === "") { + return false + } + + try { + const response = await fetch(`${backendUrl}/internal/model-decisions`, { + body: JSON.stringify({ + decision: decisionLogFields(decision), + inputs_hash: decision.diagnostics.inputsHash, + mode, + oracle_id: oracleId, + strategy_kind: strategyKind, + }), + headers: { + authorization: `Bearer ${modelDecisionsToken}`, + "content-type": "application/json", + }, + method: "POST", + signal: AbortSignal.timeout(10_000), + }) + return response.ok + } catch { + return false + } +} diff --git a/services/operator/src/strategies/dual-leg.ts b/services/operator/src/strategies/dual-leg.ts index d208814..9421224 100644 --- a/services/operator/src/strategies/dual-leg.ts +++ b/services/operator/src/strategies/dual-leg.ts @@ -3,7 +3,7 @@ import { Transaction } from "@mysten/sui/transactions" import type { DualLegConfig, OperatorConfig } from "../config.ts" import { bpsAmount, chooseDownsideStrike, chooseUpsideStrike } from "../grid.ts" import { toLogFields } from "../logger.ts" -import { decideCollar, decisionLogFields } from "../model/decide.ts" +import { decideCollar, decisionLogFields, postModelDecision } from "../model/decide.ts" import type { OracleInfo } from "../predict.ts" import { simulateTransaction } from "../sui.ts" import { readStrategyState, type StrategyState } from "../strategy-state.ts" @@ -127,6 +127,7 @@ export function createDualLegDriver( { decision: decisionLogFields(decision), mode: cfg.model }, "model decision" ) + void postModelDecision(config, kind, cfg.model, oracle.oracleId, decision) if (cfg.model === "cvar") { if (decision.legs) { diff --git a/services/operator/src/strategies/hedged-plp.ts b/services/operator/src/strategies/hedged-plp.ts index ff74e48..ea5adcd 100644 --- a/services/operator/src/strategies/hedged-plp.ts +++ b/services/operator/src/strategies/hedged-plp.ts @@ -3,7 +3,7 @@ import { Transaction } from "@mysten/sui/transactions" import type { OperatorConfig } from "../config.ts" import { bpsAmount, chooseDownsideStrike } from "../grid.ts" import { toLogFields } from "../logger.ts" -import { decideHedgedPlp, decisionLogFields } from "../model/decide.ts" +import { decideHedgedPlp, decisionLogFields, postModelDecision } from "../model/decide.ts" import type { OracleInfo } from "../predict.ts" import { simulateTransaction } from "../sui.ts" import { readHedgedPlpStrategy, type HedgedPlpStrategyState } from "../strategy-state.ts" @@ -128,6 +128,13 @@ export const hedgedPlpDriver: StrategyDriver = { { decision: decisionLogFields(decision), mode: config.hedgedPlp.model }, "model decision" ) + void postModelDecision( + config, + "hedged_plp", + config.hedgedPlp.model, + oracle.oracleId, + decision + ) if (config.hedgedPlp.model === "cvar") { if (decision.hedge) { diff --git a/web/src/components/strategies/model-decision-card.tsx b/web/src/components/strategies/model-decision-card.tsx new file mode 100644 index 0000000..df707da --- /dev/null +++ b/web/src/components/strategies/model-decision-card.tsx @@ -0,0 +1,162 @@ +import { useEffect, useState } from "react" + +import { Badge, BadgeTone } from "@/components/primitives/badge" +import { DataRow } from "@/components/primitives/data-row" +import { + fetchModelDecision, + modelKindFor, + SKIP_REASON_COPY, +} from "@/lib/strategies/model-decision" +import type { ModelDecision } from "@/lib/strategies/model-decision" +import { formatStrikeUsd, formatUsd } from "@/lib/strategies/format" +import type { StrategyMeta } from "@/lib/strategies/registry" + +// The exposure model's latest round decision for the PLP-carrying vaults: +// the vault's actual pool share, whether the hedge is genuine (not paying the +// vault back its own premium), the tail risk before/after, and the safe +// deposit size. Every figure is computed from the live on-chain pool book and +// reproducible from the recorded inputs hash. + +function formatPercent(fraction: number): string { + if (fraction === 0) { + return "0%" + } + if (fraction < 0.0001) { + return "<0.01%" + } + return `${(fraction * 100).toFixed(2)}%` +} + +function formatCvar(quoteUnits: number): string { + const dollars = quoteUnits / 1e6 + const sign = dollars < 0 ? "-" : "" + return `${sign}$${Math.abs(dollars).toFixed(2)}` +} + +export function ModelDecisionCard({ meta }: { meta: StrategyMeta }) { + const [decision, setDecision] = useState() + + useEffect(() => { + let isStale = false + + fetchModelDecision(meta.key).then((result) => { + if (!isStale) { + setDecision(result) + } + }) + + return () => { + isStale = true + } + }, [meta.key]) + + if (!modelKindFor(meta.key)) { + return null + } + + return ( +
+
+

+ Hedge decision +

+ {decision ? ( + + {decision.mode === "cvar" ? "Executing" : "Shadow"} + + ) : null} +
+ + {decision === undefined ? ( +

Loading…

+ ) : decision === null ? ( +

+ No model decision recorded yet. One appears each time the operator + evaluates a round. +

+ ) : ( + <> +
+ + {decision.effectiveMultiplier !== null ? ( + + ) : null} + + + + {decision.hedge ? ( + <> + + + + ) : null} + {decision.collarLegs ? ( + <> + + + + ) : null} +
+ + {decision.skippedReason ? ( +

+ {SKIP_REASON_COPY[decision.skippedReason]} +

+ ) : null} + +

+ {new Date(decision.createdAtMs).toLocaleString()} · inputs{" "} + {decision.inputsHash.slice(0, 10)}… +

+ + )} +
+ ) +} diff --git a/web/src/components/strategies/strategy-detail.tsx b/web/src/components/strategies/strategy-detail.tsx index 78b701b..8cd18d9 100644 --- a/web/src/components/strategies/strategy-detail.tsx +++ b/web/src/components/strategies/strategy-detail.tsx @@ -26,9 +26,13 @@ import type { StrategyState } from "@/lib/strategies/types" import { useStrategyAction } from "@/lib/strategies/use-strategy-action" import type { StrategyPerformanceResponse } from "@/services/strategy-performance-client" import { StrategyActionDialog } from "./action-dialog" +import { ModelDecisionCard } from "./model-decision-card" import { StrategyLifecycle } from "./position-lifecycle" -function allocationSegments(meta: StrategyMeta, state: StrategyState): AllocationSegment[] | undefined { +function allocationSegments( + meta: StrategyMeta, + state: StrategyState +): AllocationSegment[] | undefined { const parts = meta.allocation.map((segment) => ({ ...segment, weight: state.policy[segment.field] ?? 0, @@ -74,11 +78,15 @@ function OverviewCard({ performance: StrategyPerformanceResponse state: StrategyState }) { - const annualized = annualizedReturn(getDisplayChartPoints(performance.points).points) + const annualized = annualizedReturn( + getDisplayChartPoints(performance.points).points + ) return (
-

Overview

+

+ Overview +

@@ -104,26 +112,44 @@ function OverviewCard({
- +
{meta.hasPlp ? ( - + ) : null} {state.reservedBaseShares > 0n ? ( - + ) : null} {state.pendingShares > 0n ? ( - + ) : null}
) } -function RoundCard({ meta, state }: { meta: StrategyMeta; state: StrategyState }) { +function RoundCard({ + meta, + state, +}: { + meta: StrategyMeta + state: StrategyState +}) { const status = getStrategyStatus(state) const round = state.round // Gate the per-second countdown behind mount: the round data is present at SSR, @@ -133,11 +159,16 @@ function RoundCard({ meta, state }: { meta: StrategyMeta; state: StrategyState } return (
-

Current round

+

+ Current round +

{round?.expiryMs && mounted ? ( ) : ( - + {status} )} @@ -154,22 +185,60 @@ function RoundCard({ meta, state }: { meta: StrategyMeta; state: StrategyState } <> {meta.shape === "single" ? ( <> - - + + ) : null} {meta.shape === "dual" ? ( <> - - - - + + + + ) : null} {meta.shape === "ladder" ? ( - + ) : null} - + ) : ( @@ -179,10 +248,18 @@ function RoundCard({ meta, state }: { meta: StrategyMeta; state: StrategyState } ) } -function PolicyCard({ meta, state }: { meta: StrategyMeta; state: StrategyState }) { +function PolicyCard({ + meta, + state, +}: { + meta: StrategyMeta + state: StrategyState +}) { return (
-

Policy

+

+ Policy +

{meta.policyFields.map((field) => { const value = state.policy[field.field] @@ -218,7 +295,10 @@ function PositionPromptStatic() { Connect your wallet to deposit DUSDC and hold shares.

- ) @@ -226,11 +306,19 @@ function PositionPromptStatic() { // Wallet state depends on Dynamic, whose store isn't available during SSR. Gate // it behind mount so Hero/Overview/Round/Policy still server-render. -function PositionPanel({ meta, state }: { meta: StrategyMeta; state: StrategyState }) { +function PositionPanel({ + meta, + state, +}: { + meta: StrategyMeta + state: StrategyState +}) { const mounted = useMounted() return (
-

Your position

+

+ Your position +

{mounted ? ( ) : ( @@ -240,7 +328,13 @@ function PositionPanel({ meta, state }: { meta: StrategyMeta; state: StrategySta ) } -function PositionBody({ meta, state }: { meta: StrategyMeta; state: StrategyState }) { +function PositionBody({ + meta, + state, +}: { + meta: StrategyMeta + state: StrategyState +}) { const controller = useStrategyAction(meta, state) const { address, connect, openDialog, wallet } = controller const value = wallet ? positionValue(wallet.shareBalance, state) : 0n @@ -256,15 +350,30 @@ function PositionBody({ meta, state }: { meta: StrategyMeta; state: StrategyStat
- - + +
- -
@@ -275,7 +384,11 @@ function PositionBody({ meta, state }: { meta: StrategyMeta; state: StrategyStat Connect your wallet to deposit DUSDC and hold shares.

-
@@ -300,7 +413,9 @@ export function StrategyDetail({ return (
-

{meta.name}

+

+ {meta.name} +

This vault is unavailable right now. Try refreshing.

@@ -328,6 +443,7 @@ export function StrategyDetail({
+
diff --git a/web/src/lib/strategies/model-decision.ts b/web/src/lib/strategies/model-decision.ts new file mode 100644 index 0000000..2945052 --- /dev/null +++ b/web/src/lib/strategies/model-decision.ts @@ -0,0 +1,150 @@ +import { BACKEND_URL } from "@/lib/config" +import type { StrategyKey } from "@/services/strategy-transactions" + +// The operator posts one exposure-model decision per evaluated round for the +// PLP-carrying vaults; the backend serves the latest. Amounts arrive as +// stringified DUSDC micro units, CVaR figures as quote-unit floats. + +export type ModelDecisionMode = "shadow" | "cvar" + +export type ModelSkipReason = + | "wash" + | "budget" + | "no_viable_strike" + | "no_book_data" + | "negligible_improvement" + +export interface ModelDecisionLeg { + premium: bigint + quantity: bigint + strike: bigint +} + +export interface ModelDecision { + createdAtMs: number + mode: ModelDecisionMode + oracleId: string + inputsHash: string + f: number + effectiveMultiplier: number | null + cvarBefore: number + cvarAfter: number + safeDepositHint: bigint + skippedReason: ModelSkipReason | null + hedge: ModelDecisionLeg | null + collarLegs: { dn: ModelDecisionLeg; up: ModelDecisionLeg } | null +} + +const MODEL_KIND_BY_KEY: Partial> = { + "hedged-plp": "hedged_plp", + "plp-collar": "plp_collar", +} + +export function modelKindFor(key: StrategyKey): string | undefined { + return MODEL_KIND_BY_KEY[key] +} + +function asRecord(value: unknown): Record { + return typeof value === "object" && value !== null + ? (value as Record) + : {} +} + +function bigintFrom(value: unknown): bigint { + if (typeof value === "string" && /^\d+$/.test(value)) { + return BigInt(value) + } + if (typeof value === "number" && Number.isInteger(value)) { + return BigInt(value) + } + return 0n +} + +function numberFrom(value: unknown): number { + return typeof value === "number" && Number.isFinite(value) ? value : 0 +} + +function legFrom(value: unknown): ModelDecisionLeg | null { + const leg = asRecord(value) + if (!("strike" in leg)) { + return null + } + return { + premium: bigintFrom(leg.premium), + quantity: bigintFrom(leg.quantity), + strike: bigintFrom(leg.strike), + } +} + +const SKIP_REASONS: ModelSkipReason[] = [ + "wash", + "budget", + "no_viable_strike", + "no_book_data", + "negligible_improvement", +] + +// Latest decision for a strategy, or null when none is recorded (404) or the +// backend is unreachable. +export async function fetchModelDecision( + key: StrategyKey +): Promise { + const kind = modelKindFor(key) + if (!kind || BACKEND_URL === "") { + return null + } + + try { + const response = await fetch( + `${BACKEND_URL}/strategies/${encodeURIComponent(kind)}/model-decision` + ) + if (!response.ok) { + return null + } + + const body = asRecord(await response.json()) + const decision = asRecord(body.decision) + const diagnostics = asRecord(decision.diagnostics) + const mode = body.mode === "cvar" ? "cvar" : "shadow" + const skipped = decision.skippedReason + const legs = asRecord(decision.legs) + + return { + collarLegs: + "dn" in legs && "up" in legs + ? { + dn: legFrom(legs.dn) ?? { premium: 0n, quantity: 0n, strike: 0n }, + up: legFrom(legs.up) ?? { premium: 0n, quantity: 0n, strike: 0n }, + } + : null, + createdAtMs: numberFrom(body.created_at_ms), + cvarAfter: numberFrom(diagnostics.cvarAfter), + cvarBefore: numberFrom(diagnostics.cvarBefore), + effectiveMultiplier: + typeof diagnostics.mAtStrike === "number" + ? diagnostics.mAtStrike + : null, + f: numberFrom(diagnostics.f), + hedge: legFrom(decision.hedge), + inputsHash: typeof body.inputs_hash === "string" ? body.inputs_hash : "", + mode, + oracleId: typeof body.oracle_id === "string" ? body.oracle_id : "", + safeDepositHint: bigintFrom(diagnostics.safeDepositHint), + skippedReason: SKIP_REASONS.includes(skipped as ModelSkipReason) + ? (skipped as ModelSkipReason) + : null, + } + } catch { + return null + } +} + +export const SKIP_REASON_COPY: Record = { + budget: "Skipped: the premium budget is too small to buy a whole contract.", + negligible_improvement: + "Skipped: the best available hedge barely moves the tail.", + no_book_data: "Skipped: the pool carries no book on this market yet.", + no_viable_strike: + "Skipped: no strike improves the vault's tail at current prices.", + wash: "Skipped: at the current pool share the hedge would pay the vault back its own premium.", +} From 7e123dfb66ff949ba18a628f34eab2ee78721be1 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 13:12:06 +0100 Subject: [PATCH 09/33] fix(web): fail production builds that lack service urls instead of rendering empty --- web/package.json | 2 +- web/scripts/check-prod-env.ts | 35 +++++++++++++++++++ web/src/components/arena/page.tsx | 2 ++ web/src/components/keeper/page.tsx | 2 ++ .../services-misconfigured-notice.tsx | 19 ++++++++++ web/src/lib/config.ts | 8 +++++ 6 files changed, 67 insertions(+), 1 deletion(-) create mode 100644 web/scripts/check-prod-env.ts create mode 100644 web/src/components/primitives/services-misconfigured-notice.tsx diff --git a/web/package.json b/web/package.json index 5648c80..5ea885f 100644 --- a/web/package.json +++ b/web/package.json @@ -4,7 +4,7 @@ "type": "module", "scripts": { "dev": "vite dev --port 3000", - "build": "vite build", + "build": "bun scripts/check-prod-env.ts && vite build", "deploy": "vite build && wrangler deploy", "preview": "vite preview", "test": "vitest run", diff --git a/web/scripts/check-prod-env.ts b/web/scripts/check-prod-env.ts new file mode 100644 index 0000000..5e940cd --- /dev/null +++ b/web/scripts/check-prod-env.ts @@ -0,0 +1,35 @@ +// Production build tripwire: the app's backend/keeper/sponsor URLs are baked +// at build time (VITE_*), and a production bundle built without them renders +// Arena and the keeper dashboard empty with no error. Coolify deploys always +// pass COOLIFY_FQDN as a build arg, so its presence marks a production build — +// fail the build there rather than ship a silently hollow app. +const isProductionDeploy = Boolean(process.env.COOLIFY_FQDN) + +if (isProductionDeploy) { + const failures: string[] = [] + const requireRemote = (name: string) => { + const value = process.env[name] ?? "" + if ( + value === "" || + value.includes("localhost") || + value.includes("127.0.0.1") + ) { + failures.push(`${name}=${value || "(unset)"}`) + } + } + + requireRemote("VITE_BACKEND_URL") + requireRemote("VITE_KEEPER_API_URL") + // Sponsorship is optional but a localhost value in prod is always a mistake. + const sponsor = process.env.VITE_SPONSOR_URL ?? "" + if (sponsor.includes("localhost") || sponsor.includes("127.0.0.1")) { + failures.push(`VITE_SPONSOR_URL=${sponsor}`) + } + + if (failures.length > 0) { + console.error( + `production build is missing/localhost service URLs:\n ${failures.join("\n ")}` + ) + process.exit(1) + } +} diff --git a/web/src/components/arena/page.tsx b/web/src/components/arena/page.tsx index 2feb5e2..38bfd91 100644 --- a/web/src/components/arena/page.tsx +++ b/web/src/components/arena/page.tsx @@ -20,6 +20,7 @@ import { getCallChance, percentFormatter, } from "./atoms" +import { ServicesMisconfiguredNotice } from "@/components/primitives/services-misconfigured-notice" import { CallActionDialog } from "./call-action-dialog" import { LaunchCallDialog } from "./launch-call-dialog" @@ -31,6 +32,7 @@ export function Page({ model }: ArenaPageProps) { return (
+
diff --git a/web/src/components/keeper/page.tsx b/web/src/components/keeper/page.tsx index a0fd73b..f5b1e8e 100644 --- a/web/src/components/keeper/page.tsx +++ b/web/src/components/keeper/page.tsx @@ -1,5 +1,6 @@ import { useRouter } from "@tanstack/react-router" import { useCallback, useEffect, useState } from "react" +import { ServicesMisconfiguredNotice } from "@/components/primitives/services-misconfigured-notice" import { KeeperHeader, KeeperStatusCockpit } from "./heartbeat" import { KeeperOffline } from "./offline" @@ -59,6 +60,7 @@ export function Page({ snapshot }: KeeperPageProps) { return (
+ void refresh(true)} refreshing={refreshing} diff --git a/web/src/components/primitives/services-misconfigured-notice.tsx b/web/src/components/primitives/services-misconfigured-notice.tsx new file mode 100644 index 0000000..5b5b0e4 --- /dev/null +++ b/web/src/components/primitives/services-misconfigured-notice.tsx @@ -0,0 +1,19 @@ +import { SERVICES_MISCONFIGURED } from "@/lib/config" + +// Rendered by surfaces that read the backend/keeper APIs: a production bundle +// built without those URLs would otherwise show an empty state that is +// indistinguishable from "no data yet". The build tripwire should make this +// unreachable; this is the belt to its suspenders. +export function ServicesMisconfiguredNotice() { + if (!SERVICES_MISCONFIGURED) { + return null + } + + return ( +

+ This build was produced without its service URLs (VITE_BACKEND_URL / + VITE_KEEPER_API_URL), so live data cannot load. Rebuild with the + production environment set. +

+ ) +} diff --git a/web/src/lib/config.ts b/web/src/lib/config.ts index a343272..47d907c 100644 --- a/web/src/lib/config.ts +++ b/web/src/lib/config.ts @@ -41,6 +41,14 @@ export const BACKEND_URL: string = export const KEEPER_API_URL: string = import.meta.env.VITE_KEEPER_API_URL ?? "http://localhost:8801" +// True when a production bundle fell back to localhost service URLs — the +// build tripwire (scripts/check-prod-env.ts) should prevent this, and surfaces +// that render from these services show a misconfiguration notice instead of an +// indistinguishable empty state. +export const SERVICES_MISCONFIGURED: boolean = + import.meta.env.PROD && + (!import.meta.env.VITE_BACKEND_URL || !import.meta.env.VITE_KEEPER_API_URL) + export const BASE_VAULT_ID = "0x725808c6e223395dabf586de6ac3b9051a9c71c9767353bf51ec43b0d0c5789a" From 1b40a0681bf284c02426645d186fc647b5ed40c7 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 13:36:23 +0100 Subject: [PATCH 10/33] feat(web): chart the live vol smile with pool mispricing and no-arb checks --- web/src/components/market-detail/page.tsx | 38 +++- .../market-detail/vol-panel/explainer.tsx | 37 ++++ .../market-detail/vol-panel/smile-chart.tsx | 198 +++++++++++++++++ .../market-detail/vol-panel/term-chart.tsx | 104 +++++++++ .../market-detail/vol-panel/vol-panel.tsx | 209 ++++++++++++++++++ web/src/lib/market-detail/vol-quotes.ts | 157 +++++++++++++ web/src/lib/market-detail/vol-surface.test.ts | 113 ++++++++++ web/src/lib/market-detail/vol-surface.ts | 156 +++++++++++++ 8 files changed, 1005 insertions(+), 7 deletions(-) create mode 100644 web/src/components/market-detail/vol-panel/explainer.tsx create mode 100644 web/src/components/market-detail/vol-panel/smile-chart.tsx create mode 100644 web/src/components/market-detail/vol-panel/term-chart.tsx create mode 100644 web/src/components/market-detail/vol-panel/vol-panel.tsx create mode 100644 web/src/lib/market-detail/vol-quotes.ts create mode 100644 web/src/lib/market-detail/vol-surface.test.ts create mode 100644 web/src/lib/market-detail/vol-surface.ts diff --git a/web/src/components/market-detail/page.tsx b/web/src/components/market-detail/page.tsx index 7a4b281..cbcd8ac 100644 --- a/web/src/components/market-detail/page.tsx +++ b/web/src/components/market-detail/page.tsx @@ -15,11 +15,14 @@ import { getTradeActivityRows, } from "@/lib/trade-activity" +import { Segmented } from "@/components/primitives/segmented" + import { ActivityTabs } from "./activity-tabs" import { ChartPanel } from "./chart-panel" import { ExpiryStrip } from "./expiry-strip" import { Header } from "./header" import { TradingTicket } from "./trading-ticket" +import { VolView } from "./vol-panel/vol-panel" import { Trades } from "./trades" export interface PageProps { @@ -51,6 +54,7 @@ export function Page({ selectedStrikePriceUsd, trades, }: PageProps) { + const [chartTab, setChartTab] = useState<"price" | "vol">("price") const [tradeIntent, setTradeIntent] = useState() const [activeStrikePriceUsd, setActiveStrikePriceUsd] = useState( selectedStrikePriceUsd @@ -82,13 +86,33 @@ export function Page({ selectedOracleId={market.oracleId} /> - +
+ +
+ + {chartTab === "price" ? ( + + ) : ( + + )}
diff --git a/web/src/components/market-detail/vol-panel/explainer.tsx b/web/src/components/market-detail/vol-panel/explainer.tsx new file mode 100644 index 0000000..df7df44 --- /dev/null +++ b/web/src/components/market-detail/vol-panel/explainer.tsx @@ -0,0 +1,37 @@ +import { ChevronDownIcon } from "lucide-react" + +import { + Collapsible, + CollapsibleContent, + CollapsibleTrigger, +} from "@/components/ui/collapsible" + +// Plain-language key for the vol panel, collapsed by default. +export function VolExplainer() { + return ( + + + How to read this + + + +
    +
  • + The teal line is our fair value for an Up position at each strike, + computed from the oracle's own volatility surface and checked + against on-chain pricing. +
    • +
  • The dots are what the pool actually quotes right now.
    • +
  • + Bars mark the gap: green means the pool prices below fair value, red + above it. +
    • +
  • + Red dots flag arbitrage-inconsistent prices. Stress shows a + simulated broken surface so you can see the check work. +
    • +
+ + + ) +} diff --git a/web/src/components/market-detail/vol-panel/smile-chart.tsx b/web/src/components/market-detail/vol-panel/smile-chart.tsx new file mode 100644 index 0000000..d2b91bf --- /dev/null +++ b/web/src/components/market-detail/vol-panel/smile-chart.tsx @@ -0,0 +1,198 @@ +import { + Bar, + Cell, + ComposedChart, + Line, + ReferenceLine, + ResponsiveContainer, + Tooltip, + XAxis, + YAxis, +} from "recharts" + +import type { SmilePoint } from "@/lib/market-detail/vol-surface" + +// The smile: our validated fair curve (line) vs the pool's executable mids +// (dots), with the mispricing between them as tone-coded bars. Clicking a +// strike loads it into the trade ticket. + +export interface SmileChartProps { + onSelectStrike: (strikeUsd: number) => void + points: SmilePoint[] + selectedStrikeUsd: number + spotUsd: number + violationStrikes: number[] +} + +interface ChartDatum { + strike: number + fair: number | null + mid: number | null + edge: number | null + violation: boolean +} + +const strikeFormatter = new Intl.NumberFormat("en-US", { + maximumFractionDigits: 0, +}) + +function formatProbability(value: number): string { + return `${(value * 100).toFixed(1)}%` +} + +function SmileTooltip({ + active, + payload, +}: { + active?: boolean + payload?: { payload: ChartDatum }[] +}) { + const datum = payload?.[0]?.payload + if (!active || !datum) { + return null + } + + return ( +
+
+ ${strikeFormatter.format(datum.strike)} +
+
+ fair {datum.fair === null ? "—" : formatProbability(datum.fair)} +
+
+ pool {datum.mid === null ? "—" : formatProbability(datum.mid)} +
+ {datum.edge !== null ? ( +
+ edge {(datum.edge * 10_000).toFixed(0)} bps +
+ ) : null} + {datum.violation ? ( +
butterfly violation
+ ) : null} +
+ ) +} + +export function SmileChart({ + onSelectStrike, + points, + selectedStrikeUsd, + spotUsd, + violationStrikes, +}: SmileChartProps) { + const violations = new Set(violationStrikes) + const data: ChartDatum[] = points.map((point) => ({ + edge: point.edge, + fair: point.fair, + mid: point.mid, + strike: point.strike, + violation: violations.has(point.strike), + })) + + return ( +
+ + { + // recharts' mouse-handler types don't surface activePayload; + // narrow structurally instead. + const payload = ( + state as { + activePayload?: { payload: ChartDatum }[] + } | null + )?.activePayload + const strike = payload?.[0]?.payload.strike + if (strike !== undefined) { + onSelectStrike(strike) + } + }} + > + + `$${strikeFormatter.format(value)}` + } + tickLine={false} + /> + `${Math.round(value * 100)}%`} + tickLine={false} + width={36} + /> + } + cursor={{ stroke: "var(--border)" }} + /> + + + + {data.map((datum) => ( + + ))} + + + { + const datum = payload as ChartDatum + if (cx === undefined || cy === undefined || datum.mid === null) { + return + } + return ( + + ) + }} + isAnimationActive={false} + stroke="transparent" + /> + + +
+ ) +} diff --git a/web/src/components/market-detail/vol-panel/term-chart.tsx b/web/src/components/market-detail/vol-panel/term-chart.tsx new file mode 100644 index 0000000..7591142 --- /dev/null +++ b/web/src/components/market-detail/vol-panel/term-chart.tsx @@ -0,0 +1,104 @@ +import { + Line, + LineChart, + ReferenceDot, + ResponsiveContainer, + Tooltip, + XAxis, + YAxis, +} from "recharts" + +import type { TermPoint } from "@/lib/market-detail/vol-surface" + +// ATM total variance across live expiries. Total variance must not decrease +// with expiry (calendar no-arb); violating points render destructive. + +const expiryFormatter = new Intl.DateTimeFormat("en-US", { + day: "numeric", + hour: "2-digit", + minute: "2-digit", + month: "short", +}) + +function TermTooltip({ + active, + payload, +}: { + active?: boolean + payload?: { payload: TermPoint }[] +}) { + const datum = payload?.[0]?.payload + if (!active || !datum) { + return null + } + + return ( +
+
+ {expiryFormatter.format(new Date(datum.expiryMs))} +
+
+ w(ATM) {datum.atmVariance.toExponential(2)} +
+ {!datum.calendarOk ? ( +
calendar violation
+ ) : null} +
+ ) +} + +export function TermChart({ points }: { points: TermPoint[] }) { + return ( +
+ + + + expiryFormatter.format(new Date(value)) + } + tickLine={false} + /> + value.toExponential(1)} + tickLine={false} + width={48} + /> + } + cursor={{ stroke: "var(--border)" }} + /> + + {points + .filter((point) => !point.calendarOk) + .map((point) => ( + + ))} + + +
+ ) +} diff --git a/web/src/components/market-detail/vol-panel/vol-panel.tsx b/web/src/components/market-detail/vol-panel/vol-panel.tsx new file mode 100644 index 0000000..374b7c0 --- /dev/null +++ b/web/src/components/market-detail/vol-panel/vol-panel.tsx @@ -0,0 +1,209 @@ +import { useEffect, useState } from "react" + +import { Badge, BadgeTone } from "@/components/primitives/badge" +import { Segmented } from "@/components/primitives/segmented" +import { getOracleState } from "@/services/predict-client" +import { + fetchSmileMids, + smileStrikeLadder, +} from "@/lib/market-detail/vol-quotes" +import { + buildSmile, + buildTermStructure, + fairCurve, + stressMids, +} from "@/lib/market-detail/vol-surface" +import type { TermPoint } from "@/lib/market-detail/vol-surface" +import type { ExpiryOption, MarketSnapshot } from "@/lib/types/market" + +import { SmileChart } from "./smile-chart" +import { TermChart } from "./term-chart" +import { VolExplainer } from "./explainer" + +// The volatility panel: live smile (our fair curve vs the pool's quotes, with +// the mispricing shaded), arbitrage-consistency checks, an ATM term structure +// across expiries, and a clearly-labeled Stress preview of a broken surface. + +const MIDS_REFRESH_MS = 5_000 + +type VolTab = "smile" | "term" +type VolMode = "live" | "stress" + +export interface VolViewProps { + expiryOptions: ExpiryOption[] + market: MarketSnapshot + onSelectStrike: (strikeUsd: number) => void + selectedStrikeUsd: number +} + +export function VolView(props: VolViewProps) { + const [isClient, setIsClient] = useState(false) + + useEffect(() => { + setIsClient(true) + }, []) + + if (!isClient) { + return
+ } + + return +} + +function VolViewClient({ + expiryOptions, + market, + onSelectStrike, + selectedStrikeUsd, +}: VolViewProps) { + const [view, setView] = useState("smile") + const [mode, setMode] = useState("live") + const [mids, setMids] = useState>() + const [termPoints, setTermPoints] = useState([]) + + const spotUsd = market.forwardPriceUsd || market.currentPriceUsd + const strikes = smileStrikeLadder(market) + + // Live pool mids on a slow poll; the fair curve is pure math off the + // market's SVI params and needs no fetching. + useEffect(() => { + let isStale = false + + async function load() { + try { + const next = await fetchSmileMids(market, smileStrikeLadder(market)) + if (!isStale) { + setMids(next) + } + } catch { + // Keep the previous surface on transient RPC failures. + } + } + + void load() + const intervalId = window.setInterval(() => void load(), MIDS_REFRESH_MS) + + return () => { + isStale = true + window.clearInterval(intervalId) + } + }, [market]) + + // Term structure: one SVI read per live expiry, refreshed with the market. + useEffect(() => { + let isStale = false + + async function load() { + const candidates = expiryOptions.filter( + (option) => option.status === "active" && option.expiryMs > Date.now() + ) + const entries = await Promise.all( + candidates.map(async (option) => { + try { + const state = await getOracleState(option.oracleId) + return state.latest_svi + ? { + expiryMs: option.expiryMs, + oracleId: option.oracleId, + svi: state.latest_svi, + } + : null + } catch { + return null + } + }) + ) + + if (!isStale) { + setTermPoints( + buildTermStructure(entries.filter((entry) => entry !== null)) + ) + } + } + + void load() + + return () => { + isStale = true + } + }, [expiryOptions]) + + const displayMids = + mids === undefined + ? undefined + : mode === "stress" + ? stressMids(mids, spotUsd) + : mids + const smile = + displayMids === undefined + ? undefined + : buildSmile( + strikes, + fairCurve(market.forwardPriceUsd, market.latestSvi), + displayMids + ) + const violationCount = + (smile?.violationStrikes.length ?? 0) + + termPoints.filter((point) => !point.calendarOk).length + const canShowTerm = termPoints.length >= 2 + + return ( +
+
+
+ {mode === "stress" ? ( + Simulated stress + ) : violationCount > 0 ? ( + + {violationCount} no-arb flag{violationCount === 1 ? "" : "s"} + + ) : smile ? ( + No-arb clean + ) : null} +
+
+ {canShowTerm ? ( + + ) : null} + +
+
+ + {view === "term" && canShowTerm ? ( + + ) : smile === undefined ? ( +
+ Quoting the pool… +
+ ) : smile.points.every((point) => point.mid === null) ? ( +
+ No quotable strikes near spot right now. +
+ ) : ( + + )} + + +
+ ) +} diff --git a/web/src/lib/market-detail/vol-quotes.ts b/web/src/lib/market-detail/vol-quotes.ts new file mode 100644 index 0000000..53e55a5 --- /dev/null +++ b/web/src/lib/market-detail/vol-quotes.ts @@ -0,0 +1,157 @@ +import { bcs } from "@mysten/sui/bcs" +import { Transaction } from "@mysten/sui/transactions" + +import { + PREDICT_CLOCK_ID, + PREDICT_OBJECT_ID, + PREDICT_PACKAGE_ID, +} from "@/lib/config" +import { toOnchainPrice } from "@/services/predict-transactions" +import { getSuiGrpcClient } from "@/services/sui-client" +import type { MarketSnapshot } from "@/lib/types/market" +import { normalizeStrikePrice } from "./helpers" + +// Chain-authoritative UP mids across a strike ladder, in one devInspect per +// batch. get_trade_amounts ABORTS on saturated strikes and one abort fails the +// whole simulation, so failed batches bisect down to singles and unmintable +// strikes are simply omitted. + +const PROBE_QUANTITY = 1_000_000n // one $1 contract +const MAX_STRIKES_PER_SIMULATION = 24 +// Any syntactically valid address works: simulation runs with checks disabled. +const PROBE_SENDER = + "0x0000000000000000000000000000000000000000000000000000000000000001" + +interface CommandOutput { + bcs: Uint8Array +} + +interface CommandResult { + returnValues?: CommandOutput[] +} + +function readU64(output: CommandOutput | undefined): bigint | undefined { + if (!output) { + return undefined + } + + return BigInt(bcs.U64.parse(output.bcs)) +} + +function buildBatchTransaction( + market: MarketSnapshot, + strikesUsd: number[] +): Transaction { + const tx = new Transaction() + tx.setSender(PROBE_SENDER) + + for (const strikeUsd of strikesUsd) { + const key = tx.moveCall({ + arguments: [ + tx.pure.id(market.oracleId), + tx.pure.u64(BigInt(market.expiryMs)), + tx.pure.u64(toOnchainPrice(strikeUsd)), + tx.pure.bool(true), + ], + target: `${PREDICT_PACKAGE_ID}::market_key::new`, + }) + tx.moveCall({ + arguments: [ + tx.object(PREDICT_OBJECT_ID), + tx.object(market.oracleId), + key, + tx.pure.u64(PROBE_QUANTITY), + tx.object(PREDICT_CLOCK_ID), + ], + target: `${PREDICT_PACKAGE_ID}::predict::get_trade_amounts`, + }) + } + + return tx +} + +async function quoteBatch( + market: MarketSnapshot, + strikesUsd: number[], + into: Map +): Promise { + if (strikesUsd.length === 0) { + return + } + + const result = await getSuiGrpcClient().simulateTransaction({ + checksEnabled: false, + include: { commandResults: true }, + transaction: buildBatchTransaction(market, strikesUsd), + }) + + if (result.$kind === "Transaction") { + // commandResults sits at the TOP LEVEL of the simulate result. + const commandResults = + (result as { commandResults?: CommandResult[] }).commandResults ?? [] + + strikesUsd.forEach((strikeUsd, index) => { + const output = commandResults[2 * index + 1]?.returnValues + const mintCost = readU64(output?.[0]) + const redeemPayout = readU64(output?.[1]) + + if (mintCost === undefined || redeemPayout === undefined) { + return + } + + into.set( + strikeUsd, + Number(mintCost + redeemPayout) / (2 * Number(PROBE_QUANTITY)) + ) + }) + return + } + + if (strikesUsd.length === 1) { + return // saturated / unmintable strike: omit + } + + const midpoint = strikesUsd.length >> 1 + await quoteBatch(market, strikesUsd.slice(0, midpoint), into) + await quoteBatch(market, strikesUsd.slice(midpoint), into) +} + +// / Evenly-spaced on-grid strike ladder around the forward, clamped to the +// / oracle's grid. +export function smileStrikeLadder( + market: MarketSnapshot, + bandFraction = 0.025, + count = 21 +): number[] { + const center = market.forwardPriceUsd || market.currentPriceUsd + if (center <= 0) { + return [] + } + + const strikes = new Set() + for (let index = 0; index < count; index += 1) { + const offset = (index / (count - 1)) * 2 - 1 // -1..1 + const raw = center * (1 + offset * bandFraction) + strikes.add(normalizeStrikePrice(raw, market)) + } + + return [...strikes].sort((a, b) => a - b) +} + +// / Pool mids for the ladder; unmintable strikes are omitted from the map. +export async function fetchSmileMids( + market: MarketSnapshot, + strikesUsd: number[] +): Promise> { + const mids = new Map() + + for (let i = 0; i < strikesUsd.length; i += MAX_STRIKES_PER_SIMULATION) { + await quoteBatch( + market, + strikesUsd.slice(i, i + MAX_STRIKES_PER_SIMULATION), + mids + ) + } + + return mids +} diff --git a/web/src/lib/market-detail/vol-surface.test.ts b/web/src/lib/market-detail/vol-surface.test.ts new file mode 100644 index 0000000..1187a94 --- /dev/null +++ b/web/src/lib/market-detail/vol-surface.test.ts @@ -0,0 +1,113 @@ +import { describe, expect, it } from "vitest" + +import { + atmTotalVariance, + buildSmile, + buildTermStructure, + stressMids, +} from "./vol-surface" +import type { OracleSviUpdate } from "@/lib/types/predict" + +function svi(overrides: Partial = {}): OracleSviUpdate { + return { + a: 400_000, + b: 800_000, + checkpoint: 0, + checkpoint_timestamp_ms: 0, + digest: "test", + event_digest: "test", + event_index: 0, + m: 0, + m_negative: false, + onchain_timestamp: 0, + oracle_id: "0xtest", + package: "0xtest", + rho: 300_000_000, + rho_negative: true, + sender: "0xtest", + sigma: 50_000_000, + tx_index: 0, + ...overrides, + } +} + +describe("buildSmile", () => { + it("computes edges and flags butterfly violations", () => { + const mids = new Map([ + [100, 0.8], + [101, 0.6], + [102, 0.65], // increases with strike: violation + [103, 0.3], + ]) + const smile = buildSmile( + [100, 101, 102, 103], + (strike) => (strike === 103 ? undefined : 0.7), + mids + ) + + expect(smile.points[0]?.edge).toBeCloseTo(0.1, 12) + expect(smile.points[1]?.edge).toBeCloseTo(-0.1, 12) + expect(smile.points[3]?.fair).toBeNull() + expect(smile.points[3]?.edge).toBeNull() + expect(smile.violationStrikes).toEqual([102]) + expect(smile.maxViolation).toBeCloseTo(0.05, 12) + }) + + it("clean monotone mids report no violations", () => { + const mids = new Map([ + [100, 0.8], + [101, 0.5], + [102, 0.2], + ]) + const smile = buildSmile([100, 101, 102], () => 0.5, mids) + + expect(smile.violationStrikes).toEqual([]) + }) +}) + +describe("stressMids", () => { + it("introduces a violation the detector catches, within [0.01, 0.99]", () => { + const strikes = [98, 99, 100, 101, 102] + const mids = new Map( + strikes.map((strike, index) => [strike, 0.9 - index * 0.2]) + ) + const stressed = stressMids(mids, 100) + const smile = buildSmile(strikes, () => undefined, stressed) + + expect(smile.violationStrikes.length).toBeGreaterThan(0) + for (const value of stressed.values()) { + expect(value).toBeGreaterThanOrEqual(0.01) + expect(value).toBeLessThanOrEqual(0.99) + } + }) + + it("leaves tiny surfaces untouched", () => { + const mids = new Map([[100, 0.5]]) + expect(stressMids(mids, 100)).toBe(mids) + }) +}) + +describe("atmTotalVariance", () => { + it("computes w(0) from scaled params", () => { + // a=0.0004, b=0.0008, rho=-0.3, m=0, sigma=0.05: + // w(0) = 0.0004 + 0.0008 * (0 + 0.05) = 0.00044 + expect(atmTotalVariance(svi())).toBeCloseTo(0.00044, 10) + }) + + it("rejects non-positive variance", () => { + expect(atmTotalVariance(svi({ a: 0, b: 0 }))).toBeNull() + }) +}) + +describe("buildTermStructure", () => { + it("sorts by expiry and flags calendar violations", () => { + const term = buildTermStructure([ + { expiryMs: 2_000, oracleId: "0xb", svi: svi({ a: 200_000 }) }, // smaller w than the earlier expiry + { expiryMs: 1_000, oracleId: "0xa", svi: svi({ a: 400_000 }) }, + ]) + + expect(term.map((point) => point.oracleId)).toEqual(["0xa", "0xb"]) + expect(term[0]?.calendarOk).toBe(true) + expect(term[1]?.calendarOk).toBe(false) // variance decreased with expiry + }) +}) diff --git a/web/src/lib/market-detail/vol-surface.ts b/web/src/lib/market-detail/vol-surface.ts new file mode 100644 index 0000000..43edb51 --- /dev/null +++ b/web/src/lib/market-detail/vol-surface.ts @@ -0,0 +1,156 @@ +import { computeFairUpProbability } from "@/lib/market-svi" +import type { OracleSviUpdate } from "@/lib/types/predict" + +// Pure math behind the vol panel: smile points (fair vs pool), butterfly +// monotonicity checks, the labeled stress perturbation, and the ATM term +// structure with its calendar check. All strikes/prices in USD floats (the +// client-side convention); probabilities in [0, 1]. + +export interface SmilePoint { + strike: number + // / Our model's fair UP probability (validated against on-chain pricing). + fair: number | null + // / The pool's executable mid for the same strike, when quotable. + mid: number | null + // / mid - fair (positive = pool prices above fair). Null without both. + edge: number | null +} + +export interface SmileSurface { + points: SmilePoint[] + // / Strikes where the pool mid INCREASES with strike (butterfly violation). + violationStrikes: number[] + maxViolation: number +} + +export function buildSmile( + strikes: number[], + fairBy: (strike: number) => number | undefined, + midByStrike: Map +): SmileSurface { + const points: SmilePoint[] = strikes.map((strike) => { + const fair = fairBy(strike) ?? null + const mid = midByStrike.get(strike) ?? null + + return { + edge: fair !== null && mid !== null ? mid - fair : null, + fair, + mid, + strike, + } + }) + + const violationStrikes: number[] = [] + let maxViolation = 0 + let previous: { mid: number; strike: number } | null = null + for (const point of points) { + if (point.mid === null) { + continue + } + if (previous && point.mid > previous.mid) { + violationStrikes.push(point.strike) + maxViolation = Math.max(maxViolation, point.mid - previous.mid) + } + previous = { mid: point.mid, strike: point.strike } + } + + return { maxViolation, points, violationStrikes } +} + +// / Deterministic stress for the demo toggle: a localized bump in the pool mids +// / near the money, guaranteed to break UP-price monotonicity so the butterfly +// / detector fires. Clearly labeled as simulated wherever rendered. +export function stressMids( + midByStrike: Map, + spot: number +): Map { + const strikes = [...midByStrike.keys()].sort((a, b) => a - b) + if (strikes.length < 3) { + return midByStrike + } + + const center = strikes.reduce( + (best, strike) => + Math.abs(strike - spot) < Math.abs(best - spot) ? strike : best, + strikes[0] + ) + const width = Math.max(spot * 0.004, 1) + const stressed = new Map() + + for (const strike of strikes) { + const mid = midByStrike.get(strike)! + const distance = (strike - center) / width + const bump = 0.08 * Math.exp(-0.5 * distance * distance) + stressed.set(strike, Math.min(0.99, Math.max(0.01, mid + bump))) + } + + // Guarantee the arb is visible whatever the local slope: lift the strike + // right after the center strictly above its predecessor. + const centerIndex = strikes.indexOf(center) + if (centerIndex + 1 < strikes.length) { + const next = strikes[centerIndex + 1] + const previous = stressed.get(center)! + stressed.set( + next, + Math.min(0.99, Math.max(stressed.get(next)!, previous + 0.02)) + ) + } + + return stressed +} + +export interface TermPoint { + expiryMs: number + oracleId: string + // / SVI total variance at the money (k = 0). + atmVariance: number + // / Non-decreasing total variance in expiry; false marks the violation. + calendarOk: boolean +} + +// / ATM total variance from raw SVI params: w(0) = a + b(ρ(0−m) + √(m² + σ²)). +export function atmTotalVariance(svi: OracleSviUpdate): number | null { + const scale = 1_000_000_000 + const a = svi.a / scale + const b = svi.b / scale + const rho = (svi.rho_negative ? -1 : 1) * (svi.rho / scale) + const m = (svi.m_negative ? -1 : 1) * (svi.m / scale) + const sigma = svi.sigma / scale + const variance = a + b * (rho * -m + Math.sqrt(m * m + sigma * sigma)) + + return Number.isFinite(variance) && variance > 0 ? variance : null +} + +export function buildTermStructure( + entries: { expiryMs: number; oracleId: string; svi: OracleSviUpdate }[] +): TermPoint[] { + const points = entries + .map((entry) => ({ + atmVariance: atmTotalVariance(entry.svi), + expiryMs: entry.expiryMs, + oracleId: entry.oracleId, + })) + .filter( + ( + point + ): point is Omit & { atmVariance: number } => + point.atmVariance !== null + ) + .sort((a, b) => a.expiryMs - b.expiryMs) + + return points.map((point, index) => ({ + ...point, + // Calendar no-arb: total variance must not DECREASE with expiry. + calendarOk: + index === 0 || point.atmVariance >= points[index - 1].atmVariance, + })) +} + +// / The smile's fair curve for a market, built from its live SVI params. +export function fairCurve( + forwardUsd: number, + svi: OracleSviUpdate | null +): (strike: number) => number | undefined { + return (strike: number) => + computeFairUpProbability({ forward: forwardUsd, strike, svi }) +} From c886e294d02b67e52af7c6d80afad10b080d9ae0 Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 14:15:11 +0100 Subject: [PATCH 11/33] feat(arena): tick live countdowns, reveal settlement verdicts, and show real win-loss records --- services/backend/src/domains/leaderboard.ts | 13 ++ web/src/components/arena/atoms.tsx | 173 +++++++++++++++++- web/src/components/arena/call-detail-page.tsx | 33 +++- .../components/arena/creator-detail-page.tsx | 28 ++- web/src/components/arena/page.tsx | 26 +-- web/src/components/shared/route-error.tsx | 8 +- web/src/lib/arena/types.ts | 6 + 7 files changed, 254 insertions(+), 33 deletions(-) diff --git a/services/backend/src/domains/leaderboard.ts b/services/backend/src/domains/leaderboard.ts index 6b4173d..c6de260 100644 --- a/services/backend/src/domains/leaderboard.ts +++ b/services/backend/src/domains/leaderboard.ts @@ -24,6 +24,11 @@ export interface ArenaCallModel { creatorAvatarSeed: string creatorHandle: string creatorName: string + // Creator reputation, derived at read time from oracle-settled calls. The + // raw counts ride along so the web can tell "0% (no settles yet)" apart from + // a genuinely losing record. + creatorSettledCount: number + creatorWinCount: number creatorWinRate: number direction: ArenaDirection expiryMs: number @@ -33,6 +38,9 @@ export interface ArenaCallModel { market: string oracleId: string predictId: string + // Oracle settlement price in display USD, present once the call has settled. + // Lets the web show the outcome ("settled at X, above/below the strike"). + settlementPriceUsd?: number status: ArenaCallStatus strikeUsd: number winState?: "won" | "lost" @@ -221,6 +229,8 @@ export function toCallModel( creatorAvatarSeed: identity.avatarUrl ?? row.creator, creatorHandle: handle, creatorName: name, + creatorSettledCount: creatorStats.settledCount, + creatorWinCount: creatorStats.winCount, creatorWinRate: winRate(creatorStats.settledCount, creatorStats.winCount), direction: row.isUp ? "up" : "down", expiryMs: Number(BigInt(row.expiry)), @@ -237,6 +247,9 @@ export function toCallModel( if (won !== null) { model.winState = won ? "won" : "lost" } + if (oracleSettledForCall(row, oracle) && oracle.settlementPrice !== undefined) { + model.settlementPriceUsd = scalePrice(oracle.settlementPrice) + } return model } diff --git a/web/src/components/arena/atoms.tsx b/web/src/components/arena/atoms.tsx index 3d4cb87..6a2388e 100644 --- a/web/src/components/arena/atoms.tsx +++ b/web/src/components/arena/atoms.tsx @@ -2,7 +2,8 @@ import { Avatar as DicebearAvatar, Style } from "@dicebear/core" import glyphs from "@dicebear/styles/glyphs.json" import { formatDistanceToNowStrict } from "date-fns" import { ArrowDownIcon, ArrowUpIcon } from "lucide-react" -import { useMemo } from "react" +import { useEffect, useMemo, useState } from "react" +import type { ReactNode } from "react" import { Badge, BadgeTone } from "@/components/primitives/badge" import type { @@ -13,6 +14,7 @@ import type { ArenaDirection, } from "@/lib/arena/types" import { SUI_NETWORK } from "@/lib/config" +import { formatUsd } from "@/lib/format" import { cn } from "@/lib/utils" const compactNumberFormatter = new Intl.NumberFormat("en-US", { @@ -71,6 +73,167 @@ export function getCallChance(call: ArenaCall) { : 1 - call.fairUpProbability } +// USD with sensible precision for both BTC-scale and SUI-scale prices. +export function formatArenaUsd(value: number) { + return formatUsd(value, value < 10 ? 4 : 0) +} + +// Creator reputation inline with the handle. Raw counts (when the backend +// sends them) distinguish a new caller from a losing one; a bare win rate +// can't, so it stays the fallback for older payloads. +export function CreatorRep({ + settledCount, + winCount, + winRate, +}: { + settledCount?: number + winCount?: number + winRate: number +}) { + if (settledCount === undefined || winCount === undefined) { + return ( + + + {percentFormatter.format(winRate)} + {" "} + win + + ) + } + + if (settledCount === 0) { + return ( + + no settled calls yet + + ) + } + + return ( + + {winCount}W + · + + {settledCount - winCount}L + + + ) +} + +const URGENT_REMAINING_MS = 10 * 60 * 1_000 + +// Formats what remains until expiry: coarse when far out, mm:ss inside the +// last 10 minutes (the window a demo actually watches). +function formatRemaining(remainingMs: number) { + if (remainingMs < URGENT_REMAINING_MS) { + const totalSeconds = Math.max(0, Math.floor(remainingMs / 1_000)) + const minutes = Math.floor(totalSeconds / 60) + const seconds = totalSeconds % 60 + + return `${minutes}:${seconds.toString().padStart(2, "0")}` + } + + return formatDistanceToNowStrict(Date.now() + remainingMs) +} + +// Live time-to-expiry, ticking once a second after hydration. Before the +// clock mounts it renders the same static distance the server rendered, so +// SSR markup matches. Turns warning-toned inside the last 10 minutes and +// reads "Settling" once the expiry passes but the oracle hasn't settled. +export function CallCountdown({ + expiryMs, + withSuffix = true, +}: { + expiryMs: number + withSuffix?: boolean +}) { + const [nowMs, setNowMs] = useState() + + useEffect(() => { + setNowMs(Date.now()) + const intervalId = window.setInterval(() => setNowMs(Date.now()), 1_000) + + return () => window.clearInterval(intervalId) + }, []) + + const suffix = withSuffix ? " left" : "" + + if (nowMs === undefined) { + return ( + + {formatDistanceToNowStrict(expiryMs)} + {suffix} + + ) + } + + const remainingMs = expiryMs - nowMs + + if (remainingMs <= 0) { + return Settling + } + + return ( + + {formatRemaining(remainingMs)} + {suffix} + + ) +} + +// The settlement reveal: the call's outcome stated plainly, with the oracle +// print against the strike when the backend has it. +export function VerdictBanner({ call }: { call: ArenaCall }) { + if (!call.winState) { + return null + } + + const won = call.winState === "won" + + return ( +
+
+ {won ? "Called it" : "Missed"} +
+

+ {call.settlementPriceUsd !== undefined ? ( + <> + Settled at{" "} + + {formatArenaUsd(call.settlementPriceUsd)} + + , {call.settlementPriceUsd > call.strikeUsd ? "above" : "at or below"}{" "} + the{" "} + + {formatArenaUsd(call.strikeUsd)} + {" "} + strike. + + ) : won ? ( + "The oracle settled on the creator's side." + ) : ( + "The oracle settled against the creator's side." + )} +

+
+ ) +} + export function oppositeMarket(market: string) { if (market.includes(" above ")) { return market.replace(" above ", " below ") @@ -255,7 +418,13 @@ const activityKindLabel: Record = { reclaimed: "reclaimed bond", } -export function DetailStat({ label, value }: { label: string; value: string }) { +export function DetailStat({ + label, + value, +}: { + label: string + value: ReactNode +}) { return (
{label}
diff --git a/web/src/components/arena/call-detail-page.tsx b/web/src/components/arena/call-detail-page.tsx index c8040ce..10c4679 100644 --- a/web/src/components/arena/call-detail-page.tsx +++ b/web/src/components/arena/call-detail-page.tsx @@ -1,5 +1,4 @@ import { Link } from "@tanstack/react-router" -import { formatDistanceToNowStrict } from "date-fns" import { ArrowLeftIcon, ArrowUpRightIcon } from "lucide-react" import type { ArenaActivity, ArenaCall, ArenaCreator } from "@/lib/arena/types" @@ -9,11 +8,14 @@ import { CallActionDialog } from "./call-action-dialog" import { SettlementActions } from "./settlement-actions" import { ActivityRow, + CallCountdown, CallStatusBadge, CreatorAvatar, + CreatorRep, DetailStat, DirectionPill, SentimentBar, + VerdictBanner, formatCallTimestamp, formatMarketLabel, formatPlp, @@ -39,11 +41,22 @@ function CreatorTrackRecord({ creator }: { creator: ArenaCreator }) {
+ 0 + ? `${creator.winCount}W · ${creator.settledCount - creator.winCount}L` + : "—" + } + /> 0 + ? percentFormatter.format(getWinRate(creator)) + : "—" + } /> -
@@ -88,11 +101,13 @@ export function CallDetailPage({ {call.creatorHandle} + - - {percentFormatter.format(call.creatorWinRate)} - {" "} - win · {formatCallTimestamp(call.createdAt)} + {formatCallTimestamp(call.createdAt)}
@@ -105,6 +120,8 @@ export function CallDetailPage({
+ +
{showChance ? (
@@ -120,7 +137,7 @@ export function CallDetailPage({ {isActive ? ( } /> ) : null}
diff --git a/web/src/components/arena/creator-detail-page.tsx b/web/src/components/arena/creator-detail-page.tsx index 9e684bf..38bbaa2 100644 --- a/web/src/components/arena/creator-detail-page.tsx +++ b/web/src/components/arena/creator-detail-page.tsx @@ -46,12 +46,20 @@ export function CreatorDetailPage({
0 + ? `${creator.winCount}W · ${creator.settledCount - creator.winCount}L` + : "—" + } /> 0 + ? percentFormatter.format(getWinRate(creator)) + : "—" + } /> @@ -85,10 +93,14 @@ export function CreatorDetailPage({ {formatMarketLabel(call.market)}
- - {percentFormatter.format(getCallChance(call))} - {" "} - chance ·{" "} + {call.status === "active" && call.fairUpProbability > 0 ? ( + <> + + {percentFormatter.format(getCallChance(call))} + {" "} + chance ·{" "} + + ) : null} {formatPlp(call.bondPlp)} {" "} diff --git a/web/src/components/arena/page.tsx b/web/src/components/arena/page.tsx index 38bfd91..92eb046 100644 --- a/web/src/components/arena/page.tsx +++ b/web/src/components/arena/page.tsx @@ -1,5 +1,4 @@ import { Link } from "@tanstack/react-router" -import { formatDistanceToNowStrict } from "date-fns" import { ArrowRightIcon } from "lucide-react" import type { @@ -11,8 +10,10 @@ import { cn } from "@/lib/utils" import { ActivityRow, + CallCountdown, CallStatusBadge, CreatorAvatar, + CreatorRep, DirectionPill, SentimentBar, formatCallTimestamp, @@ -105,12 +106,11 @@ function CallCard({ call }: { call: ArenaCall }) { {call.creatorHandle} - - - {percentFormatter.format(call.creatorWinRate)} - {" "} - win - +
@@ -121,10 +121,14 @@ function CallCard({ call }: { call: ArenaCall }) {

{formatMarketLabel(call.market)}

-

- {isActive - ? `${formatDistanceToNowStrict(call.expiryMs)} left` - : formatCallTimestamp(call.createdAt)} +

+ {isActive ? ( + + ) : ( + + {formatCallTimestamp(call.createdAt)} + + )}

diff --git a/web/src/components/shared/route-error.tsx b/web/src/components/shared/route-error.tsx index 6db0645..a9eef7f 100644 --- a/web/src/components/shared/route-error.tsx +++ b/web/src/components/shared/route-error.tsx @@ -12,9 +12,9 @@ function isPredictOutage(error: Error): boolean { return error.message.includes("Predict server request failed") } -/// Friendly, retry-able error state for routes whose loaders depend on the -/// Predict server. Distinguishes a transient upstream outage from a real bug so -/// users see a calm "try again" card rather than a raw internal 500 string. +// Friendly, retry-able error state for routes whose loaders depend on the +// Predict server. Distinguishes a transient upstream outage from a real bug so +// users see a calm "try again" card rather than a raw internal 500 string. export function RouteError({ error }: { error: Error }) { const router = useRouter() const outage = isPredictOutage(error) @@ -29,7 +29,7 @@ export function RouteError({ error }: { error: Error }) {

{outage - ? "The DeepBook Predict service isn't responding right now. This is usually brief — try again in a moment." + ? "The DeepBook Predict service isn't responding right now. This is usually brief. Try again in a moment." : error.message || "An unexpected error occurred."}

diff --git a/web/src/lib/arena/types.ts b/web/src/lib/arena/types.ts index 8d6b62d..cacebde 100644 --- a/web/src/lib/arena/types.ts +++ b/web/src/lib/arena/types.ts @@ -15,6 +15,10 @@ export interface ArenaCall { creatorAvatarSeed: string creatorHandle: string creatorName: string + // Raw reputation counts (optional: an older backend omits them). They let + // the UI tell "no settles yet" apart from a genuinely losing record. + creatorSettledCount?: number + creatorWinCount?: number creatorWinRate: number direction: ArenaDirection expiryMs: number @@ -22,6 +26,8 @@ export interface ArenaCall { fairUpProbability: number id: string market: string + // Oracle settlement price in USD, present once the call has settled. + settlementPriceUsd?: number status: ArenaCallStatus strikeUsd: number winState?: "won" | "lost" From 7e6daaee36fecba3fc0e61a859cecaa2bc4954fe Mon Sep 17 00:00:00 2001 From: draco <136370233+0xDraco@users.noreply.github.com> Date: Sat, 11 Jul 2026 15:06:52 +0100 Subject: [PATCH 12/33] feat(arena): trade calls from an inline ticket and watch them fight live --- web/src/components/arena/atoms.tsx | 62 ++- .../components/arena/call-action-dialog.tsx | 347 +--------------- web/src/components/arena/call-detail-page.tsx | 187 +++++---- web/src/components/arena/call-ticket.tsx | 390 ++++++++++++++++++ .../components/arena/creator-detail-page.tsx | 3 +- web/src/components/arena/live-status.tsx | 109 +++++ web/src/components/arena/page.tsx | 255 +++++++++++- web/src/components/arena/share-call.tsx | 43 ++ web/src/lib/arena/use-live-spot.ts | 90 ++++ 9 files changed, 1056 insertions(+), 430 deletions(-) create mode 100644 web/src/components/arena/call-ticket.tsx create mode 100644 web/src/components/arena/live-status.tsx create mode 100644 web/src/components/arena/share-call.tsx create mode 100644 web/src/lib/arena/use-live-spot.ts diff --git a/web/src/components/arena/atoms.tsx b/web/src/components/arena/atoms.tsx index 6a2388e..81cad59 100644 --- a/web/src/components/arena/atoms.tsx +++ b/web/src/components/arena/atoms.tsx @@ -121,6 +121,22 @@ export function CreatorRep({ } const URGENT_REMAINING_MS = 10 * 60 * 1_000 +const FINAL_MINUTE_MS = 60 * 1_000 + +// Client-side clock ticking once a second; undefined until hydration so SSR +// markup never depends on the render-time clock. +function useNowMs() { + const [nowMs, setNowMs] = useState() + + useEffect(() => { + setNowMs(Date.now()) + const intervalId = window.setInterval(() => setNowMs(Date.now()), 1_000) + + return () => window.clearInterval(intervalId) + }, []) + + return nowMs +} // Formats what remains until expiry: coarse when far out, mm:ss inside the // last 10 minutes (the window a demo actually watches). @@ -147,14 +163,7 @@ export function CallCountdown({ expiryMs: number withSuffix?: boolean }) { - const [nowMs, setNowMs] = useState() - - useEffect(() => { - setNowMs(Date.now()) - const intervalId = window.setInterval(() => setNowMs(Date.now()), 1_000) - - return () => window.clearInterval(intervalId) - }, []) + const nowMs = useNowMs() const suffix = withSuffix ? " left" : "" @@ -186,8 +195,38 @@ export function CallCountdown({ ) } +// Thin draining bar across the top edge of a call surface during the final +// minute before expiry. The parent needs relative positioning (and +// overflow-hidden if rounded). Renders nothing outside that window. +export function FinalMinuteBar({ expiryMs }: { expiryMs: number }) { + const nowMs = useNowMs() + + if (nowMs === undefined) { + return null + } + + const remainingMs = expiryMs - nowMs + + if (remainingMs <= 0 || remainingMs > FINAL_MINUTE_MS) { + return null + } + + return ( +