From 4f48f21e6280189131f73441576ffdfa516e6243 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Fri, 17 Apr 2026 18:21:42 +0800 Subject: [PATCH 1/9] test: add trading fixtures, harness helpers, and delegate coverage Introduce JSON fixtures and load/regen tooling for trading scenarios. Add simulate tests for delegate lifecycle and permission matrix, plus unit tests for events, SDK inputs, and size formulas. Wire integration setup and existing simulate suites to shared helpers; extend market params and add WLP cancel/redeem probe script. Made-with: Cursor --- .e2e-fixed-positions.local.json | 13 +- scripts/market-params.ts | 10 +- scripts/test-cancel-redeem-wlp.ts | 435 ++++++++++++++++++ .../fixtures/delegates/permission-matrix.json | 18 + test/fixtures/trading/lifecycle-markets.json | 197 ++++++++ test/fixtures/trading/persistent-perp.json | 43 ++ test/fixtures/trading/scenarios.json | 12 + test/helpers/compute-leverage-size.ts | 28 ++ test/helpers/delegate-perms.ts | 20 + test/helpers/e2e-active-bases.ts | 34 ++ test/helpers/e2e-persistent-state.ts | 96 ++-- test/helpers/integration-reference-wallet.ts | 4 +- test/helpers/lifecycle-test-markets.ts | 111 +---- test/helpers/load-trading-fixtures.ts | 54 +++ test/helpers/move-event-payload.ts | 174 +++++++ test/helpers/place-cancel-probe.ts | 133 ++++++ test/helpers/trading-fixture-harness.ts | 27 ++ test/helpers/wlp-pool-price-refresh.ts | 66 +++ test/integration/setup.ts | 13 +- test/scripts/regen-trading-fixtures.ts | 12 + .../collateral-order-simulate.test.ts | 108 ++--- .../delegate-lifecycle-simulate.test.ts | 154 +++++++ ...elegate-permission-matrix-simulate.test.ts | 83 ++++ test/simulate/prd-product-coverage.test.ts | 69 +-- test/simulate/tx-builders-simulate.test.ts | 72 +-- test/simulate/wlp-simulate.test.ts | 28 +- test/unit/event-parsing.test.ts | 68 +++ test/unit/sdk-input-type-contracts.test.ts | 27 ++ test/unit/sdk-size-formula.test.ts | 33 ++ 29 files changed, 1856 insertions(+), 286 deletions(-) create mode 100644 scripts/test-cancel-redeem-wlp.ts create mode 100644 test/fixtures/delegates/permission-matrix.json create mode 100644 test/fixtures/trading/lifecycle-markets.json create mode 100644 test/fixtures/trading/persistent-perp.json create mode 100644 test/fixtures/trading/scenarios.json create mode 100644 test/helpers/delegate-perms.ts create mode 100644 test/helpers/e2e-active-bases.ts create mode 100644 test/helpers/load-trading-fixtures.ts create mode 100644 test/helpers/move-event-payload.ts create mode 100644 test/helpers/place-cancel-probe.ts create mode 100644 test/helpers/trading-fixture-harness.ts create mode 100644 test/helpers/wlp-pool-price-refresh.ts create mode 100644 test/scripts/regen-trading-fixtures.ts create mode 100644 test/simulate/delegate-lifecycle-simulate.test.ts create mode 100644 test/simulate/delegate-permission-matrix-simulate.test.ts create mode 100644 test/unit/event-parsing.test.ts create mode 100644 test/unit/sdk-input-type-contracts.test.ts create mode 100644 test/unit/sdk-size-formula.test.ts diff --git a/.e2e-fixed-positions.local.json b/.e2e-fixed-positions.local.json index 6c35c94..8ae16d1 100644 --- a/.e2e-fixed-positions.local.json +++ b/.e2e-fixed-positions.local.json @@ -1,13 +1,12 @@ { "version": 1, - "accountId": "0x7d5f459101cc8076215707ef49c09789514f31a4407c4836b874c8700e6ecaf6", + "accountId": "0xab4795318525c9a6113fcba320a785345f3a8b66c523ec1a517ac040d2cd945b", "positions": { - "BTC": 33, - "DEEP": 8, - "ETH": 11, - "SOL": 12, - "SUI": 7, - "WAL": 5 + "BTC": 6, + "ETH": 4, + "SOL": 2, + "SUI": 2, + "WAL": 2 }, "disclaimer": "Auto-generated from public on-chain position ids. Safe to commit. Re-run preflight/bootstrap after closes/liquidations." } diff --git a/scripts/market-params.ts b/scripts/market-params.ts index b720411..46f8967 100644 --- a/scripts/market-params.ts +++ b/scripts/market-params.ts @@ -3,9 +3,14 @@ * Passed to `trading::create_market` via admin setup scripts. * * Size is Float (1e9-scaled u128) internally; there is no `size_decimal` or `lot_size` in v2. - * `min_coll_value` is a 1e9-scaled USD floor (e.g. 10_000_000_000 = $10). + * `min_coll_value` is a 1e9-scaled USD floor (e.g. 90_000_000 = $0.09). * `max_long_oi` / `max_short_oi` are u128 scaled values converted to Float on-chain via * `float::from_scaled_val`. + * + * NOTE: `DEFAULT_MIN_COLL_VALUE` must match the value actually deployed on testnet — the + * integration suite `trader-market-onchain-config.test.ts` asserts equality against on-chain + * `Market.min_coll_value`. Bumping this in code without an admin update call on-chain will + * fail that test (and vice-versa). When updating here, also run the admin config update. */ import type { BaseAsset } from "../src/constants.ts"; @@ -25,7 +30,8 @@ export interface MarketParams { } const DEFAULT_OI_CAP = 100_000_000_000_000n; -const DEFAULT_MIN_COLL_VALUE = 10_000_000_000n; // $10 +/** Matches currently deployed testnet `Market.min_coll_value` (1e9-scaled → ~$0.09). */ +const DEFAULT_MIN_COLL_VALUE = 90_000_000n; function crypto(maxLeverageBps: number, overrides: Partial = {}): MarketParams { return { diff --git a/scripts/test-cancel-redeem-wlp.ts b/scripts/test-cancel-redeem-wlp.ts new file mode 100644 index 0000000..684b968 --- /dev/null +++ b/scripts/test-cancel-redeem-wlp.ts @@ -0,0 +1,435 @@ +/** + * 驗證 WLP redeem cancel 在當前 testnet 部署上能不能成功跑過。 + * + * 目前 package (`TESTNET_PACKAGE_IDS.WATERX_PERP`) 的 `cancel_redeem` 搭配 SDK + * `cancelRedeemWlp` 運作正常，三個情境都應 simulate 成功。若未來鏈上重新部署、 + * 或 Move ABI 改回需要呼叫端消耗 return `Coin`，這個腳本可以直接抓到 + * regression（會看到 `UnusedValueWithoutDrop` / `FailedTransaction`）。 + * + * 執行情境： + * A. 單獨 `buildCancelRedeemWlpTx`（需要 owner 有 pending redeem；找不到就 fallback + * requestId = nextRedeemId-1，只做 PTB 結構檢查） + * B. `buildRequestRedeemWlpTx` + `buildCancelRedeemWlpTx` 串在同一顆 PTB + * （照 `test/simulate/wlp-simulate.test.ts` 的套路） + * C. 對照組：手刻 PTB 改用 `cancel_redeem_and_transfer`（return type `()`）， + * 支援 `--execute` 用 integration trader 真的簽名送上鏈 + * + * 用法： + * pnpm tsx scripts/test-cancel-redeem-wlp.ts # 三情境 simulate，印摘要 + * pnpm tsx scripts/test-cancel-redeem-wlp.ts --full # 連 full result 一起印 + * pnpm tsx scripts/test-cancel-redeem-wlp.ts --only A,B # 只跑指定情境 + * pnpm tsx scripts/test-cancel-redeem-wlp.ts --execute # 情境 C 真的 signAndExecute 上鏈 + * pnpm tsx scripts/test-cancel-redeem-wlp.ts --owner 0x... # 覆寫 sender（simulate 模式用） + * pnpm tsx scripts/test-cancel-redeem-wlp.ts --request-id 42 # 情境 A 指定 requestId + * + * 若帶 --execute：需要 `.integration-trader.keystore` 或 `WATERX_INTEGRATION_PRIVATE_KEY` + * (同 `pnpm test:integration`)，執行時會燒 gas、動 wallet 上的一顆 WLP。 + */ +import { Transaction } from "@mysten/sui/transactions"; + +import { request as accountRequestCall } from "../src/generated/bucket_v2_framework/account.ts"; +import { cancelRedeemAndTransfer as cancelRedeemAndTransferCall } from "../src/generated/waterx_perp/lp_pool.ts"; +import { + buildCancelRedeemWlpTx, + buildRequestRedeemWlpTx, + getRedeemRequests, + WaterXClient, +} from "../src/index.ts"; +import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; +import { + execTx, + isIntegrationTraderConfigured, + loadIntegrationTraderKeypair, +} from "../test/integration/setup.ts"; + +type Scenario = "A" | "B" | "C"; + +interface Argv { + owner: string; + requestId?: bigint; + execute: boolean; + only: Scenario[]; + full: boolean; +} + +function parseArgs(argv: string[]): Argv { + const getFlag = (name: string): string | undefined => { + const idx = argv.findIndex((a) => a === name); + return idx >= 0 ? argv[idx + 1] : undefined; + }; + const ownerArg = getFlag("--owner"); + const rid = getFlag("--request-id"); + const onlyRaw = getFlag("--only"); + const only = onlyRaw + ? (onlyRaw.toUpperCase().split(/[,\s]+/).filter(Boolean) as Scenario[]) + : (["A", "B", "C"] as Scenario[]); + return { + owner: ownerArg ?? INTEGRATION_REFERENCE_WALLET_ADDRESS, + requestId: rid !== undefined ? BigInt(rid) : undefined, + execute: argv.includes("--execute"), + only, + full: argv.includes("--full"), + }; +} + +function stringify(value: unknown): string { + return JSON.stringify( + value, + (_key, v) => (typeof v === "bigint" ? v.toString() : v), + 2, + ); +} + +function normAddr(a: string): string { + return a.replace(/^0x/i, "").toLowerCase(); +} + +async function getNextRedeemId(client: WaterXClient): Promise { + const cfg = client.config; + const poolObj = await client.grpcClient.getObject({ + objectId: cfg.wlpPool, + include: { json: true }, + }); + const poolJson = poolObj.object?.json as Record | null | undefined; + if (!poolJson) return 0n; + const fields = + (poolJson.fields as Record | undefined) ?? + (poolJson as Record); + const raw = fields.next_redeem_id ?? fields.nextRedeemId; + if (raw === undefined || raw === null) return 0n; + try { + return BigInt(String(raw)); + } catch { + return 0n; + } +} + +async function findPendingRedeemFor( + client: WaterXClient, + owner: string, +): Promise<{ requestId: bigint; tokenType: string } | null> { + const normOwner = normAddr(owner); + let cursor = 0; + for (let page = 0; page < 20; page++) { + const { requests, nextCursor } = await getRedeemRequests(client, cursor, 50); + for (const r of requests) { + if (normAddr(r.recipient) === normOwner) { + return { requestId: r.requestId, tokenType: r.tokenType }; + } + } + if (nextCursor === undefined) break; + cursor = nextCursor; + } + return null; +} + +async function pickWlpCoin( + client: WaterXClient, + owner: string, +): Promise<{ objectId: string; balance: string } | null> { + const { objects } = await client.listCoins({ + owner, + coinType: client.config.wlpType, + }); + return objects[0] ?? null; +} + +interface SimulateSummary { + $kind: string | undefined; + success?: boolean; + error?: unknown; + commandCount?: number; + /** 每個 command 的 returnValues / mutatedReferences 數量（避免噴 BCS raw bytes） */ + commandShapes?: Array<{ returnValues: number; mutatedReferences: number }>; +} + +function summarizeSimulate(result: unknown): SimulateSummary { + const r = result as { + $kind?: string; + Transaction?: { status?: { success?: boolean; error?: unknown } }; + FailedTransaction?: { status?: { success?: boolean; error?: unknown } }; + commandResults?: Array<{ + returnValues?: unknown[]; + mutatedReferences?: unknown[]; + }>; + }; + const status = r.Transaction?.status ?? r.FailedTransaction?.status; + const commands = r.commandResults ?? []; + return { + $kind: r.$kind, + success: status?.success, + error: status?.error ?? undefined, + commandCount: commands.length, + commandShapes: commands.map((c) => ({ + returnValues: c.returnValues?.length ?? 0, + mutatedReferences: c.mutatedReferences?.length ?? 0, + })), + }; +} + +function dumpSimulate(result: unknown, { full = false } = {}): { + ok: boolean; + kind: string | undefined; +} { + const summary = summarizeSimulate(result); + console.log("\n--- simulate summary ---"); + console.log(stringify(summary)); + if (full) { + console.log("\n--- full simulate result ---"); + console.log(stringify(result)); + } + return { ok: summary.$kind === "Transaction", kind: summary.$kind }; +} + +type ScenarioStatus = "ok" | "fail" | "skipped"; + +interface ScenarioResult { + scenario: Scenario; + status: ScenarioStatus; + note?: string; +} + +async function scenarioA(client: WaterXClient, args: Argv): Promise { + console.log("\n=========================================="); + console.log("[情境 A] 單獨 buildCancelRedeemWlpTx — 預期 simulate 成功（當前 ABI）"); + console.log("=========================================="); + + let rid = args.requestId; + if (rid === undefined) { + const found = await findPendingRedeemFor(client, args.owner); + if (found) { + console.log(`找到 owner 的 pending redeem: requestId=${found.requestId}`); + rid = found.requestId; + } else { + const nextId = await getNextRedeemId(client); + rid = nextId > 0n ? nextId - 1n : 0n; + console.log( + `owner 名下沒 pending redeem → fallback requestId=${rid} (nextRedeemId-1)`, + ); + } + } + console.log("owner :", args.owner); + console.log("requestId :", rid.toString()); + + const tx = buildCancelRedeemWlpTx(client, { requestId: rid }); + tx.setSender(args.owner); + + const result = await client.simulate(tx); + const { ok } = dumpSimulate(result, { full: args.full }); + console.log(ok ? "\n✅ simulate 成功" : "\n❌ simulate 失敗"); + return { + scenario: "A", + status: ok ? "ok" : "fail", + note: `requestId=${rid.toString()}`, + }; +} + +async function scenarioB(client: WaterXClient, args: Argv): Promise { + console.log("\n=========================================="); + console.log("[情境 B] buildRequestRedeemWlpTx + buildCancelRedeemWlpTx — 預期 simulate 成功（當前 ABI）"); + console.log("=========================================="); + + const wlp = await pickWlpCoin(client, args.owner); + if (!wlp) { + console.log("⚠️ wallet 沒 WLP coin，無法跑情境 B（先 `pnpm e2e:prepare` 或 mint）。"); + return { scenario: "B", status: "skipped", note: "no WLP coin" }; + } + const nextRedeemId = await getNextRedeemId(client); + console.log("owner :", args.owner); + console.log("using lpCoin :", wlp.objectId, `(balance=${wlp.balance})`); + console.log("nextRedeemId :", nextRedeemId.toString()); + + const tx = await buildRequestRedeemWlpTx(client, { + lpCoin: wlp.objectId, + collateral: "USDC", + recipient: args.owner, + updatePythPrice: true, + }); + buildCancelRedeemWlpTx(client, { requestId: nextRedeemId, tx }); + tx.setSender(args.owner); + + const result = await client.simulate(tx); + const { ok } = dumpSimulate(result, { full: args.full }); + console.log(ok ? "\n✅ simulate 成功" : "\n❌ simulate 失敗"); + return { + scenario: "B", + status: ok ? "ok" : "fail", + note: `requestId=${nextRedeemId.toString()}`, + }; +} + +async function buildRequestPlusCancelAndTransferPtb( + client: WaterXClient, + params: { + lpCoin: string; + requestId: bigint; + recipient: string; + updatePythPrice: boolean; + }, +): Promise { + // 借用 SDK 的 buildRequestRedeemWlpTx：它會自動 refresh 所有 pool token 的 Pyth/Supra 價格， + // 並 append `lp_pool::request_redeem`。我們再自己補上 `cancel_redeem_and_transfer`。 + const tx = await buildRequestRedeemWlpTx(client, { + lpCoin: params.lpCoin, + collateral: "USDC", + recipient: params.recipient, + updatePythPrice: params.updatePythPrice, + }); + + const cfg = client.config; + const [senderRequest] = accountRequestCall({ + package: cfg.bucketFrameworkPackageId!, + })(tx); + + cancelRedeemAndTransferCall({ + package: cfg.packageId, + arguments: { + pool: cfg.wlpPool, + senderRequest: senderRequest!, + requestId: params.requestId, + }, + typeArguments: [cfg.wlpType], + })(tx); + + return tx; +} + +async function scenarioC(client: WaterXClient, args: Argv): Promise { + console.log("\n=========================================="); + console.log("[情境 C] 手刻 PTB: request_redeem + cancel_redeem_and_transfer — 預期成功"); + console.log("=========================================="); + + // 若要 --execute，owner 必須是 integration trader 本人 + let effectiveOwner = args.owner; + if (args.execute) { + if (!isIntegrationTraderConfigured()) { + console.log( + "⚠️ --execute 需要 .integration-trader.keystore 或 WATERX_INTEGRATION_PRIVATE_KEY。跳過。", + ); + return { scenario: "C", status: "skipped", note: "no integration keystore" }; + } + const kp = loadIntegrationTraderKeypair(); + const signerAddr = kp.getPublicKey().toSuiAddress(); + if (normAddr(signerAddr) !== normAddr(args.owner)) { + console.log( + `[情境 C] --owner ${args.owner} 跟 integration trader ${signerAddr} 不同，` + + "改用 trader 地址（執行需要 sender 就是 signer）。", + ); + effectiveOwner = signerAddr; + } + } + + const wlp = await pickWlpCoin(client, effectiveOwner); + if (!wlp) { + console.log(`⚠️ ${effectiveOwner} 沒 WLP coin，無法跑情境 C。先 mint 或跑 e2e:prepare。`); + return { scenario: "C", status: "skipped", note: "no WLP coin" }; + } + + const nextRedeemId = await getNextRedeemId(client); + console.log("owner :", effectiveOwner); + console.log("using lpCoin :", wlp.objectId, `(balance=${wlp.balance})`); + console.log("nextRedeemId :", nextRedeemId.toString(), "(cancel target)"); + + const simTx = await buildRequestPlusCancelAndTransferPtb(client, { + lpCoin: wlp.objectId, + requestId: nextRedeemId, + recipient: effectiveOwner, + updatePythPrice: true, + }); + simTx.setSender(effectiveOwner); + + console.log("\n[simulate]"); + const simResult = await client.simulate(simTx); + const { ok: simOk } = dumpSimulate(simResult, { full: args.full }); + if (!simOk) { + console.log("\n❌ Simulate 失敗。檢查上方 error 後再決定要不要 --execute。"); + return { scenario: "C", status: "fail", note: "simulate failed" }; + } + console.log("\n✅ Simulate 成功。"); + + if (!args.execute) { + console.log( + "\n（未加 --execute，不送上鏈。真的要驗證可以跑 `--execute`。）", + ); + return { scenario: "C", status: "ok", note: "simulate only" }; + } + + console.log("\n[signAndExecute] 用 integration trader 真的送上鏈…"); + const kp = loadIntegrationTraderKeypair(); + // 重新 build 一顆（避免 re-use 已 simulate 的 tx 物件時內部狀態出問題） + const execTxn = await buildRequestPlusCancelAndTransferPtb(client, { + lpCoin: wlp.objectId, + requestId: nextRedeemId, + recipient: effectiveOwner, + updatePythPrice: true, + }); + + try { + const result = await execTx(execTxn, kp); + console.log("\ndigest :", result.digest); + console.log("status :", result.effects?.status?.status); + if (result.effects?.status?.status !== "success") { + console.log("error :", result.effects?.status?.error); + } + console.log("\n--- full execute result ---"); + console.log(stringify(result)); + const execOk = result.effects?.status?.status === "success"; + return { + scenario: "C", + status: execOk ? "ok" : "fail", + note: `executed digest=${result.digest}`, + }; + } catch (e) { + const msg = e instanceof Error ? e.message : String(e); + console.log("\n❌ signAndExecute 失敗：", msg); + return { scenario: "C", status: "fail", note: `execute error: ${msg}` }; + } +} + +function statusIcon(status: ScenarioStatus): string { + if (status === "ok") return "✅"; + if (status === "fail") return "❌"; + return "⚠️ "; +} + +function printSummary(results: ScenarioResult[]): void { + console.log("\n=========================================="); + console.log("Summary"); + console.log("=========================================="); + for (const r of results) { + const note = r.note ? ` — ${r.note}` : ""; + console.log(` ${statusIcon(r.status)} [情境 ${r.scenario}] ${r.status}${note}`); + } + const failed = results.filter((r) => r.status === "fail").length; + const skipped = results.filter((r) => r.status === "skipped").length; + const ok = results.filter((r) => r.status === "ok").length; + console.log(`\n total: ${results.length} ok: ${ok} fail: ${failed} skipped: ${skipped}`); +} + +async function main() { + const args = parseArgs(process.argv.slice(2)); + const client = WaterXClient.testnet(); + + console.log("package :", client.config.packageId); + console.log("wlpPool :", client.config.wlpPool); + console.log("wlpType :", client.config.wlpType); + console.log("owner :", args.owner); + console.log("execute :", args.execute ? "yes (real tx)" : "no (simulate only)"); + console.log("scenarios:", args.only.join(", ")); + + const results: ScenarioResult[] = []; + if (args.only.includes("A")) results.push(await scenarioA(client, args)); + if (args.only.includes("B")) results.push(await scenarioB(client, args)); + if (args.only.includes("C")) results.push(await scenarioC(client, args)); + + printSummary(results); + + if (results.some((r) => r.status === "fail")) { + process.exit(1); + } +} + +main().catch((err) => { + console.error("\n[test-cancel-redeem-wlp] 失敗：", err); + process.exit(1); +}); diff --git a/test/fixtures/delegates/permission-matrix.json b/test/fixtures/delegates/permission-matrix.json new file mode 100644 index 0000000..d485cee --- /dev/null +++ b/test/fixtures/delegates/permission-matrix.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "comment": "Permission bit → human name; on-chain bitmask matches DELEGATE_PERM in test/helpers/delegate-perms.ts", + "entries": [ + { "name": "OPEN_POSITION", "bit": 1 }, + { "name": "CLOSE_POSITION", "bit": 2 }, + { "name": "PLACE_ORDER", "bit": 4 }, + { "name": "CANCEL_ORDER", "bit": 8 }, + { "name": "DEPOSIT_COLLATERAL", "bit": 16 }, + { "name": "WITHDRAW_COLLATERAL", "bit": 32 }, + { "name": "DEPOSIT", "bit": 64 }, + { "name": "WITHDRAW", "bit": 128 }, + { "name": "TRANSFER", "bit": 256 }, + { "name": "MINT_WLP", "bit": 512 }, + { "name": "REDEEM_WLP", "bit": 1024 }, + { "name": "MANAGE_DELEGATES", "bit": 2048 } + ] +} diff --git a/test/fixtures/trading/lifecycle-markets.json b/test/fixtures/trading/lifecycle-markets.json new file mode 100644 index 0000000..16bfd51 --- /dev/null +++ b/test/fixtures/trading/lifecycle-markets.json @@ -0,0 +1,197 @@ +{ + "BTC": { + "approxPrice": 70000, + "leverage": 2, + "openCollateral": "50000000", + "isLong": true, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "ETH": { + "approxPrice": 3800, + "leverage": 4, + "openCollateral": "42000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "SUI": { + "approxPrice": 1, + "leverage": 5, + "openCollateral": "35000000", + "isLong": true, + "sizeLot": "1000000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "10000000", + "increaseSize": "5000000", + "decreaseSize": "5000000" + } + }, + "SOL": { + "approxPrice": 180, + "leverage": 2, + "openCollateral": "40000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "WAL": { + "approxPrice": 0.45, + "leverage": 4, + "openCollateral": "32000000", + "isLong": true, + "sizeLot": "1000000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "10000000", + "increaseSize": "5000000", + "decreaseSize": "5000000" + } + }, + "DEEP": { + "approxPrice": 0.12, + "leverage": 4, + "openCollateral": "30000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "AAPLX": { + "approxPrice": 220, + "leverage": 2, + "openCollateral": "42000000", + "isLong": true, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "GOOGLX": { + "approxPrice": 175, + "leverage": 2, + "openCollateral": "40000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "METAX": { + "approxPrice": 520, + "leverage": 2, + "openCollateral": "44000000", + "isLong": true, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "NVDAX": { + "approxPrice": 140, + "leverage": 2, + "openCollateral": "41000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "QQQX": { + "approxPrice": 480, + "leverage": 2, + "openCollateral": "43000000", + "isLong": true, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "SPYX": { + "approxPrice": 580, + "leverage": 2, + "openCollateral": "45000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "TSLAX": { + "approxPrice": 340, + "leverage": 2, + "openCollateral": "40000000", + "isLong": true, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + } +} diff --git a/test/fixtures/trading/persistent-perp.json b/test/fixtures/trading/persistent-perp.json new file mode 100644 index 0000000..5f5099b --- /dev/null +++ b/test/fixtures/trading/persistent-perp.json @@ -0,0 +1,43 @@ +{ + "version": 1, + "description": "E2E persistent perp rows for the integration reference UserAccount (consumed by test/helpers/e2e-persistent-state.ts). Only crypto bases — xStock is not part of persistent e2e state.", + "markets": { + "BTC": { + "isLong": true, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "ETH": { + "isLong": false, + "leverage": 4, + "openCollateral": "10000000", + "openSize": "2000" + }, + "SUI": { + "isLong": true, + "leverage": 5, + "openCollateral": "10000000", + "openSize": "10000000" + }, + "SOL": { + "isLong": false, + "leverage": 4, + "simulateLeverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "WAL": { + "isLong": true, + "leverage": 4, + "openCollateral": "10000000", + "openSize": "10000000" + }, + "DEEP": { + "isLong": false, + "leverage": 4, + "openCollateral": "10000000", + "openSize": "2000" + } + } +} diff --git a/test/fixtures/trading/scenarios.json b/test/fixtures/trading/scenarios.json new file mode 100644 index 0000000..6a37890 --- /dev/null +++ b/test/fixtures/trading/scenarios.json @@ -0,0 +1,12 @@ +{ + "version": 1, + "description": "Scenario ids for table-driven trading simulate tests (openApproxOracle, explicitSizeFee, resize, statefulOps, singlePtb).", + "scenarios": [ + "openApproxOracle", + "explicitSizeOpenFee", + "resizeLeverageOnly", + "statefulOps", + "tableApproxPriceBtc", + "placeCancelBtc" + ] +} diff --git a/test/helpers/compute-leverage-size.ts b/test/helpers/compute-leverage-size.ts index 488828a..a15e2ca 100644 --- a/test/helpers/compute-leverage-size.ts +++ b/test/helpers/compute-leverage-size.ts @@ -18,3 +18,31 @@ export function computeLeverageDerivedSize(opts: ComputeLeverageSizeOptions): bi const sizeRaw = Math.floor(((collUsd * opts.leverage) / opts.approxPrice) * 1_000_000); return BigInt(sizeRaw - (sizeRaw > 1000 ? sizeRaw % 1000 : 0)); } + +/** + * Mirrors {@link resolveSizeFromParams} when `approxPrice` + `leverage` are set (`src/tx-builders.ts`). + * Uses `Number(collateralAmount)` as the notional numerator (USDC raw units are **not** divided by 1e6). + */ +export function replicateSdkApproxPriceSizeRaw(opts: { + collateralAmount: bigint | number; + leverage: number; + approxPrice: number; +}): bigint { + const lev = opts.leverage ?? 1; + const collUsd = Number(opts.collateralAmount); + const sizeRaw = Math.floor((collUsd * lev) / opts.approxPrice); + return BigInt(sizeRaw - (sizeRaw > 1000 ? sizeRaw % 1000 : 0)); +} + +export function explicitSizeRawForTargetLeverageUsd(opts: { + collateralRawUsdc6: bigint; + leverageTimes: number; + usdPerBaseToken: number; + sizeDecimal: number; +}): bigint { + const collateralUsd = Number(opts.collateralRawUsdc6) / 1_000_000; + const notionalUsd = collateralUsd * opts.leverageTimes; + const sizeInBase = notionalUsd / opts.usdPerBaseToken; + const scale = 10 ** opts.sizeDecimal; + return BigInt(Math.floor(sizeInBase * scale)); +} diff --git a/test/helpers/delegate-perms.ts b/test/helpers/delegate-perms.ts new file mode 100644 index 0000000..7d5cb22 --- /dev/null +++ b/test/helpers/delegate-perms.ts @@ -0,0 +1,20 @@ +/** + * Mirrors `waterx_perp::user_account` permission bitmask (u16). + * @see contracts/waterx_perp/sources/user_account.move + */ +export const DELEGATE_PERM = { + OPEN_POSITION: 1, + CLOSE_POSITION: 2, + PLACE_ORDER: 4, + CANCEL_ORDER: 8, + DEPOSIT_COLLATERAL: 16, + WITHDRAW_COLLATERAL: 32, + DEPOSIT: 64, + WITHDRAW: 128, + TRANSFER: 256, + MINT_WLP: 512, + REDEEM_WLP: 1024, + MANAGE_DELEGATES: 2048, + ALL_TRADING: 63, + ALL: 4095, +} as const; diff --git a/test/helpers/e2e-active-bases.ts b/test/helpers/e2e-active-bases.ts new file mode 100644 index 0000000..0b5b642 --- /dev/null +++ b/test/helpers/e2e-active-bases.ts @@ -0,0 +1,34 @@ +/** + * Single source of truth for which base markets are exercised by the e2e / preflight / + * prepare flows. + * + * `activeLifecycleTestBases()` (scratch lifecycle + e2e simulate + e2e PTB params) and + * `activeE2ePersistentPerpBases()` (persistent slot maintenance) both filter their own + * config tables by this list, so removing a base here disables it across ALL e2e surfaces + * at once (preflight checks, prepare/bootstrap opens, scratch simulate iterations). + * + * Re-enabling a base: just un-comment it in {@link ACTIVE_E2E_BASES} — the corresponding + * rows in `test/fixtures/trading/lifecycle-markets.json` and + * `test/fixtures/trading/persistent-perp.json` are still defined and will start running again + * automatically. + */ +import type { BaseAsset } from "../../src/constants.ts"; + +/** + * Bases exercised by e2e / preflight / prepare, in iteration order. Disable a base by + * removing it (or commenting out) and document why. + */ +export const ACTIVE_E2E_BASES: readonly BaseAsset[] = [ + "BTC", + "ETH", + "SUI", + "SOL", + "WAL", + // "DEEP" — disabled: testnet Pyth/Supra DEEP/USD aggregator below required weight + // (abort 204 err_total_weight_not_enough in simulate open). + // Re-enable once `pnpm e2e:preflight` shows DEEP oracle readiness OK. +]; + +export function isActiveE2eBase(base: BaseAsset): boolean { + return ACTIVE_E2E_BASES.includes(base); +} diff --git a/test/helpers/e2e-persistent-state.ts b/test/helpers/e2e-persistent-state.ts index f41828d..24ab04f 100644 --- a/test/helpers/e2e-persistent-state.ts +++ b/test/helpers/e2e-persistent-state.ts @@ -4,10 +4,14 @@ * scratch positions only (`trader-position-lifecycle` opens and closes its own). * * Perp: at least one open position per listed base (params align with e2e open leg). + * Rows come from [test/fixtures/trading/persistent-perp.json](../fixtures/trading/persistent-perp.json) — + * edit that JSON (not this file) to change sizes / leverage / direction. * WLP: mint when **UserAccount** balance is below `E2E_PERSISTENT_WLP.minBalanceRaw`. * Wallet-level WLP/collateral for simulate is covered by `e2e-wlp-readiness.ts` + preflight/prepare. */ import type { BaseAsset } from "../../src/constants.ts"; +import rawPersistent from "../fixtures/trading/persistent-perp.json"; +import { ACTIVE_E2E_BASES, isActiveE2eBase } from "./e2e-active-bases.ts"; export type E2ePersistentPerpRow = { isLong: boolean; @@ -20,65 +24,55 @@ export type E2ePersistentPerpRow = { openSize: bigint; }; -/** Scan order; only bases with a row in `E2E_PERSISTENT_PERP_MARKETS` are active. */ -export const E2E_PERSISTENT_PERP_ORDER: readonly BaseAsset[] = [ - "BTC", - "ETH", - "SUI", - "SOL", - "WAL", - "DEEP", -]; - -/** Add a key to enable persistent perp for that base; remove the key to disable. */ -export const E2E_PERSISTENT_PERP_MARKETS: Partial> = { - BTC: { - isLong: true, - leverage: 2, - openCollateral: 10_000_000n, - openSize: 2000n, - }, - ETH: { - isLong: false, - leverage: 4, - openCollateral: 10_000_000n, - openSize: 2000n, - }, - SUI: { - isLong: true, - leverage: 5, - openCollateral: 10_000_000n, - openSize: 10_000_000n, - }, - SOL: { - isLong: false, - leverage: 4, - simulateLeverage: 2, - openCollateral: 10_000_000n, - openSize: 2000n, - }, - WAL: { - isLong: true, - leverage: 4, - openCollateral: 10_000_000n, - openSize: 10_000_000n, - }, - DEEP: { - isLong: false, - leverage: 4, - openCollateral: 10_000_000n, - openSize: 2000n, - }, +type PersistentPerpJson = { + markets: Record< + string, + { + isLong: boolean; + leverage: number; + simulateLeverage?: number; + openCollateral: string; + openSize: string; + } + >; }; +function rowFromJson(j: PersistentPerpJson["markets"][string]): E2ePersistentPerpRow { + const row: E2ePersistentPerpRow = { + isLong: j.isLong, + leverage: j.leverage, + openCollateral: BigInt(j.openCollateral), + openSize: BigInt(j.openSize), + }; + if (j.simulateLeverage !== undefined) row.simulateLeverage = j.simulateLeverage; + return row; +} + +const parsedPersistent: Partial> = {}; +for (const [k, v] of Object.entries((rawPersistent as PersistentPerpJson).markets)) { + parsedPersistent[k as BaseAsset] = rowFromJson(v); +} + +/** Persistent perp rows (loaded from `test/fixtures/trading/persistent-perp.json`). */ +export const E2E_PERSISTENT_PERP_MARKETS: Partial> = + parsedPersistent; + +/** + * Bases with both a persistent-perp fixture row AND an entry in {@link ACTIVE_E2E_BASES}. + * Toggling a base on/off for every e2e surface is done by editing `ACTIVE_E2E_BASES`. + */ export function activeE2ePersistentPerpBases(): BaseAsset[] { - return E2E_PERSISTENT_PERP_ORDER.filter((b) => E2E_PERSISTENT_PERP_MARKETS[b] != null); + return ACTIVE_E2E_BASES.filter( + (b) => E2E_PERSISTENT_PERP_MARKETS[b] != null && isActiveE2eBase(b), + ); } export function e2ePersistentPerpRow(base: BaseAsset): E2ePersistentPerpRow { const row = E2E_PERSISTENT_PERP_MARKETS[base]; if (!row) { - throw new Error(`No E2E_PERSISTENT_PERP_MARKETS[${base}] — add a row or remove callers.`); + throw new Error( + `No E2E_PERSISTENT_PERP_MARKETS[${base}] — add a row in test/fixtures/trading/persistent-perp.json or remove callers.`, + ); } return row; } diff --git a/test/helpers/integration-reference-wallet.ts b/test/helpers/integration-reference-wallet.ts index d98a16a..7d768f0 100644 --- a/test/helpers/integration-reference-wallet.ts +++ b/test/helpers/integration-reference-wallet.ts @@ -4,7 +4,7 @@ * Persistent perp + WLP targets for this account: `test/helpers/e2e-persistent-state.ts`. */ export const INTEGRATION_REFERENCE_WALLET_ADDRESS = - "0xdab02860cc388c0d1613520dca5b876ff1a89435d85933f027982baa8ef18700"; + "0xce898112fe8a68f5a203bd1e69fd438a021949ac420287eaf31d7665f6150247"; /** * Canonical WaterX **UserAccount** object id for {@link INTEGRATION_REFERENCE_WALLET_ADDRESS} on @@ -15,4 +15,4 @@ export const INTEGRATION_REFERENCE_WALLET_ADDRESS = * `.e2e-fixed-positions.local.json`). */ export const INTEGRATION_REFERENCE_USER_ACCOUNT_ID = - "0x20f9ec03b8704d7c5295e88143131646d1791cd7e4f2c5290565471d99fa3295"; + "0xab4795318525c9a6113fcba320a785345f3a8b66c523ec1a517ac040d2cd945b"; diff --git a/test/helpers/lifecycle-test-markets.ts b/test/helpers/lifecycle-test-markets.ts index 9740235..df8ac2a 100644 --- a/test/helpers/lifecycle-test-markets.ts +++ b/test/helpers/lifecycle-test-markets.ts @@ -1,13 +1,14 @@ /** * Single source of truth for **integration** + **e2e** per-market lifecycle / open-position tests. * - * - Add a `BaseAsset` key to run that market in both suites; **delete the key** (or comment block) - * to stop running it. - * - Iteration order is {@link LIFECYCLE_TEST_BASE_ORDER} intersected with keys present in - * {@link LIFECYCLE_TEST_MARKETS}. + * Data rows live in [test/fixtures/trading/lifecycle-markets.json](../fixtures/trading/lifecycle-markets.json). + * Add or remove a market by editing that JSON — this module only re-exports the typed view. + * Iteration order is {@link LIFECYCLE_TEST_BASE_ORDER} intersected with keys present in the fixture. */ import type { BaseAsset } from "../../src/constants.ts"; +import { LIFECYCLE_TEST_MARKETS_FROM_FIXTURE } from "./load-trading-fixtures.ts"; + export type LifecycleTestMarketRow = { /** * Ballpark USD/base for simulate / e2e `approxPrice` and `computeLeverageDerivedSize`. @@ -47,6 +48,10 @@ export type LifecycleTestMarketRow = { /** * Preferred scan / test order. Only bases with a row in {@link LIFECYCLE_TEST_MARKETS} run. + * + * xStock rows also exist in [test/fixtures/trading/lifecycle-markets.json](../fixtures/trading/lifecycle-markets.json) + * but are intentionally omitted from the default iteration order — add them here to opt-in + * (requires working xStock Pyth/Supra oracles on testnet). */ export const LIFECYCLE_TEST_BASE_ORDER: readonly BaseAsset[] = [ "BTC", @@ -57,99 +62,9 @@ export const LIFECYCLE_TEST_BASE_ORDER: readonly BaseAsset[] = [ "DEEP", ]; -/** Enable a market by adding a row; disable by removing the key. */ -export const LIFECYCLE_TEST_MARKETS: Partial> = { - BTC: { - approxPrice: 70_000, - leverage: 2, - openCollateral: 50_000_000n, - isLong: true, - sizeLot: 1000n, - simulateOpenCollateral: 10_000_000n, - e2ePtb: { - openCollateral: 10_000_000n, - increaseCollateral: 5_000_000n, - openSize: 2000n, - increaseSize: 1000n, - decreaseSize: 1000n, - }, - }, - ETH: { - approxPrice: 3800, - leverage: 4, - openCollateral: 42_000_000n, - isLong: false, - sizeLot: 1000n, - simulateOpenCollateral: 10_000_000n, - e2ePtb: { - openCollateral: 10_000_000n, - increaseCollateral: 5_000_000n, - openSize: 2000n, - increaseSize: 1000n, - decreaseSize: 1000n, - }, - }, - SUI: { - approxPrice: 1, - leverage: 5, - openCollateral: 35_000_000n, - isLong: true, - sizeLot: 1_000_000n, - simulateOpenCollateral: 10_000_000n, - e2ePtb: { - openCollateral: 10_000_000n, - increaseCollateral: 5_000_000n, - openSize: 10_000_000n, - increaseSize: 5_000_000n, - decreaseSize: 5_000_000n, - }, - }, - SOL: { - approxPrice: 180, - leverage: 2, - openCollateral: 40_000_000n, - isLong: false, - sizeLot: 1000n, - simulateOpenCollateral: 10_000_000n, - e2ePtb: { - openCollateral: 10_000_000n, - increaseCollateral: 5_000_000n, - openSize: 2000n, - increaseSize: 1000n, - decreaseSize: 1000n, - }, - }, - WAL: { - approxPrice: 0.45, - leverage: 4, - openCollateral: 32_000_000n, - isLong: true, - sizeLot: 1_000_000n, - simulateOpenCollateral: 10_000_000n, - e2ePtb: { - openCollateral: 10_000_000n, - increaseCollateral: 5_000_000n, - openSize: 10_000_000n, - increaseSize: 5_000_000n, - decreaseSize: 5_000_000n, - }, - }, - DEEP: { - approxPrice: 0.12, - leverage: 4, - openCollateral: 30_000_000n, - isLong: false, - sizeLot: 1000n, - simulateOpenCollateral: 10_000_000n, - e2ePtb: { - openCollateral: 10_000_000n, - increaseCollateral: 5_000_000n, - openSize: 2000n, - increaseSize: 1000n, - decreaseSize: 1000n, - }, - }, -}; +/** Fixture-backed rows. Add/disable a market by editing `lifecycle-markets.json`. */ +export const LIFECYCLE_TEST_MARKETS: Partial> = + LIFECYCLE_TEST_MARKETS_FROM_FIXTURE; /** Bases that have a row — in stable order. */ export function activeLifecycleTestBases(): BaseAsset[] { @@ -160,7 +75,7 @@ export function lifecycleRow(base: BaseAsset): LifecycleTestMarketRow { const row = LIFECYCLE_TEST_MARKETS[base]; if (!row) { throw new Error( - `No LIFECYCLE_TEST_MARKETS[${base}] — add a row or remove ${base} from callers.`, + `No LIFECYCLE_TEST_MARKETS[${base}] — add a row to test/fixtures/trading/lifecycle-markets.json or remove ${base} from callers.`, ); } return row; diff --git a/test/helpers/load-trading-fixtures.ts b/test/helpers/load-trading-fixtures.ts new file mode 100644 index 0000000..380f750 --- /dev/null +++ b/test/helpers/load-trading-fixtures.ts @@ -0,0 +1,54 @@ +/** + * Loads [test/fixtures/trading/lifecycle-markets.json](test/fixtures/trading/lifecycle-markets.json) + * — single source for lifecycle rows used by e2e / simulate table tests. + */ +import raw from "../fixtures/trading/lifecycle-markets.json"; + +import type { BaseAsset } from "../../src/constants.ts"; + +/** Mirrors {@link import("./lifecycle-test-markets.ts").LifecycleTestMarketRow} — kept local to avoid circular imports. */ +type FixtureRow = { + approxPrice: number; + leverage: number; + openCollateral: bigint; + isLong: boolean; + sizeLot: bigint; + simulateOpenCollateral: bigint; + simulateLeverage?: number; + e2ePtb: { + openCollateral: bigint; + increaseCollateral: bigint; + openSize: bigint; + increaseSize: bigint; + decreaseSize: bigint; + }; +}; + +function rowFromJson(j: Record): FixtureRow { + const e2e = j.e2ePtb as Record; + return { + approxPrice: j.approxPrice as number, + leverage: j.leverage as number, + openCollateral: BigInt(j.openCollateral as string), + isLong: j.isLong as boolean, + sizeLot: BigInt(j.sizeLot as string), + simulateOpenCollateral: BigInt(j.simulateOpenCollateral as string), + simulateLeverage: + j.simulateLeverage !== undefined ? (j.simulateLeverage as number) : undefined, + e2ePtb: { + openCollateral: BigInt(e2e.openCollateral), + increaseCollateral: BigInt(e2e.increaseCollateral), + openSize: BigInt(e2e.openSize), + increaseSize: BigInt(e2e.increaseSize), + decreaseSize: BigInt(e2e.decreaseSize), + }, + }; +} + +const parsed: Partial> = {}; +for (const [k, v] of Object.entries(raw as Record>)) { + parsed[k as BaseAsset] = rowFromJson(v); +} + +/** Lifecycle market rows from JSON fixture (bigint fields as decimal strings). */ +export const LIFECYCLE_TEST_MARKETS_FROM_FIXTURE: Partial> = parsed; diff --git a/test/helpers/move-event-payload.ts b/test/helpers/move-event-payload.ts new file mode 100644 index 0000000..bb0b76d --- /dev/null +++ b/test/helpers/move-event-payload.ts @@ -0,0 +1,174 @@ +/** + * Normalize gRPC / JSON-RPC Move event payloads (parsedJson) for test assertions. + * Handles Sui explorer-style `{ fields: { ... } }`, stringified JSON, and camelCase. + * When `parsedJson` is missing (some gRPC simulate paths), decodes `contents` BCS for + * `waterx_perp::events::PositionOpened` using generated struct layout. + */ +import { fromBase64 } from "@mysten/bcs"; + +import { PositionOpened as PositionOpenedStruct } from "../../src/generated/waterx_perp/events.ts"; + +/** Unwrap one level of `fields` nesting (Sui JSON-RPC / explorer). */ +export function unwrapSuiDisplayJson(obj: unknown): Record | null { + if (obj == null || typeof obj !== "object") return null; + let cur: unknown = obj; + for (let depth = 0; depth < 8; depth++) { + if (cur == null || typeof cur !== "object") break; + const o = cur as Record; + if ("fields" in o && o.fields != null && typeof o.fields === "object") { + cur = o.fields; + continue; + } + break; + } + return cur != null && typeof cur === "object" ? (cur as Record) : null; +} + +const FLOAT_PRECISION = 1_000_000_000n; + +function bytesFromUnknownContents(raw: unknown): Uint8Array | null { + if (raw == null) return null; + if (raw instanceof Uint8Array) return raw; + if (typeof raw === "string") { + try { + return fromBase64(raw); + } catch { + return null; + } + } + if (Array.isArray(raw)) return new Uint8Array(raw as number[]); + return null; +} + +/** + * Map on-chain `PositionOpened` BCS to the same loose shape as JSON `parsedJson` (for {@link readPositionOpenedFields}). + */ +function flatJsonFromPositionOpenedBcs(decoded: { + size: { value: bigint }; + entry_price: { value: bigint }; + open_fee_amount: bigint; + is_long: boolean; +}): Record { + const sv = decoded.size.value; + const sizeAmount = + sv >= FLOAT_PRECISION && sv % FLOAT_PRECISION === 0n ? sv / FLOAT_PRECISION : sv; + return { + size_amount: sizeAmount.toString(), + open_fee_amount: decoded.open_fee_amount.toString(), + is_long: decoded.is_long, + entry_price: { value: decoded.entry_price.value.toString() }, + }; +} + +function tryPayloadFromPositionOpenedBcs(ev: Record): unknown | null { + const t = String( + ev.type ?? + ev.eventType ?? + ev.moveEventType ?? + (typeof ev.event_type === "string" ? ev.event_type : "") ?? + "", + ); + if (!t.includes("::events::PositionOpened")) return null; + const raw = ev.contents ?? (ev.event as Record | undefined)?.contents; + const bytes = bytesFromUnknownContents(raw); + if (!bytes?.length) return null; + try { + const decoded = PositionOpenedStruct.parse(bytes) as unknown as { + size: { value: bigint }; + entry_price: { value: bigint }; + open_fee_amount: bigint; + is_long: boolean; + }; + return flatJsonFromPositionOpenedBcs(decoded); + } catch { + return null; + } +} + +/** + * Best-effort parse of `parsedJson` / `json` / `parsed_json` from a simulate event record. + */ +export function payloadFromSimulateEventRecord(ev: Record): unknown { + let p: unknown = ev.parsedJson ?? ev.json ?? ev.parsed_json; + if (typeof p === "string") { + try { + p = JSON.parse(p) as unknown; + } catch { + p = null; + } + } + if (p == null || typeof p !== "object") { + const fromBcs = tryPayloadFromPositionOpenedBcs(ev); + return fromBcs ?? p; + } + const flat = unwrapSuiDisplayJson(p); + return flat ?? p; +} + +export function boolFromUnknown(v: unknown): boolean | null { + if (v === true || v === false) return v; + if (v === 0 || v === "0") return false; + if (v === 1 || v === "1") return true; + if (v === "true") return true; + if (v === "false") return false; + return null; +} + +export function u64FromField(v: unknown): bigint | null { + if (typeof v === "bigint") return v; + if (typeof v === "number" && Number.isFinite(v)) return BigInt(Math.trunc(v)); + if (typeof v === "string" && /^[0-9]+$/.test(v)) return BigInt(v); + return null; +} + +/** Float `to_scaled_val` / JSON `{ value: u128 string }` / bare u128 string. */ +export function floatScaledFromJson(j: unknown): bigint | null { + if (j == null) return null; + const direct = u64FromField(j); + if (direct !== null) return direct; + if (typeof j === "object") { + const o = j as Record; + if ("value" in o) return floatScaledFromJson(o.value); + if ("fields" in o) return floatScaledFromJson(o.fields); + } + return null; +} + +/** + * Read fields needed for open-fee assertion from a PositionOpened `parsedJson` object. + */ +export function readPositionOpenedFields(payload: Record): { + sizeAmount: bigint; + openFeeAmount: bigint; + isLong: boolean; + entryPriceScaled: bigint; +} | null { + const sizeRaw = + payload.size_amount ?? + payload.sizeAmount ?? + payload.size ?? + payload["size_amount"]; + const feeRaw = + payload.open_fee_amount ?? + payload.openFeeAmount ?? + payload["open_fee_amount"]; + const longRaw = payload.is_long ?? payload.isLong ?? payload["is_long"]; + const priceRaw = payload.entry_price ?? payload.entryPrice ?? payload["entry_price"]; + + let sizeAmount = u64FromField(sizeRaw); + if (sizeAmount === null) { + const fs = floatScaledFromJson(sizeRaw); + if (fs !== null) { + sizeAmount = + fs >= FLOAT_PRECISION && fs % FLOAT_PRECISION === 0n ? fs / FLOAT_PRECISION : fs; + } + } + const openFeeAmount = u64FromField(feeRaw); + const entryPriceScaled = floatScaledFromJson(priceRaw); + const isLong = boolFromUnknown(longRaw); + if (sizeAmount === null || openFeeAmount === null || entryPriceScaled === null || isLong === null) { + return null; + } + + return { sizeAmount, openFeeAmount, isLong, entryPriceScaled }; +} diff --git a/test/helpers/place-cancel-probe.ts b/test/helpers/place-cancel-probe.ts new file mode 100644 index 0000000..34176cb --- /dev/null +++ b/test/helpers/place-cancel-probe.ts @@ -0,0 +1,133 @@ +/** + * Place+cancel in one PTB needs the `order_id` that **place** will assign. + * + * `getMarketSummary().nextOrderId` is correct **only if** no other testnet tx increments the + * counter between that read and this PTB's simulate — otherwise cancel hits `err_order_not_found` + * (300). {@link simulatePlaceCancelSinglePtbWithRetries} re-fetches `nextOrderId` and re-simulates + * on 300. Long-term: `TODO(contracts#cancel-by-key)` if the chain exposes cancel without a price key. + */ +import type { Transaction } from "@mysten/sui/transactions"; +import { getMarketSummary, type WaterXClient } from "@waterx/perp-sdk"; + +import type { BaseAsset } from "../../src/constants.ts"; +import { payloadFromSimulateEventRecord, u64FromField } from "./move-event-payload.ts"; +import { eventRecordType, eventsFromSimulateResult } from "./oracle-simulate-multi-asset.ts"; +import { parseSimulateFailure } from "./simulate-assertions.ts"; + +/** Matches Move `float::floor(trigger_price)` for USD prices built via `round(usd * 1e9)` scaled val. */ +export function usdToTriggerPriceKey(usd: number): number { + const scaled = BigInt(Math.round(usd * 1e9)); + return Number(scaled / 1_000_000_000n); +} + +/** + * Re-fetch `nextOrderId` + re-simulate when cancel aborts with 300 (stale predicted id / testnet race). + */ +export async function simulatePlaceCancelSinglePtbWithRetries( + client: WaterXClient, + args: { + base: BaseAsset; + /** Same USD as `buildPlaceOrderTx` / `placeOrder` `triggerPrice`. */ + triggerPriceUsd: number; + maxAttempts?: number; + gasBudget?: number; + build: (input: { tx: Transaction; orderId: bigint; triggerPriceKey: number }) => void | Promise; + setSender: (tx: Transaction) => void; + }, +): Promise< + | { ok: true; result: unknown; tx: Transaction } + | { ok: false; lastResult: unknown; lastTx: Transaction } +> { + const { Transaction } = await import("@mysten/sui/transactions"); + const triggerPriceKey = usdToTriggerPriceKey(args.triggerPriceUsd); + const max = args.maxAttempts ?? 12; + const gasBudget = args.gasBudget ?? 300_000_000; + let lastResult: unknown; + let lastTx: Transaction | undefined; + + for (let i = 0; i < max; i++) { + const entry = client.getMarketEntry(args.base); + const summary = await getMarketSummary(client, entry.marketId, entry.baseType); + const orderId = summary.nextOrderId; + + const tx = new Transaction(); + lastTx = tx; + tx.setGasBudget(gasBudget); + await args.build({ tx, orderId, triggerPriceKey }); + args.setSender(tx); + + const result = await client.simulate(tx); + lastResult = result; + if (result && typeof result === "object" && (result as { $kind?: string }).$kind === "Transaction") { + return { ok: true, result, tx }; + } + const meta = parseSimulateFailure(result); + if (meta?.abortCode !== "300") { + return { ok: false, lastResult: result, lastTx: tx }; + } + } + + return { ok: false, lastResult, lastTx: lastTx! }; +} + +function orderIdFromOrderCreatedEvents(result: unknown): bigint | null { + const events = eventsFromSimulateResult(result); + for (const ev of events) { + const t = eventRecordType(ev); + if (!t.includes("::events::OrderCreated")) continue; + const raw = ev as Record; + const p = payloadFromSimulateEventRecord(raw); + if (p == null || typeof p !== "object") continue; + const rec = p as Record; + const id = rec.order_id ?? rec.orderId; + const n = u64FromField(id); + if (n !== null) return n; + } + return null; +} + +/** + * Dry-run **place order only**; return `order_id` from `OrderCreated` event body. + * Returns `null` if simulate fails or event missing. + */ +export async function simulatePlaceOrderProbeOrderId( + client: WaterXClient, + buildPlaceOnly: (tx: Transaction) => void | Promise, + setSender: (tx: Transaction) => void, + gasBudget = 320_000_000, +): Promise { + const { Transaction } = await import("@mysten/sui/transactions"); + const tx = new Transaction(); + tx.setGasBudget(gasBudget); + await buildPlaceOnly(tx); + setSender(tx); + const result = await client.grpcClient.simulateTransaction({ + transaction: tx, + include: { events: true, commandResults: true, effects: true }, + }); + if (!result || typeof result !== "object") return null; + if ((result as { $kind?: string }).$kind === "FailedTransaction") return null; + return orderIdFromOrderCreatedEvents(result); +} + +/** + * Retry probe a few times (ledger `next_order_id` can move between attempts). + */ +export async function probeOrderIdForPlaceCancelWithRetry( + client: WaterXClient, + buildPlaceOnly: (tx: Transaction) => void | Promise, + setSender: (tx: Transaction) => void, + opts?: { retries?: number; gasBudget?: number }, +): Promise<{ orderId: bigint } | { reason: string }> { + const retries = opts?.retries ?? 3; + const gasBudget = opts?.gasBudget ?? 320_000_000; + for (let i = 0; i < retries; i++) { + const id = await simulatePlaceOrderProbeOrderId(client, buildPlaceOnly, setSender, gasBudget); + if (id !== null) return { orderId: id }; + } + return { + reason: + "testnet order_id probe failed after retries — possible oracle failure or heavy testnet race; " + + "consider contracts#cancel-by-key API", + }; +} diff --git a/test/helpers/trading-fixture-harness.ts b/test/helpers/trading-fixture-harness.ts new file mode 100644 index 0000000..e02ea35 --- /dev/null +++ b/test/helpers/trading-fixture-harness.ts @@ -0,0 +1,27 @@ +/** + * Table + JSON fixture helpers for trading simulate tests. + * Lifecycle rows load from `test/fixtures/trading/lifecycle-markets.json` via + * {@link import("./load-trading-fixtures.ts").LIFECYCLE_TEST_MARKETS_FROM_FIXTURE}. + */ +import type { BaseAsset } from "../../src/constants.ts"; + +import { + activeLifecycleTestBases, + lifecycleRow, + type LifecycleTestMarketRow, +} from "./lifecycle-test-markets.ts"; + +export type TradingFixtureCase = { + base: BaseAsset; + row: LifecycleTestMarketRow; +}; + +/** + * Expands the active e2e base set × lifecycle row for data-driven describes. + */ +export function activeTradingFixtureCases(): TradingFixtureCase[] { + return activeLifecycleTestBases().map((base) => ({ + base, + row: lifecycleRow(base), + })); +} diff --git a/test/helpers/wlp-pool-price-refresh.ts b/test/helpers/wlp-pool-price-refresh.ts new file mode 100644 index 0000000..fca1fe3 --- /dev/null +++ b/test/helpers/wlp-pool-price-refresh.ts @@ -0,0 +1,66 @@ +/** + * Mirrors `refreshAllPoolTokensAndGetDepositPriceResult` in `tx-builders.ts` (private): + * Hermes Pyth refresh (optional) + `lp_pool::update_token_value` for **each** configured collateral + * so `assert_prices_fresh` passes before `request_redeem` / mint / settle paths. + */ +import { Transaction } from "@mysten/sui/transactions"; +import { + buildOracleFeed, + PYTH_TESTNET_FEED_IDS, + PythCache, + updatePythPrices, + type WaterXClient, +} from "@waterx/perp-sdk"; + +import { updateTokenValue as updateTokenValueCall } from "../../src/generated/waterx_perp/lp_pool.ts"; + +export type AppendWlpPoolPriceRefreshOpts = { + updatePythPrice?: boolean; + pythCache?: PythCache; +}; + +/** + * Appends oracle wiring to `tx` so WLP pool token timestamps are fresh (testnet simulate). + */ +export async function appendWlpPoolTokenRefreshesForSimulate( + client: WaterXClient, + tx: Transaction, + opts: AppendWlpPoolPriceRefreshOpts = {}, +): Promise { + const cfg = client.config; + const pythCfg = cfg.pythConfig; + const feedIds = PYTH_TESTNET_FEED_IDS; + + for (const [, coll] of Object.entries(cfg.collaterals)) { + if (opts.updatePythPrice && pythCfg && coll.feedKey) { + const feedId = feedIds[coll.feedKey]; + if (feedId) { + try { + await updatePythPrices( + tx, + client.grpcClient, + pythCfg, + [feedId.replace(/^0x/, "")], + opts.pythCache ?? new PythCache(), + ); + } catch { + /* Hermes down — on-chain Pyth may still be within tolerance */ + } + } + } + + const priceResult = buildOracleFeed( + client, + tx, + coll.type, + coll.aggregatorId, + coll.priceInfoId, + ); + + updateTokenValueCall({ + package: cfg.packageId, + arguments: { pool: cfg.wlpPool, priceResult }, + typeArguments: [cfg.wlpType, coll.type], + })(tx); + } +} diff --git a/test/integration/setup.ts b/test/integration/setup.ts index 38382d8..b8364bf 100644 --- a/test/integration/setup.ts +++ b/test/integration/setup.ts @@ -201,15 +201,20 @@ function isCooldownNotElapsedError(e: unknown): boolean { */ export function isSupraOracleInfrastructureError(e: unknown): boolean { const s = e instanceof Error ? e.message : String(e); - return s.includes("supra_rule::feed"); + return ( + s.includes("supra_rule::feed") || + s.includes("pyth_rule::feed") || + s.includes("err_total_weight_not_enough") + ); } /** Vitest `TestContext` slice — any object with `skip` works. */ export type IntegrationSkipContext = { skip: (reason?: string) => void }; /** - * Runs an async integration action; on testnet Supra infra failure, marks the test skipped instead - * of failing (same policy as simulate `isOracleTransientFailureMessage`). + * Runs an async integration action; on testnet oracle infra failure (Supra / Pyth / aggregator + * weight), marks the test skipped instead of failing (same policy as simulate + * `isOracleTransientFailureMessage`). * * @returns `undefined` when skipped (caller should `return`); otherwise the action result. */ @@ -222,7 +227,7 @@ export async function execIntegrationOrSkipSupra( } catch (e) { if (isSupraOracleInfrastructureError(e)) { ctx.skip( - `Testnet Supra oracle unavailable (transient): ${e instanceof Error ? e.message : String(e)}`, + `Testnet oracle unavailable (transient): ${e instanceof Error ? e.message : String(e)}`, ); return undefined; } diff --git a/test/scripts/regen-trading-fixtures.ts b/test/scripts/regen-trading-fixtures.ts new file mode 100644 index 0000000..a98d3d6 --- /dev/null +++ b/test/scripts/regen-trading-fixtures.ts @@ -0,0 +1,12 @@ +#!/usr/bin/env node +/** + * Placeholder for regenerating `test/fixtures/trading/*.json` golden baselines from testnet simulate. + * + * Usage (future): `pnpm test:regen-fixtures -- --base BTC` + * For now: edit `lifecycle-markets.json` by hand when market params change; run `pnpm typecheck`. + */ +console.log( + "[regen-trading-fixtures] No-op: update test/fixtures/trading/lifecycle-markets.json manually. " + + "Optional future: snapshot simulate events into per-base expected JSON.", +); +process.exit(0); diff --git a/test/simulate/collateral-order-simulate.test.ts b/test/simulate/collateral-order-simulate.test.ts index cb895a9..f400318 100644 --- a/test/simulate/collateral-order-simulate.test.ts +++ b/test/simulate/collateral-order-simulate.test.ts @@ -15,10 +15,12 @@ import { updatePythPrices } from "../../src/utils/pyth.ts"; import { buildOracleFeedForSimulate as buildOracleFeed } from "../helpers/build-oracle-feed-simulate.ts"; import { ensureAtLeastFundedTtoUsdcCoinsForSimulate } from "../helpers/ensure-tto-usdc-coins-for-simulate.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; +import { simulatePlaceCancelSinglePtbWithRetries } from "../helpers/place-cancel-probe.ts"; import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { assertSimulateSuccess, + parseSimulateFailure, skipSimulateIfOracleTransient, } from "../helpers/simulate-assertions.ts"; import { client } from "../helpers/testnet.ts"; @@ -31,7 +33,6 @@ const OPEN_SIZE = 2_000n; const ORDER_TRIGGER_PRICE_USD = 60_000; const ORDER_TRIGGER_PRICE_SCALED = BigInt(Math.round(ORDER_TRIGGER_PRICE_USD * 1e9)); -const ORDER_TRIGGER_PRICE_KEY = BigInt(ORDER_TRIGGER_PRICE_USD); const ORDER_TYPE_TAG_LIMIT_BUY = 0; const ORDER_COLLATERAL = 10_000_000n; const ORDER_SIZE = 2_000n; @@ -223,9 +224,6 @@ describe("placeOrder / cancelOrder (single-PTB simulate, no keys)", () => { } const m = client.getMarketEntry("BTC"); - const summary = await getMarketSummary(client, m.marketId, m.baseType); - const orderId = summary.nextOrderId; - const cfg = client.config; const usdcCoins = await getAccountCoins(client, accountId, cfg.collaterals.USDC.type); const funded = usdcCoins @@ -236,11 +234,6 @@ describe("placeOrder / cancelOrder (single-PTB simulate, no keys)", () => { return; } - const tx = new Transaction(); - tx.setSender(OWNER); - tx.setGasBudget(300_000_000); - - await appendBestEffortPythUpdates(tx); const tradingBase = { collateralTokenType: cfg.collaterals.USDC.type, baseTokenType: m.baseType, @@ -249,54 +242,65 @@ describe("placeOrder / cancelOrder (single-PTB simulate, no keys)", () => { accountId, }; - const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp1 = buildOracleFeed( - client, - tx, - cfg.collaterals.USDC.type, - cfg.collaterals.USDC.aggregatorId, - cfg.collaterals.USDC.priceInfoId, - ); - placeOrder(client, tx, { - ...tradingBase, - receivingCoins: [funded[0]!], - collateralAmount: ORDER_COLLATERAL, - isLong: true, - isStopOrder: false, - reduceOnly: false, - size: ORDER_SIZE, - triggerPrice: ORDER_TRIGGER_PRICE_SCALED, - basePriceResult: bp1, - collateralPriceResult: cp1, - }); + const outcome = await simulatePlaceCancelSinglePtbWithRetries(client, { + base: "BTC", + triggerPriceUsd: ORDER_TRIGGER_PRICE_USD, + gasBudget: 300_000_000, + setSender: (tx) => tx.setSender(OWNER), + build: async ({ tx, orderId, triggerPriceKey }) => { + await appendBestEffortPythUpdates(tx); + const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); + const cp1 = buildOracleFeed( + client, + tx, + cfg.collaterals.USDC.type, + cfg.collaterals.USDC.aggregatorId, + cfg.collaterals.USDC.priceInfoId, + ); + placeOrder(client, tx, { + ...tradingBase, + receivingCoins: [funded[0]!], + collateralAmount: ORDER_COLLATERAL, + isLong: true, + isStopOrder: false, + reduceOnly: false, + size: ORDER_SIZE, + triggerPrice: ORDER_TRIGGER_PRICE_SCALED, + basePriceResult: bp1, + collateralPriceResult: cp1, + }); - const bp2 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp2 = buildOracleFeed( - client, - tx, - cfg.collaterals.USDC.type, - cfg.collaterals.USDC.aggregatorId, - cfg.collaterals.USDC.priceInfoId, - ); - cancelOrder(client, tx, { - ...tradingBase, - orderId, - triggerPriceKey: ORDER_TRIGGER_PRICE_KEY, - orderTypeTag: ORDER_TYPE_TAG_LIMIT_BUY, - basePriceResult: bp2, - collateralPriceResult: cp2, + const bp2 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); + const cp2 = buildOracleFeed( + client, + tx, + cfg.collaterals.USDC.type, + cfg.collaterals.USDC.aggregatorId, + cfg.collaterals.USDC.priceInfoId, + ); + cancelOrder(client, tx, { + ...tradingBase, + orderId, + triggerPriceKey: BigInt(triggerPriceKey), + orderTypeTag: ORDER_TYPE_TAG_LIMIT_BUY, + basePriceResult: bp2, + collateralPriceResult: cp2, + }); + }, }); - try { - const result = await client.simulate(tx); - assertSimulateSuccessOrSkipOracleWeak(ctx, result, 22, tx); - } catch (e) { - const msg = e instanceof Error ? e.message : String(e); - if (msg.includes("err_order_not_found") || msg.includes("300")) { - ctx.skip("orderId prediction stale on shared testnet"); + if (!outcome.ok) { + if (skipSimulateIfOracleTransient(ctx, outcome.lastResult)) return; + const meta = parseSimulateFailure(outcome.lastResult); + if (meta?.abortCode === "300") { + ctx.skip( + "testnet orderId raced even after retries — TODO(contracts#cancel-by-key)", + ); return; } - throw e; + assertSimulateSuccessOrSkipOracleWeak(ctx, outcome.lastResult, 22, outcome.lastTx); + return; } + assertSimulateSuccessOrSkipOracleWeak(ctx, outcome.result, 22, outcome.tx); }, 120_000); }); diff --git a/test/simulate/delegate-lifecycle-simulate.test.ts b/test/simulate/delegate-lifecycle-simulate.test.ts new file mode 100644 index 0000000..6bcb3dc --- /dev/null +++ b/test/simulate/delegate-lifecycle-simulate.test.ts @@ -0,0 +1,154 @@ +/** + * Sub-account / delegate: simulate paths that hit `has_permission` on-chain. + * Positive cases require an existing on-chain delegate row (run owner `addDelegate` once, or use + * an account that already has delegates). + */ +import { buildPlaceOrderTx, getAccountBalance, getAccountsByOwner } from "@waterx/perp-sdk"; +import { describe, expect, it } from "vitest"; + +import { DELEGATE_PERM } from "../helpers/delegate-perms.ts"; +import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; +import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; +import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; +import { assertSimulateMoveAbort, skipSimulateIfOracleTransient } from "../helpers/simulate-assertions.ts"; +import { client } from "../helpers/testnet.ts"; +import { WATERX_PERP_ABORT } from "../helpers/waterx-perp-error-codes.ts"; + +/** Not the owner / not a delegate — must fail `place_order_request` permission check. */ +const STRANGER = + "0x2222222222222222222222222222222222222222222222222222222222222222" as const; + +const ORDER_COLLATERAL = 10_000_000n; +const ORDER_SIZE = 2_000n; + +describe("delegate lifecycle (simulate)", () => { + it("stranger sender cannot placeOrder on reference account (err_unauthorized 800)", async (ctx) => { + const accounts = await getAccountsByOwner(client, OWNER); + if (!accounts.length) { + ctx.skip(`No UserAccount for ${OWNER}`); + return; + } + let accountId: string; + try { + accountId = pickE2eAccountIdForOwner(OWNER, accounts); + } catch (e) { + ctx.skip(e instanceof Error ? e.message : String(e)); + return; + } + + const prices = await lifecycleOracleUsdOrSkip(client, ctx); + if (!prices) return; + + const usdc = await getAccountBalance(client, accountId, client.config.collaterals.USDC.type); + if (usdc < ORDER_COLLATERAL) { + ctx.skip(`Insufficient USDC in account for placeOrder probe`); + return; + } + + const tx = await buildPlaceOrderTx(client, { + accountId, + base: "BTC", + isLong: true, + collateralAmount: ORDER_COLLATERAL, + size: ORDER_SIZE, + triggerPrice: 55_000, + approxPrice: prices.BTC, + }); + tx.setSender(STRANGER); + const result = await client.simulate(tx); + if (skipSimulateIfOracleTransient(ctx, result)) return; + assertSimulateMoveAbort(result, { + abortCode: WATERX_PERP_ABORT.UNAUTHORIZED, + locationIncludes: "err_unauthorized", + }); + }, 120_000); + + it("delegate with PLACE_ORDER may placeOrder (skip if no on-chain delegate)", async (ctx) => { + const accounts = await getAccountsByOwner(client, OWNER); + if (!accounts.length) { + ctx.skip(`No UserAccount for ${OWNER}`); + return; + } + let accountId: string; + try { + accountId = pickE2eAccountIdForOwner(OWNER, accounts); + } catch (e) { + ctx.skip(e instanceof Error ? e.message : String(e)); + return; + } + + const acc = accounts.find((a) => a.accountId === accountId) ?? accounts[0]!; + const delegate = acc.delegates.find( + (d) => (d.permissions & DELEGATE_PERM.PLACE_ORDER) !== 0, + ); + if (!delegate) { + ctx.skip( + "No delegate with PLACE_ORDER on this account — add one on-chain or extend test account setup.", + ); + return; + } + + const prices = await lifecycleOracleUsdOrSkip(client, ctx); + if (!prices) return; + + const usdc = await getAccountBalance(client, accountId, client.config.collaterals.USDC.type); + if (usdc < ORDER_COLLATERAL) { + ctx.skip(`Insufficient USDC in account`); + return; + } + + const tx = await buildPlaceOrderTx(client, { + accountId, + base: "BTC", + isLong: true, + collateralAmount: ORDER_COLLATERAL, + size: ORDER_SIZE, + triggerPrice: 55_000, + approxPrice: prices.BTC, + }); + tx.setSender(delegate.delegateAddress); + const result = await client.simulate(tx); + if (skipSimulateIfOracleTransient(ctx, result)) return; + expect((result as { $kind?: string }).$kind).toBe("Transaction"); + }, 120_000); + + it("owner addDelegate + removeDelegate PTB shape (simulate add only — no chain commit)", async (ctx) => { + const accounts = await getAccountsByOwner(client, OWNER); + if (!accounts.length) { + ctx.skip(`No UserAccount for ${OWNER}`); + return; + } + let accountObjectAddress: string; + try { + accountObjectAddress = pickE2eAccountIdForOwner(OWNER, accounts); + } catch (e) { + ctx.skip(e instanceof Error ? e.message : String(e)); + return; + } + + const { addDelegate, removeDelegate } = await import("../../src/user/account.ts"); + const { Transaction } = await import("@mysten/sui/transactions"); + const tx = new Transaction(); + tx.setSender(OWNER); + tx.setGasBudget(200_000_000); + addDelegate(client, tx, { + accountObjectAddress, + delegate: STRANGER, + permissions: DELEGATE_PERM.PLACE_ORDER | DELEGATE_PERM.CANCEL_ORDER, + }); + const r1 = await client.simulate(tx); + if (skipSimulateIfOracleTransient(ctx, r1)) return; + expect((r1 as { $kind?: string }).$kind).toBe("Transaction"); + + const tx2 = new Transaction(); + tx2.setSender(OWNER); + tx2.setGasBudget(200_000_000); + removeDelegate(client, tx2, { + accountObjectAddress, + delegate: STRANGER, + }); + const r2 = await client.simulate(tx2); + if (skipSimulateIfOracleTransient(ctx, r2)) return; + expect((r2 as { $kind?: string }).$kind).toBe("Transaction"); + }, 120_000); +}); diff --git a/test/simulate/delegate-permission-matrix-simulate.test.ts b/test/simulate/delegate-permission-matrix-simulate.test.ts new file mode 100644 index 0000000..d3447ca --- /dev/null +++ b/test/simulate/delegate-permission-matrix-simulate.test.ts @@ -0,0 +1,83 @@ +/** + * Permission bitmask consistency: fixture rows match `DELEGATE_PERM` (same as Move `user_account`). + * Trading simulate: wrong sender → `err_unauthorized` (800) for a representative `placeOrder` call. + */ +import { buildPlaceOrderTx, getAccountsByOwner } from "@waterx/perp-sdk"; +import { describe, expect, it } from "vitest"; + +import matrix from "../fixtures/delegates/permission-matrix.json"; +import { DELEGATE_PERM } from "../helpers/delegate-perms.ts"; +import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; +import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; +import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; +import { assertSimulateMoveAbort, skipSimulateIfOracleTransient } from "../helpers/simulate-assertions.ts"; +import { client } from "../helpers/testnet.ts"; +import { WATERX_PERP_ABORT } from "../helpers/waterx-perp-error-codes.ts"; +const STRANGER = + "0x3333333333333333333333333333333333333333333333333333333333333333" as const; + +describe("delegate permission matrix", () => { + it("fixture bits match DELEGATE_PERM constants", () => { + const map: Record = { + OPEN_POSITION: DELEGATE_PERM.OPEN_POSITION, + CLOSE_POSITION: DELEGATE_PERM.CLOSE_POSITION, + PLACE_ORDER: DELEGATE_PERM.PLACE_ORDER, + CANCEL_ORDER: DELEGATE_PERM.CANCEL_ORDER, + DEPOSIT_COLLATERAL: DELEGATE_PERM.DEPOSIT_COLLATERAL, + WITHDRAW_COLLATERAL: DELEGATE_PERM.WITHDRAW_COLLATERAL, + DEPOSIT: DELEGATE_PERM.DEPOSIT, + WITHDRAW: DELEGATE_PERM.WITHDRAW, + TRANSFER: DELEGATE_PERM.TRANSFER, + MINT_WLP: DELEGATE_PERM.MINT_WLP, + REDEEM_WLP: DELEGATE_PERM.REDEEM_WLP, + MANAGE_DELEGATES: DELEGATE_PERM.MANAGE_DELEGATES, + }; + for (const row of matrix.entries) { + expect(map[row.name], row.name).toBe(row.bit); + } + }); +}); + +describe("delegate permission matrix (simulate) — unauthorized sender", () => { + it("placeOrder from non-owner non-delegate aborts 800", async (ctx) => { + const accounts = await getAccountsByOwner(client, OWNER); + if (!accounts.length) { + ctx.skip(`No UserAccount for ${OWNER}`); + return; + } + let accountId: string; + try { + accountId = pickE2eAccountIdForOwner(OWNER, accounts); + } catch (e) { + ctx.skip(e instanceof Error ? e.message : String(e)); + return; + } + + const prices = await lifecycleOracleUsdOrSkip(client, ctx); + if (!prices) return; + + const { getAccountBalance } = await import("@waterx/perp-sdk"); + const usdc = await getAccountBalance(client, accountId, client.config.collaterals.USDC.type); + if (usdc < 10_000_000n) { + ctx.skip("Insufficient USDC"); + return; + } + + const tx = await buildPlaceOrderTx(client, { + accountId, + base: "BTC", + isLong: true, + collateralAmount: 10_000_000n, + size: 2000n, + triggerPrice: 50_000, + approxPrice: prices.BTC, + }); + tx.setSender(STRANGER); + const result = await client.simulate(tx); + if (skipSimulateIfOracleTransient(ctx, result)) return; + assertSimulateMoveAbort(result, { + abortCode: WATERX_PERP_ABORT.UNAUTHORIZED, + locationIncludes: "err_unauthorized", + }); + }, 120_000); +}); diff --git a/test/simulate/prd-product-coverage.test.ts b/test/simulate/prd-product-coverage.test.ts index 9b2a69a..654186b 100644 --- a/test/simulate/prd-product-coverage.test.ts +++ b/test/simulate/prd-product-coverage.test.ts @@ -31,6 +31,7 @@ import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../helpers/lifecycle-test-markets.ts"; import { fetchSimulatedUsdPricesForBases } from "../helpers/oracle-simulate-multi-asset.ts"; +import { simulatePlaceCancelSinglePtbWithRetries } from "../helpers/place-cancel-probe.ts"; import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { @@ -448,43 +449,47 @@ describe("PRD §3.4 — TC-ORDER-004: cancel pending limit (simulate)", () => { return; } - const market = client.getMarketEntry("BTC"); - const summary = await getMarketSummary(client, market.marketId, market.baseType); - const orderId = Number(summary.nextOrderId); - const triggerPriceKey = 55_000; - - const tx = new Transaction(); - tx.setSender(OWNER); - tx.setGasBudget(320_000_000); - - await buildPlaceOrderTx(client, { - accountId, + const triggerPriceUsd = 55_000; + const outcome = await simulatePlaceCancelSinglePtbWithRetries(client, { base: "BTC", - isLong: true, - collateralAmount: ORDER_COLLATERAL, - size: ORDER_SIZE, - triggerPrice: triggerPriceKey, - tx, - updatePythPrice: true, + triggerPriceUsd, + gasBudget: 320_000_000, + setSender: (tx) => tx.setSender(OWNER), + build: async ({ tx, orderId, triggerPriceKey }) => { + await buildPlaceOrderTx(client, { + accountId, + base: "BTC", + isLong: true, + collateralAmount: ORDER_COLLATERAL, + size: ORDER_SIZE, + triggerPrice: triggerPriceUsd, + tx, + updatePythPrice: true, + }); + await buildCancelOrderTx(client, { + accountId, + base: "BTC", + orderId: Number(orderId), + triggerPriceKey, + tx, + updatePythPrice: true, + }); + }, }); - await buildCancelOrderTx(client, { - accountId, - base: "BTC", - orderId, - triggerPriceKey, - tx, - updatePythPrice: true, - }); - try { - await trySimulate(ctx, tx, 20); - } catch (e) { - const msg = e instanceof Error ? e.message : String(e); - if (msg.includes("err_order_not_found") || msg.includes("300")) { - ctx.skip("orderId prediction stale on shared testnet"); + + if (!outcome.ok) { + if (skipSimulateIfOracleTransient(ctx, outcome.lastResult)) return; + const meta = parseSimulateFailure(outcome.lastResult); + if (meta?.abortCode === "300") { + ctx.skip( + "testnet orderId raced even after retries — TODO(contracts#cancel-by-key)", + ); return; } - throw e; + assertSimulateSuccess(outcome.lastResult, 20, { transaction: outcome.lastTx }); + return; } + assertSimulateSuccess(outcome.result, 20, { transaction: outcome.tx }); }, 120_000); }); diff --git a/test/simulate/tx-builders-simulate.test.ts b/test/simulate/tx-builders-simulate.test.ts index 5eee1f4..3350596 100644 --- a/test/simulate/tx-builders-simulate.test.ts +++ b/test/simulate/tx-builders-simulate.test.ts @@ -8,12 +8,12 @@ import { getAccountBalance, getAccountCoins, getAccountsByOwner, - getMarketSummary, TESTNET_TYPES, } from "@waterx/perp-sdk"; import { describe, it } from "vitest"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; +import { simulatePlaceCancelSinglePtbWithRetries } from "../helpers/place-cancel-probe.ts"; import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { @@ -26,6 +26,7 @@ import { import { scratchTradingScenarios } from "../helpers/scratch-trading-scenarios.ts"; import { assertSimulateSuccess, + parseSimulateFailure, skipSimulateIfOracleTransient, } from "../helpers/simulate-assertions.ts"; import { clientTxBuildersSimulate as client } from "../helpers/testnet.ts"; @@ -172,44 +173,47 @@ describe("tx-builders stateful ops (simulate)", () => { return; } - const market = client.getMarketEntry("BTC"); - const summary = await getMarketSummary(client, market.marketId, market.baseType); - const orderId = Number(summary.nextOrderId); - - const { Transaction } = await import("@mysten/sui/transactions"); - const tx = new Transaction(); - tx.setSender(OWNER); - tx.setGasBudget(300_000_000); - - await buildPlaceOrderTx(client, { - accountId, + const outcome = await simulatePlaceCancelSinglePtbWithRetries(client, { base: "BTC", - isLong: true, - collateralAmount: ORDER_COLLATERAL, - size: ORDER_SIZE, - triggerPrice: ORDER_TRIGGER_PRICE_USD, - updatePythPrice: true, - tx, - }); - await buildCancelOrderTx(client, { - accountId, - base: "BTC", - orderId, - triggerPriceKey: 0, - orderTypeTag: 255, - updatePythPrice: true, - tx, + triggerPriceUsd: ORDER_TRIGGER_PRICE_USD, + gasBudget: 300_000_000, + setSender: (tx) => tx.setSender(OWNER), + build: async ({ tx, orderId, triggerPriceKey }) => { + await buildPlaceOrderTx(client, { + accountId, + base: "BTC", + isLong: true, + collateralAmount: ORDER_COLLATERAL, + size: ORDER_SIZE, + triggerPrice: ORDER_TRIGGER_PRICE_USD, + updatePythPrice: true, + tx, + }); + await buildCancelOrderTx(client, { + accountId, + base: "BTC", + orderId: Number(orderId), + triggerPriceKey, + orderTypeTag: 255, + updatePythPrice: true, + tx, + }); + }, }); - try { - await trySimulate(ctx, tx, 20); - } catch (e) { - const msg = e instanceof Error ? e.message : String(e); - if (msg.includes("err_order_not_found") || msg.includes("300")) { - ctx.skip("orderId prediction stale on shared testnet"); + + if (!outcome.ok) { + if (skipSimulateIfOracleTransient(ctx, outcome.lastResult)) return; + const meta = parseSimulateFailure(outcome.lastResult); + if (meta?.abortCode === "300") { + ctx.skip( + "testnet orderId raced even after retries — TODO(contracts#cancel-by-key)", + ); return; } - throw e; + assertSimulateSuccess(outcome.lastResult, 20, { transaction: outcome.lastTx }); + return; } + assertSimulateSuccess(outcome.result, 20, { transaction: outcome.tx }); }, 120_000); it("buildTransferToAccountTx (coinObjectId path) + buildReceiveCoinTx", async (ctx) => { diff --git a/test/simulate/wlp-simulate.test.ts b/test/simulate/wlp-simulate.test.ts index 3f2d0d0..e7e621c 100644 --- a/test/simulate/wlp-simulate.test.ts +++ b/test/simulate/wlp-simulate.test.ts @@ -10,11 +10,16 @@ import { describe, expect, it } from "vitest"; import type { CollateralAsset } from "../../src/constants.ts"; import { e2eWalletCollateralMinForMintSimulate } from "../helpers/e2e-wlp-readiness.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; -import { assertSimulateSuccess } from "../helpers/simulate-assertions.ts"; +import { + assertSimulateSuccess, + parseSimulateFailure, +} from "../helpers/simulate-assertions.ts"; import { client } from "../helpers/testnet.ts"; /** `waterx_perp::error::ERedeemNotReady` — settle before 24h (`err_redeem_not_ready`). */ const ERR_REDEEM_NOT_READY_ABORT = 407; +/** `waterx_perp::error::ENoRedeemRequest` — candidate request was already settled/cancelled. */ +const ERR_NO_REDEEM_REQUEST_ABORT = 408; async function getNextRedeemId(): Promise { const cfg = client.config; @@ -99,11 +104,15 @@ describe("WLP SDK builders (simulate) — per collateral", () => { describe("buildSettleRedeemWlpTx (state-dependent simulate)", () => { /** * Chain-dependent: settle only succeeds when the target redeem request is ≥ 24h old. - * Until then, simulate must abort with MoveAbort code 407 (`err_redeem_not_ready`); - * that counts as an expected pass (no stderr dump). + * Valid simulate outcomes on shared testnet: + * - success ($kind Transaction) → the request had reached its 24h cooldown. + * - MoveAbort 407 (`err_redeem_not_ready`) → request pending but within 24h cooldown. + * - MoveAbort 408 (`err_no_redeem_request`) → candidate (= `nextRedeemId - 1`) was already + * settled or cancelled on-chain; no pending redeem to probe cooldown against. Skip with a + * clear note rather than failing the suite — this is testnet state, not an SDK regression. */ for (const collateral of collateralAssets) { - it(`settle — ${collateral} (407 or success)`, async (ctx) => { + it(`settle — ${collateral} (407 or success; 408 ⇒ skip)`, async (ctx) => { const nextRedeemId = await getNextRedeemId(); if (nextRedeemId <= 0n) { ctx.skip( @@ -117,6 +126,17 @@ describe("buildSettleRedeemWlpTx (state-dependent simulate)", () => { const tx = await buildSettleRedeemWlpTx(client, { requestId: candidateId, collateral }); tx.setSender(OWNER); const result = await client.simulate(tx); + + const meta = parseSimulateFailure(result); + const abortCode = meta?.abortCode != null ? Number(meta.abortCode) : null; + if (abortCode === ERR_NO_REDEEM_REQUEST_ABORT) { + ctx.skip( + `redeem request ${candidateId} already settled or cancelled on testnet — ` + + "no pending redeem available to probe 24h cooldown (not an SDK regression).", + ); + return; + } + assertSimulateSuccess(result, 4, { transaction: tx, allowFailedTransactionMoveAbort: { diff --git a/test/unit/event-parsing.test.ts b/test/unit/event-parsing.test.ts new file mode 100644 index 0000000..30139f8 --- /dev/null +++ b/test/unit/event-parsing.test.ts @@ -0,0 +1,68 @@ +import { describe, expect, it } from "vitest"; + +import { + payloadFromSimulateEventRecord, + readPositionOpenedFields, +} from "../helpers/move-event-payload.ts"; + +describe("move-event-payload — PositionOpened parsing", () => { + it("parses flat RPC-style snake_case + Float { value }", () => { + const ev = { + type: "0xpkg::events::PositionOpened", + parsedJson: { + account_object_address: "0x01", + market_id: "0x02", + position_id: "1", + is_long: true, + size_amount: "2000", + collateral_amount: "10000000", + leverage_bps: "100000", + entry_price: { value: "65000000000000" }, + open_fee_amount: "42", + timestamp: "1", + sender: "0x03", + }, + }; + const p = payloadFromSimulateEventRecord(ev); + expect(p && typeof p === "object").toBe(true); + const f = readPositionOpenedFields(p as Record); + expect(f).not.toBeNull(); + expect(f!.sizeAmount).toBe(2000n); + expect(f!.openFeeAmount).toBe(42n); + expect(f!.isLong).toBe(true); + expect(f!.entryPriceScaled).toBe(65_000_000_000_000n); + }); + + it("parses nested fields wrapper + is_long as 0/1 + camelCase keys", () => { + const ev = { + parsed_json: { + fields: { + sizeAmount: "2000", + openFeeAmount: "42", + isLong: 1, + entryPrice: { fields: { value: "65000000000000" } }, + }, + }, + }; + const p = payloadFromSimulateEventRecord(ev); + const f = readPositionOpenedFields(p as Record); + expect(f).not.toBeNull(); + expect(f!.isLong).toBe(true); + expect(f!.entryPriceScaled).toBe(65_000_000_000_000n); + }); + + it("parses stringified JSON payload", () => { + const ev = { + json: JSON.stringify({ + size_amount: "2000", + open_fee_amount: "42", + is_long: false, + entry_price: { value: "1000000000" }, + }), + }; + const p = payloadFromSimulateEventRecord(ev); + const f = readPositionOpenedFields(p as Record); + expect(f).not.toBeNull(); + expect(f!.isLong).toBe(false); + }); +}); diff --git a/test/unit/sdk-input-type-contracts.test.ts b/test/unit/sdk-input-type-contracts.test.ts new file mode 100644 index 0000000..a9fb243 --- /dev/null +++ b/test/unit/sdk-input-type-contracts.test.ts @@ -0,0 +1,27 @@ +/** + * Desired contracts for u64 / numeric inputs to high-level builders (`sdk#u64-normalizer`). + * Today many paths use `BigInt(x)` directly — these tests document JavaScript edge cases; + * when the SDK adds a shared normalizer, extend these to assert on builder behavior. + */ +import { describe, expect, it } from "vitest"; + +describe("sdk#u64-normalizer — JS primitives vs u64", () => { + it("BigInt rejects non-integer Number (e.g. fractional triggerPriceKey)", () => { + expect(() => BigInt(60_000.2)).toThrow(RangeError); + }); + + it("BigInt accepts decimal string within safe range", () => { + expect(BigInt("123456789012345678")).toBe(123456789012345678n); + }); + + it("2^64 does not fit u64 — value is > UINT64_MAX", () => { + const u64Max = (1n << 64n) - 1n; + const tooBig = 1n << 64n; + expect(tooBig > u64Max).toBe(true); + }); + + it("NaN / Infinity are not valid u64 sources", () => { + expect(Number.isFinite(Number.NaN)).toBe(false); + expect(Number.isFinite(Number.POSITIVE_INFINITY)).toBe(false); + }); +}); diff --git a/test/unit/sdk-size-formula.test.ts b/test/unit/sdk-size-formula.test.ts new file mode 100644 index 0000000..4763e62 --- /dev/null +++ b/test/unit/sdk-size-formula.test.ts @@ -0,0 +1,33 @@ +/** + * Pins `sdk#size-formula`: `src/tx-builders.ts` `resolveSizeFromParams` uses raw collateral as USD + * and ignores `size_decimal` when `approxPrice` + `leverage` are set. + * + * When the SDK is fixed to match {@link explicitSizeRawForTargetLeverageUsd}, flip the assertion + * to `expect(a).toBe(b)` and rename the test. + */ +import { describe, expect, it } from "vitest"; + +import { + explicitSizeRawForTargetLeverageUsd, + replicateSdkApproxPriceSizeRaw, +} from "../helpers/compute-leverage-size.ts"; + +describe("sdk#size-formula — replicateSdk vs decimal-aware explicit size", () => { + it("replicateSdkApproxPriceSizeRaw still drifts from explicitSizeRawForTargetLeverageUsd (BTC-like)", () => { + const collateral = 10_000_000n; + const leverage = 1000; + const approx = 70_000; + const sdkLike = replicateSdkApproxPriceSizeRaw({ + collateralAmount: collateral, + leverage, + approxPrice: approx, + }); + const canonical = explicitSizeRawForTargetLeverageUsd({ + collateralRawUsdc6: collateral, + leverageTimes: leverage, + usdPerBaseToken: approx, + sizeDecimal: 9, + }); + expect(sdkLike).not.toBe(canonical); + }); +}); From bdfe159e574e4b4d07eb733c5a7fe4f3fbbcccd1 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Fri, 17 Apr 2026 18:46:56 +0800 Subject: [PATCH 2/9] refactor(test): unify trading fixtures and clean helpers/scripts - Add test/fixtures/trading/trading-config.json as single source for lifecycle rows, persistent perp, enabled bases, thresholds, and wallet mins; remove split lifecycle-markets.json and persistent-perp.json. - Delete dead helpers (trading-fixture-harness, lifecycle-oracle-usd-prices, wlp-pool-price-refresh); extract SCRATCH_EXPECT to scratch-scenario-steps.ts. - Rename execIntegrationOrSkipOracle in integration setup and scratch runner; align testnet/oracle comments with Pyth-only v2; trim compute-leverage-size. - Remove scripts/debug-oracle-aggregates.ts and setup-supra-oracle.sh; mark clear-supra-weights.sh as legacy migration; fix setup-pyth-identifiers.sh base types to market_symbol::*_USD. - Rewrite scripts/README.md; update MIGRATION.md, test docs, and preflight copy. Made-with: Cursor --- MIGRATION.md | 4 +- scripts/README.md | 112 ++++--- scripts/clear-supra-weights.sh | 3 + scripts/debug-oracle-aggregates.ts | 112 ------- scripts/e2e-preflight.ts | 2 +- scripts/setup-pyth-identifiers.sh | 15 +- scripts/setup-supra-oracle.sh | 85 ----- scripts/test-cancel-redeem-wlp.ts | 30 +- test/README.md | 4 +- test/fixtures/trading/lifecycle-markets.json | 197 ------------ test/fixtures/trading/persistent-perp.json | 43 --- test/fixtures/trading/trading-config.json | 292 ++++++++++++++++++ test/helpers/compute-leverage-size.ts | 8 +- test/helpers/e2e-active-bases.ts | 36 +-- test/helpers/e2e-persistent-state.ts | 73 +---- test/helpers/e2e-wlp-readiness.ts | 22 +- test/helpers/lifecycle-oracle-usd-prices.ts | 39 --- test/helpers/lifecycle-test-markets.ts | 83 ++--- test/helpers/load-trading-fixtures.ts | 149 ++++++++- test/helpers/move-event-payload.ts | 20 +- test/helpers/oracle-simulate-multi-asset.ts | 4 +- test/helpers/place-cancel-probe.ts | 12 +- ...un-scratch-trading-scenario-integration.ts | 9 +- .../run-scratch-trading-scenario-simulate.ts | 3 +- test/helpers/scratch-scenario-steps.ts | 42 +++ test/helpers/scratch-trading-scenarios.ts | 31 +- test/helpers/simulate-assertions.ts | 1 + test/helpers/testnet.ts | 4 +- test/helpers/trading-fixture-harness.ts | 27 -- test/helpers/wlp-pool-price-refresh.ts | 66 ---- test/integration/setup.ts | 14 +- .../user/trader-close-position.test.ts | 4 +- .../user/trader-e2e-persistent-state.test.ts | 4 +- .../user/trader-position-lifecycle.test.ts | 6 +- test/scripts/regen-trading-fixtures.ts | 4 +- .../collateral-order-simulate.test.ts | 4 +- .../delegate-lifecycle-simulate.test.ts | 12 +- ...elegate-permission-matrix-simulate.test.ts | 9 +- test/simulate/prd-product-coverage.test.ts | 4 +- test/simulate/tx-builders-simulate.test.ts | 4 +- test/simulate/wlp-simulate.test.ts | 5 +- 41 files changed, 711 insertions(+), 887 deletions(-) delete mode 100644 scripts/debug-oracle-aggregates.ts delete mode 100755 scripts/setup-supra-oracle.sh delete mode 100644 test/fixtures/trading/lifecycle-markets.json delete mode 100644 test/fixtures/trading/persistent-perp.json create mode 100644 test/fixtures/trading/trading-config.json delete mode 100644 test/helpers/lifecycle-oracle-usd-prices.ts create mode 100644 test/helpers/scratch-scenario-steps.ts delete mode 100644 test/helpers/trading-fixture-harness.ts delete mode 100644 test/helpers/wlp-pool-price-refresh.ts diff --git a/MIGRATION.md b/MIGRATION.md index 1aa8763..1611c78 100644 --- a/MIGRATION.md +++ b/MIGRATION.md @@ -375,12 +375,12 @@ Off-chain event consumers MUST update parsers accordingly. | Purpose | v1 | v2 | |---|---|---| | Create all markets | `create-markets.ts` (plus manual Pyth setup) | `setup-markets.sh` (one PTB per market: aggregator + Pyth weight + share + Pyth identifier + create_market + share) | -| Wire Supra + Pyth per-token | `setup-oracle.ts`, `setup-pyth-identifiers.sh`, `setup-supra-oracle.sh` | Folded into `setup-markets.sh` (Pyth-only) | +| Wire Pyth per-token | `setup-oracle.ts`, `setup-pyth-identifiers.sh`, legacy `setup-supra-oracle.sh` | `setup-markets.sh` + `setup-pyth-identifiers.sh` (Pyth-only); Supra setup script removed | | Clear legacy Supra weights | — | `clear-supra-weights.sh` | | Register WLP deposit tokens | — | `setup-wlp-tokens.sh` (USDC + USDSUI via `lp_pool::add_token`) | | Refresh Pyth prices (ops) | (manual) | `update-pyth-prices.ts` | -`setup-oracle.ts`, `setup-pyth-identifiers.sh`, `setup-supra-oracle.sh` were deleted. +`setup-oracle.ts` and `setup-supra-oracle.sh` were removed; `setup-pyth-identifiers.sh` remains for identifier updates. --- diff --git a/scripts/README.md b/scripts/README.md index 74d8f4c..f1e842f 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -1,57 +1,87 @@ -# Admin Setup Scripts +# Scripts -Scripts for deploying and configuring the WaterX Perp protocol. All require `AdminCap` ownership. +Operational and admin helpers for WaterX perp on Sui testnet. **v2 is Pyth-only** on the SDK path; legacy Supra cleanup is a one-shot shell script only. ## Prerequisites -```bash -export ADMIN_SECRET_KEY= -``` +- **Admin / listing**: `sui client active-address` must own `AdminCap` and/or `ListingCap` where noted. +- **TypeScript**: run via `pnpm exec tsx scripts/.ts` or the **npm script** aliases in root `package.json`. +- **Env**: many TS scripts use `ADMIN_SECRET_KEY` (base64 ed25519 secret) or integration vars — run without secrets to see dry-run behavior where supported. -Run without the env var to see a dry-run preview. +## npm script aliases (root `package.json`) -## Deployment Order +| pnpm script | Script file | +| ----------- | ----------- | +| `codegen` | runs `fix-generated-imports.ts` after codegen | +| `e2e:preflight` | `e2e-preflight.ts` | +| `e2e:prepare` | `e2e-prepare.ts` | +| `e2e:bootstrap-positions` | `bootstrap-e2e-lifecycle-positions.ts` | +| `diagnose:positions` | `diagnose-integration-positions.ts` | +| `oracle:aggregates` | `print-oracle-aggregates.ts` | +| `query-output` | `query-output.ts` | +| `create-testnet-account` | `create-testnet-user-account.ts` | +| `rewarder:smoke` | `reward-distributor-smoke.ts` | +| `close-all-btc` | `close-all-my-btc-positions.ts` | -After publishing the Move packages, run these scripts in order: +CI also chains `e2e-preflight.ts` before simulate tests (`test:ci:e2e`). -```bash -# 1. Add USDC (and other tokens) to the WLP pool -npx tsx scripts/add-token-pool.ts +## By category -# 2. Create all trading markets (BTC, ETH, SOL, SUI, DEEP, WAL) -npx tsx scripts/create-markets.ts -# → Copy the created Market object IDs into TESTNET_MARKETS in constants.ts +### Admin / on-chain setup (bash + TS) -# 3. Set up Pyth + Supra oracle feeds (identifiers, pair IDs, aggregator weights) -ADMIN_SECRET_KEY= npx tsx scripts/setup-oracle.ts -# Or Supra-only via CLI (no secret key needed): -./scripts/setup-supra-oracle.sh +| File | Purpose | +| ---- | ------- | +| `setup-markets.sh` | Per-market PTB: aggregator + Pyth rule weight + `pyth_rule::set_identifier` + `create_market`. | +| `setup-wlp-tokens.sh` | `lp_pool::add_token` for USDC / USDSUI. | +| `setup-pyth-identifiers.sh` | `pyth_rule::set_identifier` for base + collateral types (`market_symbol::*_USD`). | +| `setup-pyth-tolerance.sh` | `pyth_rule::set_tolerance_sec` per token. | +| `set-min-coll-value.sh` | `update_market_config` min collateral value across markets. | +| `create-markets.ts` | TS helper to create markets (params from `market-params.ts`). | +| `market-params.ts` | Shared market creation params (imported by tests + `create-markets.ts`). | +| `setup-keepers.ts` | Register keepers on `GlobalConfig`. | -# 4. Add keeper addresses for order matching / liquidation / funding -npx tsx scripts/setup-keepers.ts +### E2E / integration ergonomics -# 5. (Optional) Add USDSUI token pool + rebalance weights -./scripts/add-usdsui-pool.sh -``` +| File | Purpose | +| ---- | ------- | +| `e2e-preflight.ts` | Wallet / account / positions / oracle simulate gates before `test:e2e`. | +| `e2e-prepare.ts` | TTO split, cooldown, collateral / WLP top-up (needs integration key). | +| `bootstrap-e2e-lifecycle-positions.ts` | Open small persistent perp slots per `test/fixtures/trading/trading-config.json`. | +| `diagnose-integration-positions.ts` | Inspect reference account positions / refresh local fixed-position hints. | -## Scripts +### Oracle ops -| Script | Description | -| ----------------------- | --------------------------------------------------------------------------------------- | -| `create-markets.ts` | Create `Market` for all assets | -| `add-token-pool.ts` | Add collateral token (USDC) to WLP pool | -| `setup-oracle.ts` | Configure Pyth identifiers + Supra pair IDs + SupraRule aggregator weights (all-in-one) | -| `setup-supra-oracle.sh` | Supra-only setup via `sui client call` (no secret key, uses active CLI address) | -| `setup-keepers.ts` | Authorize keeper addresses in GlobalConfig | -| `market-params.ts` | Market creation parameters (imported by create-markets) | -| `add-usdsui-pool.sh` | Add USDSUI to WLP pool + rebalance USDC weight to 50/50 | +| File | Purpose | +| ---- | ------- | +| `print-oracle-aggregates.ts` | Hermes + simulate oracle PTB; `--format pretty` or `raw`. | +| `update-pyth-prices.ts` | Push Hermes updates to on-chain Pyth price objects. | -## Adding a New Market +### WLP / rewarder / accounts -1. Add the asset to `BaseAsset` type in `src/constants.ts` -2. Add creation params to `scripts/market-params.ts` -3. Add base token type to `BASE_TYPES` in `scripts/create-markets.ts` -4. Add token feed to `TOKEN_FEEDS` in `scripts/setup-oracle.ts` -5. Run `create-markets.ts`, `setup-oracle.ts`, and `setup-supra-oracle.sh` -6. Add the new market entry to `TESTNET_MARKETS` in `src/constants.ts` -7. Add Supra pair ID to `SUPRA_PAIR_IDS` in `src/constants.ts` (if available) +| File | Purpose | +| ---- | ------- | +| `test-cancel-redeem-wlp.ts` | `cancel_redeem` scenarios (simulate; optional `--execute`). | +| `reward-distributor-smoke.ts` | Stake / claim / redeem smoke on reward distributor. | +| `create-testnet-user-account.ts` | Create `UserAccount` for integration testing. | +| `close-all-my-btc-positions.ts` | Close all BTC positions for configured account (`--dry-run` supported). | + +### Dev utilities + +| File | Purpose | +| ---- | ------- | +| `fix-generated-imports.ts` | Post-`sui-ts-codegen` import normalization (used by `pnpm codegen`). | +| `query-output.ts` | Dump SDK query results to `query-output/*.json`. | + +### Legacy migration + +| File | Purpose | +| ---- | ------- | +| `clear-supra-weights.sh` | **One-shot**: zero `SupraRule` weight on USDC/USDSUI aggregators after v2 migration. Remove when no longer needed on your network. | + +## Adding a new market (high level) + +1. Extend `BaseAsset` / `TESTNET_MARKETS` in `src/constants.ts`. +2. Add params in `market-params.ts` and run `setup-markets.sh` (or `create-markets.ts`) plus Pyth identifier / tolerance scripts. +3. Update **`test/fixtures/trading/trading-config.json`** for e2e tables (`lifecycleMarkets`, `enabledE2eBases`, `persistentPerp` as needed). + +See root [CLAUDE.md](../CLAUDE.md) for protocol details. diff --git a/scripts/clear-supra-weights.sh b/scripts/clear-supra-weights.sh index 28ceeb2..fe181e4 100755 --- a/scripts/clear-supra-weights.sh +++ b/scripts/clear-supra-weights.sh @@ -1,6 +1,9 @@ #!/usr/bin/env bash set -euo pipefail +# Legacy migration (one-shot): run after upgrading testnet aggregators to Pyth-only v2. +# Once all collateral `PriceAggregator`s have no SupraRule weight on-chain, delete this script. +# # Drop the legacy SupraRule weight from the USDC + USDSUI collateral PriceAggregators # so v2 (Pyth-only) `aggregate()` calls stop failing with err_missing_price_source (201). # diff --git a/scripts/debug-oracle-aggregates.ts b/scripts/debug-oracle-aggregates.ts deleted file mode 100644 index fbb7939..0000000 --- a/scripts/debug-oracle-aggregates.ts +++ /dev/null @@ -1,112 +0,0 @@ -import { Transaction } from "@mysten/sui/transactions"; -import { buildOracleFeed, WaterXClient } from "@waterx/perp-sdk"; - -type TokenFeed = { - label: string; - tokenType: string; - aggregatorId: string; - priceInfoId: string; -}; - -function allTokenFeeds(client: WaterXClient): TokenFeed[] { - const marketFeeds = Object.entries(client.config.markets).map(([base, m]) => ({ - label: `MARKET:${base}`, - tokenType: m.baseType, - aggregatorId: m.aggregatorId, - priceInfoId: m.priceInfoId, - })); - const collateralFeeds = Object.entries(client.config.collaterals).map(([asset, c]) => ({ - label: `COLLATERAL:${asset}`, - tokenType: c.type, - aggregatorId: c.aggregatorId, - priceInfoId: c.priceInfoId, - })); - return [...marketFeeds, ...collateralFeeds]; -} - -function short(v: string, n = 10): string { - return `${v.slice(0, n)}...${v.slice(-6)}`; -} - -function printAggregatedEvent(ev: any) { - const typeText = - ev?.type ?? ev?.eventType ?? ev?.moveEventType ?? ev?.event?.type ?? "(unknown-event-type)"; - const parsed = - ev?.parsedJson ?? - ev?.parsed_json ?? - ev?.event?.parsedJson ?? - ev?.event?.parsed_json ?? - ev?.json ?? - null; - if (!parsed) { - console.log(`- ${typeText}: no parsed payload`); - return; - } - - const sources = (parsed.sources ?? []) as string[]; - const prices = (parsed.prices ?? []) as Array; - const weights = (parsed.weights ?? []) as Array; - const result = parsed.result; - const threshold = parsed.current_threshold ?? parsed.currentThreshold; - - console.log(`- ${typeText}`); - console.log(` threshold=${String(threshold)} result=${String(result)}`); - for (let i = 0; i < sources.length; i++) { - console.log( - ` source=${sources[i]} weight=${String(weights[i] ?? "-")} price=${String(prices[i] ?? "-")}`, - ); - } -} - -async function runOne(client: WaterXClient, f: TokenFeed) { - const tx = new Transaction(); - tx.setSender("0x1111111111111111111111111111111111111111111111111111111111111111"); - tx.setGasBudget(250_000_000); - buildOracleFeed(client, tx, f.tokenType, f.aggregatorId, f.priceInfoId); - - const result: any = await client.grpcClient.simulateTransaction({ - transaction: tx, - include: { commandResults: true, effects: true, events: true }, - }); - if (result?.$kind === "FailedTransaction") { - const err = result?.FailedTransaction?.status?.error; - const msg = typeof err === "string" ? err : (err?.message ?? JSON.stringify(err)); - console.log(`\n[${f.label}] FAILED`); - console.log(` token=${f.tokenType}`); - console.log(` aggregator=${f.aggregatorId}`); - console.log(` error=${msg}`); - return; - } - - const events: any[] = result?.Transaction?.events ?? []; - const aggEvents = events.filter((e) => { - const t = String(e?.type ?? e?.eventType ?? e?.moveEventType ?? ""); - return t.includes("bucket_v2_oracle::aggregator::PriceAggregated"); - }); - console.log(`\n[${f.label}] OK`); - console.log(` token=${f.tokenType}`); - console.log(` aggregator=${f.aggregatorId}`); - console.log(` PriceAggregated events=${aggEvents.length}`); - for (const ev of aggEvents) { - printAggregatedEvent(ev); - } -} - -async function main() { - const client = WaterXClient.testnet(); - const feeds = allTokenFeeds(client); - console.log(`checking ${feeds.length} feeds...\n`); - for (const f of feeds) { - console.log(`- ${f.label} token=${short(f.tokenType)} agg=${short(f.aggregatorId)}`); - } - console.log(""); - - for (const f of feeds) { - await runOne(client, f); - } -} - -main().catch((e) => { - console.error(e instanceof Error ? e.message : String(e)); - process.exit(1); -}); diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index fab7d96..b0e1da8 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -330,7 +330,7 @@ export async function runPreflight( kind: "oracle_transient", detail: "oracle feed/aggregate transient failure detected", action: - "Retry `pnpm e2e:preflight` (Hermes/Pyth pull + Supra push feeds); strict CI fails until simulate open succeeds.", + "Retry `pnpm e2e:preflight` after Hermes/Pyth refresh; strict CI fails until simulate open succeeds.", }); } else { rows.push({ diff --git a/scripts/setup-pyth-identifiers.sh b/scripts/setup-pyth-identifiers.sh index c8b4d53..b231d0b 100755 --- a/scripts/setup-pyth-identifiers.sh +++ b/scripts/setup-pyth-identifiers.sh @@ -12,13 +12,14 @@ LISTING_CAP="0xa5d55065e5f4dda8d17213e425176198332ac639dee5b732c1892a4d8cc49854" GAS=200000000 -# ── Token types ───────────────────────────────────────────────────── -BTC_TYPE="0x64158e48941d4c6e868b3ef0dad03ee587d3acafcb928cf139be42f5df8a9c36::waterx_btc::WATERX_BTC" -ETH_TYPE="0x64158e48941d4c6e868b3ef0dad03ee587d3acafcb928cf139be42f5df8a9c36::waterx_eth::WATERX_ETH" -SOL_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_sol::WATERX_SOL" -SUI_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_sui::WATERX_SUI" -DEEP_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_deep::WATERX_DEEP" -WAL_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_wal::WATERX_WAL" +# ── Token types (v2 `market_symbol::_USD` — align with src/constants.ts TESTNET_TYPES) ── +MSYM_PKG="0xd08f5c03e1d5a87d411b39969e5294eb0e5d10560105a747aefa77c0b17facae" +BTC_TYPE="${MSYM_PKG}::market_symbol::BTC_USD" +ETH_TYPE="${MSYM_PKG}::market_symbol::ETH_USD" +SOL_TYPE="${MSYM_PKG}::market_symbol::SOL_USD" +SUI_TYPE="${MSYM_PKG}::market_symbol::SUI_USD" +DEEP_TYPE="${MSYM_PKG}::market_symbol::DEEP_USD" +WAL_TYPE="${MSYM_PKG}::market_symbol::WAL_USD" USDC_TYPE="0x7ccd477e884ec74f960b23a8b34b7d87999e4d7ee0dde738a0c25f46200f201a::mock_usdc::MOCK_USDC" USDSUI_TYPE="0xc0fad30bc21babe3b8b51c6a4c380d27b61a47e34b26968daf20315da0e35016::mock_usdsui::MOCK_USDSUI" diff --git a/scripts/setup-supra-oracle.sh b/scripts/setup-supra-oracle.sh deleted file mode 100755 index a068c3c..0000000 --- a/scripts/setup-supra-oracle.sh +++ /dev/null @@ -1,85 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail - -# Add SupraRule weight=1 to all PriceAggregators (base assets + collaterals). -# Uses `sui client call` — no secret key needed, uses active CLI address. -# -# Usage: ./scripts/setup-supra-oracle.sh - -ORACLE_PKG="0xa00eb6c923368aef9aade69d75b348f53dc2ee344771ce3c3629dee05a0fb88c" -SUPRA_RULE_PKG="0xde280cdb680998d632cca7a1972627854aae9b4acf4cf254fc541395e9471b6d" -LISTING_CAP="0xa5d55065e5f4dda8d17213e425176198332ac639dee5b732c1892a4d8cc49854" -SUPRA_CONFIG="0x10c1b0ce0aba4b6ffbf4ef3047cdd8ebee9f445ad0cb8ed406fa4bba5aaedb62" - -SUPRA_WITNESS="${SUPRA_RULE_PKG}::supra_rule::SupraRule" -WEIGHT=1 -GAS=200000000 - -# ── Token types ───────────────────────────────────────────────────── -BTC_TYPE="0x64158e48941d4c6e868b3ef0dad03ee587d3acafcb928cf139be42f5df8a9c36::waterx_btc::WATERX_BTC" -ETH_TYPE="0x64158e48941d4c6e868b3ef0dad03ee587d3acafcb928cf139be42f5df8a9c36::waterx_eth::WATERX_ETH" -SOL_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_sol::WATERX_SOL" -SUI_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_sui::WATERX_SUI" -DEEP_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_deep::WATERX_DEEP" -WAL_TYPE="0xaa0fe78f01a91b6aaa27b78ad934cd78b3886d33dcabdb06633f481f377e19e4::waterx_wal::WATERX_WAL" -USDC_TYPE="0x7ccd477e884ec74f960b23a8b34b7d87999e4d7ee0dde738a0c25f46200f201a::mock_usdc::MOCK_USDC" -USDSUI_TYPE="0xc0fad30bc21babe3b8b51c6a4c380d27b61a47e34b26968daf20315da0e35016::mock_usdsui::MOCK_USDSUI" - -# ── Aggregator IDs ────────────────────────────────────────────────── -BTC_AGG="0x49b4ef44726620f8bc60fbaf721e3b5f84a7ddc2a8f7a4e55b396dff5cb77528" -ETH_AGG="0x7a54a6c68947fe1ed6c59ffe37fb03960863261993b2c556041e7944ae35c33c" -SOL_AGG="0xf9947f871cc67cb734a8a6b5f29368cce4753a93ba4c0d96516277475fa0e141" -SUI_AGG="0x6198facaceec8333930fa99108d809a43d2f31b3231424a082f6cbef227b7218" -DEEP_AGG="0xce7192008606def9cce51a7ab959170b4901eac570464e71f8494924120f548d" -WAL_AGG="0x7ef03c33d79898f805ec0e0c7082604c6dbf805f2bae1bfe77f20952f011628b" -USDC_AGG="0x6f9cd2133e7073376ac4de314873e625a8606bddb4daa33affd0a08933b8b2a7" -USDSUI_AGG="0x861d7fe0e5130ca818481f32eff768be1e097c897aa0c35ed9ae10d3f0553179" - -# ── Supra pair IDs ────────────────────────────────────────────────── -# BTC=18, ETH=19, USDC=89, SUI=90, DEEP=491, WAL=534 - -# ── 1. Set Supra pair IDs (keyed by aggregator ID) ────────────────── -echo "=== Setting Supra pair IDs ===" - -# Format: TYPE_VAR:AGG_VAR:PAIR_ID -for triple in \ - "BTC_TYPE:BTC_AGG:18" "ETH_TYPE:ETH_AGG:19" "SUI_TYPE:SUI_AGG:90" \ - "DEEP_TYPE:DEEP_AGG:491" "WAL_TYPE:WAL_AGG:534" "USDC_TYPE:USDC_AGG:89" "USDSUI_TYPE:USDSUI_AGG:89"; do TYPE_VAR="${triple%%:*}" - REST="${triple#*:}" - AGG_VAR="${REST%%:*}" - PAIR_ID="${REST##*:}" - TOKEN_TYPE="${!TYPE_VAR}" - AGG_ID="${!AGG_VAR}" - LABEL="${TYPE_VAR%%_TYPE}" - echo " $LABEL (pair $PAIR_ID)..." - sui client call \ - --package "$SUPRA_RULE_PKG" --module supra_rule --function set_pair_id \ - --type-args "$TOKEN_TYPE" \ - --args "$SUPRA_CONFIG" "$AGG_ID" "$LISTING_CAP" "$PAIR_ID" \ - --gas-budget $GAS - sleep 1 -done - -# ── 2. Set SupraRule weight on all aggregators ────────────────────── -echo "" -echo "=== Setting SupraRule weight=$WEIGHT on all aggregators ===" - -for entry in \ - "BTC_TYPE:BTC_AGG" "ETH_TYPE:ETH_AGG" "SOL_TYPE:SOL_AGG" "SUI_TYPE:SUI_AGG" \ - "DEEP_TYPE:DEEP_AGG" "WAL_TYPE:WAL_AGG" "USDC_TYPE:USDC_AGG" "USDSUI_TYPE:USDSUI_AGG"; do - TYPE_VAR="${entry%%:*}" - AGG_VAR="${entry##*:}" - TOKEN_TYPE="${!TYPE_VAR}" - AGG_ID="${!AGG_VAR}" - LABEL="${TYPE_VAR%%_TYPE}" - echo " $LABEL aggregator..." - sui client call \ - --package "$ORACLE_PKG" --module aggregator --function set_rule_weight \ - --type-args "$TOKEN_TYPE" "$SUPRA_WITNESS" \ - --args "$AGG_ID" "$LISTING_CAP" "$WEIGHT" \ - --gas-budget $GAS - sleep 1 -done - -echo "" -echo "Done. SupraRule weight=$WEIGHT set for BTC, ETH, SOL, SUI, DEEP, WAL, USDC, USDSUI." diff --git a/scripts/test-cancel-redeem-wlp.ts b/scripts/test-cancel-redeem-wlp.ts index 684b968..b054704 100644 --- a/scripts/test-cancel-redeem-wlp.ts +++ b/scripts/test-cancel-redeem-wlp.ts @@ -61,7 +61,10 @@ function parseArgs(argv: string[]): Argv { const rid = getFlag("--request-id"); const onlyRaw = getFlag("--only"); const only = onlyRaw - ? (onlyRaw.toUpperCase().split(/[,\s]+/).filter(Boolean) as Scenario[]) + ? (onlyRaw + .toUpperCase() + .split(/[,\s]+/) + .filter(Boolean) as Scenario[]) : (["A", "B", "C"] as Scenario[]); return { owner: ownerArg ?? INTEGRATION_REFERENCE_WALLET_ADDRESS, @@ -73,11 +76,7 @@ function parseArgs(argv: string[]): Argv { } function stringify(value: unknown): string { - return JSON.stringify( - value, - (_key, v) => (typeof v === "bigint" ? v.toString() : v), - 2, - ); + return JSON.stringify(value, (_key, v) => (typeof v === "bigint" ? v.toString() : v), 2); } function normAddr(a: string): string { @@ -167,7 +166,10 @@ function summarizeSimulate(result: unknown): SimulateSummary { }; } -function dumpSimulate(result: unknown, { full = false } = {}): { +function dumpSimulate( + result: unknown, + { full = false } = {}, +): { ok: boolean; kind: string | undefined; } { @@ -203,9 +205,7 @@ async function scenarioA(client: WaterXClient, args: Argv): Promise 0n ? nextId - 1n : 0n; - console.log( - `owner 名下沒 pending redeem → fallback requestId=${rid} (nextRedeemId-1)`, - ); + console.log(`owner 名下沒 pending redeem → fallback requestId=${rid} (nextRedeemId-1)`); } } console.log("owner :", args.owner); @@ -226,7 +226,9 @@ async function scenarioA(client: WaterXClient, args: Argv): Promise { console.log("\n=========================================="); - console.log("[情境 B] buildRequestRedeemWlpTx + buildCancelRedeemWlpTx — 預期 simulate 成功（當前 ABI）"); + console.log( + "[情境 B] buildRequestRedeemWlpTx + buildCancelRedeemWlpTx — 預期 simulate 成功（當前 ABI）", + ); console.log("=========================================="); const wlp = await pickWlpCoin(client, args.owner); @@ -267,7 +269,7 @@ async function buildRequestPlusCancelAndTransferPtb( updatePythPrice: boolean; }, ): Promise { - // 借用 SDK 的 buildRequestRedeemWlpTx：它會自動 refresh 所有 pool token 的 Pyth/Supra 價格， + // 借用 SDK 的 buildRequestRedeemWlpTx：它會自動 refresh 所有 pool token 的 Pyth 價格， // 並 append `lp_pool::request_redeem`。我們再自己補上 `cancel_redeem_and_transfer`。 const tx = await buildRequestRedeemWlpTx(client, { lpCoin: params.lpCoin, @@ -348,9 +350,7 @@ async function scenarioC(client: WaterXClient, args: Argv): Promise; -}; - -function rowFromJson(j: PersistentPerpJson["markets"][string]): E2ePersistentPerpRow { - const row: E2ePersistentPerpRow = { - isLong: j.isLong, - leverage: j.leverage, - openCollateral: BigInt(j.openCollateral), - openSize: BigInt(j.openSize), - }; - if (j.simulateLeverage !== undefined) row.simulateLeverage = j.simulateLeverage; - return row; -} - -const parsedPersistent: Partial> = {}; -for (const [k, v] of Object.entries((rawPersistent as PersistentPerpJson).markets)) { - parsedPersistent[k as BaseAsset] = rowFromJson(v); -} - -/** Persistent perp rows (loaded from `test/fixtures/trading/persistent-perp.json`). */ -export const E2E_PERSISTENT_PERP_MARKETS: Partial> = - parsedPersistent; +/** Persistent perp rows (loaded from `trading-config.json`). */ +export { E2E_PERSISTENT_PERP_MARKETS }; /** - * Bases with both a persistent-perp fixture row AND an entry in {@link ACTIVE_E2E_BASES}. - * Toggling a base on/off for every e2e surface is done by editing `ACTIVE_E2E_BASES`. + * Bases with both a persistent-perp fixture row AND an entry in {@link ENABLED_E2E_BASES}. */ export function activeE2ePersistentPerpBases(): BaseAsset[] { - return ACTIVE_E2E_BASES.filter( + return (ENABLED_E2E_BASES as BaseAsset[]).filter( (b) => E2E_PERSISTENT_PERP_MARKETS[b] != null && isActiveE2eBase(b), ); } @@ -71,21 +35,18 @@ export function e2ePersistentPerpRow(base: BaseAsset): E2ePersistentPerpRow { const row = E2E_PERSISTENT_PERP_MARKETS[base]; if (!row) { throw new Error( - `No E2E_PERSISTENT_PERP_MARKETS[${base}] — add a row in test/fixtures/trading/persistent-perp.json or remove callers.`, + `No E2E_PERSISTENT_PERP_MARKETS[${base}] — add a row under persistentPerp.markets in test/fixtures/trading/trading-config.json or remove callers.`, ); } return row; } /** Below `minBalanceRaw`, pull `mintPullUsdc` from the account and mint WLP back to the account. */ -export const E2E_PERSISTENT_WLP = { - minBalanceRaw: 1_000_000n, - mintPullUsdc: 25_000_000n, -} as const; +export { E2E_PERSISTENT_WLP }; /** Rough min USDC for bootstrap scripts: sum of perp collaterals + one WLP round + buffer. */ export function e2ePersistentMinAccountUsdcRough(): bigint { - let sum = E2E_PERSISTENT_WLP.mintPullUsdc + 20_000_000n; + let sum = E2E_PERSISTENT_WLP.mintPullUsdc + E2E_PERSISTENT_ACCOUNT_BUFFER_USDC; for (const base of activeE2ePersistentPerpBases()) { sum += e2ePersistentPerpRow(base).openCollateral; } diff --git a/test/helpers/e2e-wlp-readiness.ts b/test/helpers/e2e-wlp-readiness.ts index 7561189..5e3af85 100644 --- a/test/helpers/e2e-wlp-readiness.ts +++ b/test/helpers/e2e-wlp-readiness.ts @@ -2,25 +2,22 @@ * E2e / preflight: **wallet** (owner address) balances for WLP simulate tests. * `buildMintWlpTx` / `buildRequestRedeemWlpTx` use `listCoins(owner)` — not UserAccount TTO. * - * New collaterals: extend {@link e2eWalletCollateralMinForMintSimulate} if decimals differ. + * Thresholds: `e2eWallet` in [test/fixtures/trading/trading-config.json](../fixtures/trading/trading-config.json). */ import type { WaterXClient } from "../../src/client.ts"; import type { CollateralAsset } from "../../src/constants.ts"; +import { + e2eWalletCollateralMinForMintSimulate, + getE2eWalletWlpMinRaw, +} from "./load-trading-fixtures.ts"; /** Min raw WLP on the reference **wallet** so redeem/cancel simulate can pick a coin. */ -export const E2E_WALLET_WLP_MIN_RAW = 1_000n; +export const E2E_WALLET_WLP_MIN_RAW = getE2eWalletWlpMinRaw(); /** * Min **wallet** collateral balance to run `buildMintWlpTx` simulate (single coin path). - * Mock USDC / USDSUI use 6 decimals on testnet. */ -export function e2eWalletCollateralMinForMintSimulate(asset: CollateralAsset): bigint { - const tuned: Partial> = { - USDC: 1_000_000n, - USDSUI: 1_000_000n, - }; - return tuned[asset] ?? 1_000_000n; -} +export { e2eWalletCollateralMinForMintSimulate }; export async function sumWalletCoinBalance( client: WaterXClient, @@ -52,11 +49,12 @@ export async function collectE2eWlpReadinessIssues( ): Promise { const issues: E2eWlpReadinessIssue[] = []; + const wlpMin = getE2eWalletWlpMinRaw(); const wlpSum = await sumWalletCoinBalance(client, owner, client.config.wlpType); - if (wlpSum < E2E_WALLET_WLP_MIN_RAW) { + if (wlpSum < wlpMin) { issues.push({ kind: "wlp_wallet", - detail: `wallet WLP sum=${wlpSum}, need >= ${E2E_WALLET_WLP_MIN_RAW}`, + detail: `wallet WLP sum=${wlpSum}, need >= ${wlpMin}`, }); } diff --git a/test/helpers/lifecycle-oracle-usd-prices.ts b/test/helpers/lifecycle-oracle-usd-prices.ts deleted file mode 100644 index d50ca38..0000000 --- a/test/helpers/lifecycle-oracle-usd-prices.ts +++ /dev/null @@ -1,39 +0,0 @@ -import type { WaterXClient } from "@waterx/perp-sdk"; - -import type { BaseAsset } from "../../src/constants.ts"; -import { activeLifecycleTestBases } from "./lifecycle-test-markets.ts"; -import { fetchSimulatedUsdPricesForBases } from "./oracle-simulate-multi-asset.ts"; - -const basePriceCache = new Map(); - -/** - * One `simulateTransaction` per base (feeds + aggregate only for that token). - * Avoids a single huge PTB that can hit `err_total_weight_not_enough` on testnet. - */ -export async function getOracleUsdPriceForBase( - client: WaterXClient, - base: BaseAsset, -): Promise { - const hit = basePriceCache.get(base); - if (hit !== undefined) return hit; - const row = await fetchSimulatedUsdPricesForBases(client, [base]); - const v = row[base]; - basePriceCache.set(base, v); - return v; -} - -/** All lifecycle bases; fills cache per asset on first access. */ -export async function getLifecycleOracleUsdPrices( - client: WaterXClient, -): Promise> { - const bases = activeLifecycleTestBases(); - const out = {} as Record; - for (const b of bases) { - out[b] = await getOracleUsdPriceForBase(client, b); - } - return out; -} - -export function resetLifecycleOracleUsdPricesCache(): void { - basePriceCache.clear(); -} diff --git a/test/helpers/lifecycle-test-markets.ts b/test/helpers/lifecycle-test-markets.ts index df8ac2a..a9209a4 100644 --- a/test/helpers/lifecycle-test-markets.ts +++ b/test/helpers/lifecycle-test-markets.ts @@ -1,13 +1,16 @@ /** - * Single source of truth for **integration** + **e2e** per-market lifecycle / open-position tests. + * Typed view over **integration** + **e2e** per-market lifecycle / open-position tests. * - * Data rows live in [test/fixtures/trading/lifecycle-markets.json](../fixtures/trading/lifecycle-markets.json). - * Add or remove a market by editing that JSON — this module only re-exports the typed view. - * Iteration order is {@link LIFECYCLE_TEST_BASE_ORDER} intersected with keys present in the fixture. + * All data lives in [test/fixtures/trading/trading-config.json](../fixtures/trading/trading-config.json). + * Iteration order is {@link LIFECYCLE_TEST_BASE_ORDER} intersected with rows in `lifecycleMarkets` + * and {@link ENABLED_E2E_BASES} (see {@link activeLifecycleTestBases}). */ import type { BaseAsset } from "../../src/constants.ts"; - -import { LIFECYCLE_TEST_MARKETS_FROM_FIXTURE } from "./load-trading-fixtures.ts"; +import { + ENABLED_E2E_BASES, + LIFECYCLE_TEST_BASE_ORDER, + LIFECYCLE_TEST_MARKETS_FROM_FIXTURE, +} from "./load-trading-fixtures.ts"; export type LifecycleTestMarketRow = { /** @@ -20,8 +23,8 @@ export type LifecycleTestMarketRow = { openCollateral: bigint; isLong: boolean; /** - * Legacy hint for local math; **integration** uses `fetchIntegrationMarketSummaries` (`beforeAll`) - * for real `lotSize` / `minSize`. Kept for docs / e2e row symmetry. + * Test-table hint only (v2 uses `Float` size on-chain; no `min_size` / `lot_size` on `MarketConfig`). + * Integration may still read market snapshots for unrelated asserts. */ sizeLot: bigint; /** @@ -46,59 +49,41 @@ export type LifecycleTestMarketRow = { }; }; -/** - * Preferred scan / test order. Only bases with a row in {@link LIFECYCLE_TEST_MARKETS} run. - * - * xStock rows also exist in [test/fixtures/trading/lifecycle-markets.json](../fixtures/trading/lifecycle-markets.json) - * but are intentionally omitted from the default iteration order — add them here to opt-in - * (requires working xStock Pyth/Supra oracles on testnet). - */ -export const LIFECYCLE_TEST_BASE_ORDER: readonly BaseAsset[] = [ - "BTC", - "ETH", - "SUI", - "SOL", - "WAL", - "DEEP", -]; +/** Re-export fixture iteration order. */ +export { LIFECYCLE_TEST_BASE_ORDER }; -/** Fixture-backed rows. Add/disable a market by editing `lifecycle-markets.json`. */ +/** Which bases run preflight / scratch / table-driven simulate (subset of `lifecycleMarkets` keys). */ +export { ENABLED_E2E_BASES }; + +/** Fixture-backed rows. */ export const LIFECYCLE_TEST_MARKETS: Partial> = - LIFECYCLE_TEST_MARKETS_FROM_FIXTURE; + LIFECYCLE_TEST_MARKETS_FROM_FIXTURE as Partial>; -/** Bases that have a row — in stable order. */ +/** + * Bases that have a lifecycle row, appear in `enabledE2eBases`, and follow `baseOrder`. + * This is the set used by preflight, scratch scenarios, and most per-base simulate loops. + */ export function activeLifecycleTestBases(): BaseAsset[] { - return LIFECYCLE_TEST_BASE_ORDER.filter((b) => LIFECYCLE_TEST_MARKETS[b] != null); + const enabled = new Set(ENABLED_E2E_BASES as BaseAsset[]); + return LIFECYCLE_TEST_BASE_ORDER.filter( + (b) => LIFECYCLE_TEST_MARKETS[b] != null && enabled.has(b), + ); } export function lifecycleRow(base: BaseAsset): LifecycleTestMarketRow { const row = LIFECYCLE_TEST_MARKETS[base]; if (!row) { throw new Error( - `No LIFECYCLE_TEST_MARKETS[${base}] — add a row to test/fixtures/trading/lifecycle-markets.json or remove ${base} from callers.`, + `No LIFECYCLE_TEST_MARKETS[${base}] — add a row under lifecycleMarkets in test/fixtures/trading/trading-config.json (and enable the base in enabledE2eBases if needed).`, ); } return row; } -/** Integration: `buildIncreasePositionTx` collateral (USDC 6dp). */ -export const LIFECYCLE_INCREASE_COLLATERAL_USDC = 12_000_000n; - -/** Integration: `buildDepositCollateralTx` collateral add amount (USDC 6dp). */ -export const LIFECYCLE_DEPOSIT_COLLATERAL_USDC = 2_000_000n; - -/** Integration: `buildWithdrawCollateralTx` collateral release amount (USDC 6dp). */ -export const LIFECYCLE_WITHDRAW_COLLATERAL_USDC = 1_000_000n; - -/** - * Minimum account USDC before **scratch** lifecycle (`trader-position-lifecycle`): largest - * `openCollateral` among enabled bases + increase + fee headroom. E2e persistent slots + WLP live - * in `e2e-persistent-state.ts` / `trader-e2e-persistent-state.test.ts`. - */ -export const LIFECYCLE_MIN_ACCOUNT_USDC = 130_000_000n; - -/** - * Minimum account USDC for opt-in `WATERX_INTEGRATION_APPROX_PRICE_CHAIN` open+close smoke - * (uses `simulateOpenCollateral` + headroom; cheaper than full scratch lifecycle). - */ -export const LIFECYCLE_APPROX_PRICE_CHAIN_SMOKE_MIN_USDC = 40_000_000n; +export { + LIFECYCLE_APPROX_PRICE_CHAIN_SMOKE_MIN_USDC, + LIFECYCLE_DEPOSIT_COLLATERAL_USDC, + LIFECYCLE_INCREASE_COLLATERAL_USDC, + LIFECYCLE_MIN_ACCOUNT_USDC, + LIFECYCLE_WITHDRAW_COLLATERAL_USDC, +} from "./load-trading-fixtures.ts"; diff --git a/test/helpers/load-trading-fixtures.ts b/test/helpers/load-trading-fixtures.ts index 380f750..5a98a62 100644 --- a/test/helpers/load-trading-fixtures.ts +++ b/test/helpers/load-trading-fixtures.ts @@ -1,13 +1,12 @@ /** - * Loads [test/fixtures/trading/lifecycle-markets.json](test/fixtures/trading/lifecycle-markets.json) - * — single source for lifecycle rows used by e2e / simulate table tests. + * Loads [test/fixtures/trading/trading-config.json](../fixtures/trading/trading-config.json) — + * single source for lifecycle rows, persistent perp, iteration order, enabled bases, and thresholds. */ -import raw from "../fixtures/trading/lifecycle-markets.json"; +import type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; +import raw from "../fixtures/trading/trading-config.json"; -import type { BaseAsset } from "../../src/constants.ts"; - -/** Mirrors {@link import("./lifecycle-test-markets.ts").LifecycleTestMarketRow} — kept local to avoid circular imports. */ -type FixtureRow = { +/** Mirrors {@link import("./lifecycle-test-markets.ts").LifecycleTestMarketRow} — local to avoid circular imports. */ +type FixtureLifecycleRow = { approxPrice: number; leverage: number; openCollateral: bigint; @@ -24,7 +23,53 @@ type FixtureRow = { }; }; -function rowFromJson(j: Record): FixtureRow { +export type E2ePersistentPerpRow = { + isLong: boolean; + leverage: number; + simulateLeverage?: number; + openCollateral: bigint; + openSize: bigint; +}; + +type TradingConfigJson = { + version: number; + baseOrder: string[]; + enabledE2eBases: string[]; + scratchIntegration: { + increaseCollateralUsdc: string; + depositCollateralUsdc: string; + withdrawCollateralUsdc: string; + minAccountUsdc: string; + approxPriceChainSmokeMinUsdc: string; + }; + persistentWlp: { + minBalanceRaw: string; + mintPullUsdc: string; + accountBufferUsdc: string; + }; + e2eWallet: { + wlpMinRaw: string; + defaultCollateralMintSimulateMin: string; + collateralMintSimulateMinByAsset?: Partial>; + }; + lifecycleMarkets: Record>; + persistentPerp: { + markets: Record< + string, + { + isLong: boolean; + leverage: number; + simulateLeverage?: number; + openCollateral: string; + openSize: string; + } + >; + }; +}; + +const cfg = raw as TradingConfigJson; + +function lifecycleRowFromJson(j: Record): FixtureLifecycleRow { const e2e = j.e2ePtb as Record; return { approxPrice: j.approxPrice as number, @@ -33,8 +78,7 @@ function rowFromJson(j: Record): FixtureRow { isLong: j.isLong as boolean, sizeLot: BigInt(j.sizeLot as string), simulateOpenCollateral: BigInt(j.simulateOpenCollateral as string), - simulateLeverage: - j.simulateLeverage !== undefined ? (j.simulateLeverage as number) : undefined, + simulateLeverage: j.simulateLeverage !== undefined ? (j.simulateLeverage as number) : undefined, e2ePtb: { openCollateral: BigInt(e2e.openCollateral), increaseCollateral: BigInt(e2e.increaseCollateral), @@ -45,10 +89,85 @@ function rowFromJson(j: Record): FixtureRow { }; } -const parsed: Partial> = {}; -for (const [k, v] of Object.entries(raw as Record>)) { - parsed[k as BaseAsset] = rowFromJson(v); +const parsedLifecycle: Partial> = {}; +for (const [k, v] of Object.entries(cfg.lifecycleMarkets)) { + parsedLifecycle[k as BaseAsset] = lifecycleRowFromJson(v); } -/** Lifecycle market rows from JSON fixture (bigint fields as decimal strings). */ -export const LIFECYCLE_TEST_MARKETS_FROM_FIXTURE: Partial> = parsed; +/** Preferred iteration order (intersect with row presence + {@link ENABLED_E2E_BASES} in callers). */ +export const LIFECYCLE_TEST_BASE_ORDER = cfg.baseOrder as readonly BaseAsset[]; + +/** + * Bases that participate in preflight, scratch iteration, and other e2e surfaces. + * Must still have a `lifecycleMarkets` row; persistent perp is optional per base. + */ +export const ENABLED_E2E_BASES = cfg.enabledE2eBases as readonly BaseAsset[]; + +/** Lifecycle market rows from JSON (bigint fields as decimal strings in source). */ +export const LIFECYCLE_TEST_MARKETS_FROM_FIXTURE: Partial> = + parsedLifecycle; + +/** Integration: `buildIncreasePositionTx` collateral (USDC 6dp). */ +export const LIFECYCLE_INCREASE_COLLATERAL_USDC = BigInt( + cfg.scratchIntegration.increaseCollateralUsdc, +); + +/** Integration: `buildDepositCollateralTx` collateral add amount (USDC 6dp). */ +export const LIFECYCLE_DEPOSIT_COLLATERAL_USDC = BigInt( + cfg.scratchIntegration.depositCollateralUsdc, +); + +/** Integration: `buildWithdrawCollateralTx` collateral release amount (USDC 6dp). */ +export const LIFECYCLE_WITHDRAW_COLLATERAL_USDC = BigInt( + cfg.scratchIntegration.withdrawCollateralUsdc, +); + +/** + * Minimum account USDC before **scratch** lifecycle (`trader-position-lifecycle`): largest + * `openCollateral` among enabled bases + increase + fee headroom. + */ +export const LIFECYCLE_MIN_ACCOUNT_USDC = BigInt(cfg.scratchIntegration.minAccountUsdc); + +/** + * Minimum account USDC for opt-in `WATERX_INTEGRATION_APPROX_PRICE_CHAIN` open+close smoke. + */ +export const LIFECYCLE_APPROX_PRICE_CHAIN_SMOKE_MIN_USDC = BigInt( + cfg.scratchIntegration.approxPriceChainSmokeMinUsdc, +); + +const parsedPersistent: Partial> = {}; +for (const [k, v] of Object.entries(cfg.persistentPerp.markets)) { + const row: E2ePersistentPerpRow = { + isLong: v.isLong, + leverage: v.leverage, + openCollateral: BigInt(v.openCollateral), + openSize: BigInt(v.openSize), + }; + if (v.simulateLeverage !== undefined) row.simulateLeverage = v.simulateLeverage; + parsedPersistent[k as BaseAsset] = row; +} + +/** Persistent perp rows (from `trading-config.json` → `persistentPerp.markets`). */ +export const E2E_PERSISTENT_PERP_MARKETS: Partial> = + parsedPersistent; + +/** Below `minBalanceRaw`, pull `mintPullUsdc` from the account and mint WLP back to the account. */ +export const E2E_PERSISTENT_WLP = { + minBalanceRaw: BigInt(cfg.persistentWlp.minBalanceRaw), + mintPullUsdc: BigInt(cfg.persistentWlp.mintPullUsdc), +} as const; + +export const E2E_PERSISTENT_ACCOUNT_BUFFER_USDC = BigInt(cfg.persistentWlp.accountBufferUsdc); + +/** Min raw WLP on the reference **wallet** so redeem/cancel simulate can pick a coin. */ +export function getE2eWalletWlpMinRaw(): bigint { + return BigInt(cfg.e2eWallet.wlpMinRaw); +} + +/** Min **wallet** collateral balance for `buildMintWlpTx` simulate (single coin path). */ +export function e2eWalletCollateralMinForMintSimulate(asset: CollateralAsset): bigint { + const by = cfg.e2eWallet.collateralMintSimulateMinByAsset; + const v = by?.[asset]; + if (v !== undefined) return BigInt(v); + return BigInt(cfg.e2eWallet.defaultCollateralMintSimulateMin); +} diff --git a/test/helpers/move-event-payload.ts b/test/helpers/move-event-payload.ts index bb0b76d..50f9908 100644 --- a/test/helpers/move-event-payload.ts +++ b/test/helpers/move-event-payload.ts @@ -144,14 +144,8 @@ export function readPositionOpenedFields(payload: Record): { entryPriceScaled: bigint; } | null { const sizeRaw = - payload.size_amount ?? - payload.sizeAmount ?? - payload.size ?? - payload["size_amount"]; - const feeRaw = - payload.open_fee_amount ?? - payload.openFeeAmount ?? - payload["open_fee_amount"]; + payload.size_amount ?? payload.sizeAmount ?? payload.size ?? payload["size_amount"]; + const feeRaw = payload.open_fee_amount ?? payload.openFeeAmount ?? payload["open_fee_amount"]; const longRaw = payload.is_long ?? payload.isLong ?? payload["is_long"]; const priceRaw = payload.entry_price ?? payload.entryPrice ?? payload["entry_price"]; @@ -159,14 +153,18 @@ export function readPositionOpenedFields(payload: Record): { if (sizeAmount === null) { const fs = floatScaledFromJson(sizeRaw); if (fs !== null) { - sizeAmount = - fs >= FLOAT_PRECISION && fs % FLOAT_PRECISION === 0n ? fs / FLOAT_PRECISION : fs; + sizeAmount = fs >= FLOAT_PRECISION && fs % FLOAT_PRECISION === 0n ? fs / FLOAT_PRECISION : fs; } } const openFeeAmount = u64FromField(feeRaw); const entryPriceScaled = floatScaledFromJson(priceRaw); const isLong = boolFromUnknown(longRaw); - if (sizeAmount === null || openFeeAmount === null || entryPriceScaled === null || isLong === null) { + if ( + sizeAmount === null || + openFeeAmount === null || + entryPriceScaled === null || + isLong === null + ) { return null; } diff --git a/test/helpers/oracle-simulate-multi-asset.ts b/test/helpers/oracle-simulate-multi-asset.ts index 43239be..697c933 100644 --- a/test/helpers/oracle-simulate-multi-asset.ts +++ b/test/helpers/oracle-simulate-multi-asset.ts @@ -1,6 +1,6 @@ /** - * One gRPC `simulateTransaction` that feeds Pyth (best-effort Hermes) + Supra and aggregates - * **all** requested base markets — same path as `buildOpenPositionTx` oracle wiring. + * One gRPC `simulateTransaction` that feeds Pyth (best-effort Hermes) and aggregates + * **all** requested base markets — same oracle path as `buildOpenPositionTx`. * * Parses `bucket_v2_oracle::aggregator::PriceAggregated::result` (Float `to_scaled_val`, 1e9). */ diff --git a/test/helpers/place-cancel-probe.ts b/test/helpers/place-cancel-probe.ts index 34176cb..271d097 100644 --- a/test/helpers/place-cancel-probe.ts +++ b/test/helpers/place-cancel-probe.ts @@ -31,7 +31,11 @@ export async function simulatePlaceCancelSinglePtbWithRetries( triggerPriceUsd: number; maxAttempts?: number; gasBudget?: number; - build: (input: { tx: Transaction; orderId: bigint; triggerPriceKey: number }) => void | Promise; + build: (input: { + tx: Transaction; + orderId: bigint; + triggerPriceKey: number; + }) => void | Promise; setSender: (tx: Transaction) => void; }, ): Promise< @@ -58,7 +62,11 @@ export async function simulatePlaceCancelSinglePtbWithRetries( const result = await client.simulate(tx); lastResult = result; - if (result && typeof result === "object" && (result as { $kind?: string }).$kind === "Transaction") { + if ( + result && + typeof result === "object" && + (result as { $kind?: string }).$kind === "Transaction" + ) { return { ok: true, result, tx }; } const meta = parseSimulateFailure(result); diff --git a/test/helpers/run-scratch-trading-scenario-integration.ts b/test/helpers/run-scratch-trading-scenario-integration.ts index 7c90321..03359e2 100644 --- a/test/helpers/run-scratch-trading-scenario-integration.ts +++ b/test/helpers/run-scratch-trading-scenario-integration.ts @@ -23,7 +23,8 @@ import { positionIdFromOpened, simulateResizeForIntegrationOrSkip, } from "../integration/helpers/scratch-lifecycle.ts"; -import { SCRATCH_EXPECT, type ScratchTradingScenario } from "./scratch-trading-scenarios.ts"; +import { SCRATCH_EXPECT } from "./scratch-scenario-steps.ts"; +import type { ScratchTradingScenario } from "./scratch-trading-scenarios.ts"; export type IntegrationScratchRunnerDeps = { client: WaterXClient; @@ -38,7 +39,7 @@ export type IntegrationScratchRunnerDeps = { maxAttempts?: number; }, ) => Promise; - execIntegrationOrSkipSupra: ( + execIntegrationOrSkipOracle: ( ctx: { skip: (reason?: string) => void }, fn: () => Promise, ) => Promise; @@ -60,7 +61,7 @@ export async function runScratchTradingScenarioIntegration( client, trader, execBuiltTxWithCooldownRetries, - execIntegrationOrSkipSupra, + execIntegrationOrSkipOracle, extractEvent, assertSuccess, marketAtStart, @@ -78,7 +79,7 @@ export async function runScratchTradingScenarioIntegration( if (openProbe === undefined) return; expectResizeProbeMatchesSnapshot(base, openProbe, snap); - const openResult = await execIntegrationOrSkipSupra(ctx, () => + const openResult = await execIntegrationOrSkipOracle(ctx, () => execBuiltTxWithCooldownRetries( () => buildOpenPositionTx(client, { diff --git a/test/helpers/run-scratch-trading-scenario-simulate.ts b/test/helpers/run-scratch-trading-scenario-simulate.ts index 49c1658..f589b06 100644 --- a/test/helpers/run-scratch-trading-scenario-simulate.ts +++ b/test/helpers/run-scratch-trading-scenario-simulate.ts @@ -17,7 +17,8 @@ import { assertSimulateOpenFeeMatchesFormula } from "./assert-simulate-open-fee. import { expectLeverageOpenSizingVsMarket } from "./e2e-open-sizing-expect.ts"; import { lifecycleOracleUsdOrSkip } from "./e2e-oracle-context.ts"; import { fetchSimulatedCollateralUsdPrice } from "./oracle-simulate-multi-asset.ts"; -import { SCRATCH_EXPECT, type ScratchTradingScenario } from "./scratch-trading-scenarios.ts"; +import { SCRATCH_EXPECT } from "./scratch-scenario-steps.ts"; +import type { ScratchTradingScenario } from "./scratch-trading-scenarios.ts"; import { assertSimulateSuccess, skipSimulateIfOracleTransient } from "./simulate-assertions.ts"; export type SimulateScratchCtx = { skip: (reason?: string) => void }; diff --git a/test/helpers/scratch-scenario-steps.ts b/test/helpers/scratch-scenario-steps.ts new file mode 100644 index 0000000..1aca904 --- /dev/null +++ b/test/helpers/scratch-scenario-steps.ts @@ -0,0 +1,42 @@ +/** + * Shared scratch **expectations** and integration **step ordering** for + * {@link import("./run-scratch-trading-scenario-integration.ts").runScratchTradingScenarioIntegration} + * vs {@link import("./run-scratch-trading-scenario-simulate.ts")}. + * + * Thresholds come from `trading-config.json` via {@link import("./load-trading-fixtures.ts")}. + */ +import { + LIFECYCLE_DEPOSIT_COLLATERAL_USDC, + LIFECYCLE_WITHDRAW_COLLATERAL_USDC, +} from "./load-trading-fixtures.ts"; + +/** Minimum Move commands we expect a successful `buildOpenPositionTx` simulate to execute (heuristic). */ +export const SCRATCH_EXPECT = { + simulate: { + /** `approxPrice` / explicit `size` / table-approx open (no on-chain resize). */ + minCommandsOpenStandard: 9, + /** Open sized via on-chain `resize`. */ + minCommandsOpenResize: 10, + }, + integration: { + /** After `PositionOpened`, leverage must be in (0, maxLeverageBps]. */ + openLeverageBpsMinExclusive: 0n, + /** Collateral delta after deposit (USDC raw). */ + depositDelta: LIFECYCLE_DEPOSIT_COLLATERAL_USDC, + /** Collateral delta after withdraw (USDC raw). */ + withdrawDelta: LIFECYCLE_WITHDRAW_COLLATERAL_USDC, + }, +} as const; + +/** + * Ordered phases in {@link import("./run-scratch-trading-scenario-integration.ts").runScratchTradingScenarioIntegration} + * (after optional resize probe + open). + */ +export const SCRATCH_INTEGRATION_STEP_ORDER = [ + "open", + "deposit", + "withdraw", + "increase", + "decrease", + "close", +] as const; diff --git a/test/helpers/scratch-trading-scenarios.ts b/test/helpers/scratch-trading-scenarios.ts index bc2d6db..2bd45d3 100644 --- a/test/helpers/scratch-trading-scenarios.ts +++ b/test/helpers/scratch-trading-scenarios.ts @@ -1,37 +1,20 @@ /** - * Data-driven **scratch** perp scenarios: one row per enabled {@link LIFECYCLE_TEST_MARKETS} base. + * Data-driven **scratch** perp scenarios: one row per {@link activeLifecycleTestBases} base. * Used by integration (full on-chain lifecycle) and e2e simulate (open dry-runs + optional stateful). * - * To add a market: extend {@link LIFECYCLE_TEST_MARKETS}; order follows {@link LIFECYCLE_TEST_BASE_ORDER}. + * To add a market: extend `lifecycleMarkets` in test/fixtures/trading/trading-config.json and enable the base in `enabledE2eBases`. */ import type { BaseAsset } from "../../src/constants.ts"; import type { LifecycleTestMarketRow } from "./lifecycle-test-markets.ts"; import { + activeLifecycleTestBases, LIFECYCLE_DEPOSIT_COLLATERAL_USDC, LIFECYCLE_INCREASE_COLLATERAL_USDC, - LIFECYCLE_TEST_BASE_ORDER, - LIFECYCLE_TEST_MARKETS, LIFECYCLE_WITHDRAW_COLLATERAL_USDC, lifecycleRow, } from "./lifecycle-test-markets.ts"; -/** Minimum Move commands we expect a successful `buildOpenPositionTx` simulate to execute (heuristic). */ -export const SCRATCH_EXPECT = { - simulate: { - /** `approxPrice` / explicit `size` / table-approx open (no on-chain resize). */ - minCommandsOpenStandard: 9, - /** Open sized via on-chain `resize`. */ - minCommandsOpenResize: 10, - }, - integration: { - /** After `PositionOpened`, leverage must be in (0, maxLeverageBps]. */ - openLeverageBpsMinExclusive: 0n, - /** Collateral delta after deposit (USDC raw). */ - depositDelta: LIFECYCLE_DEPOSIT_COLLATERAL_USDC, - /** Collateral delta after withdraw (USDC raw). */ - withdrawDelta: LIFECYCLE_WITHDRAW_COLLATERAL_USDC, - }, -} as const; +export { SCRATCH_EXPECT } from "./scratch-scenario-steps.ts"; export type ScratchTradingScenario = { /** Stable id for Vitest titles, e.g. `scratch-BTC`. */ @@ -68,15 +51,11 @@ export type ScratchTradingScenario = { }; }; -function basesInOrder(): BaseAsset[] { - return LIFECYCLE_TEST_BASE_ORDER.filter((b) => LIFECYCLE_TEST_MARKETS[b] != null); -} - /** * All scratch scenarios for currently configured testnet markets (same set as `activeLifecycleTestBases()`). */ export function scratchTradingScenarios(): ScratchTradingScenario[] { - return basesInOrder().map((base) => { + return activeLifecycleTestBases().map((base) => { const row = lifecycleRow(base); const levSim = row.simulateLeverage ?? row.leverage; return { diff --git a/test/helpers/simulate-assertions.ts b/test/helpers/simulate-assertions.ts index 4214385..71bff59 100644 --- a/test/helpers/simulate-assertions.ts +++ b/test/helpers/simulate-assertions.ts @@ -36,6 +36,7 @@ export function extractSimulateError(result: SimulateResult): string { export function isOracleTransientFailureMessage(msg: string): boolean { return ( msg.includes("err_total_weight_not_enough") || + // Legacy testnet deployments may still surface Supra rule errors in abort text. msg.includes("::supra_rule::feed") || msg.includes("::pyth_rule::feed") ); diff --git a/test/helpers/testnet.ts b/test/helpers/testnet.ts index 46cce2b..1b0377c 100644 --- a/test/helpers/testnet.ts +++ b/test/helpers/testnet.ts @@ -1,8 +1,8 @@ /** * Shared testnet client + constants for read-only / simulate tests (no admin keystore). * - * Uses full testnet config (**Pyth + Supra**) so `buildOracleFeed` / tx-builders match on-chain - * `PriceAggregator` expectations (every weighted rule is fed). + * Uses `WaterXClient.testnet()` (SDK v2 is **Pyth-only**); `buildOracleFeed` matches on-chain + * `PriceAggregator` + `pyth_rule` wiring on public testnet. */ import { TESTNET_OBJECTS, TESTNET_TYPES, WaterXClient } from "@waterx/perp-sdk"; diff --git a/test/helpers/trading-fixture-harness.ts b/test/helpers/trading-fixture-harness.ts deleted file mode 100644 index e02ea35..0000000 --- a/test/helpers/trading-fixture-harness.ts +++ /dev/null @@ -1,27 +0,0 @@ -/** - * Table + JSON fixture helpers for trading simulate tests. - * Lifecycle rows load from `test/fixtures/trading/lifecycle-markets.json` via - * {@link import("./load-trading-fixtures.ts").LIFECYCLE_TEST_MARKETS_FROM_FIXTURE}. - */ -import type { BaseAsset } from "../../src/constants.ts"; - -import { - activeLifecycleTestBases, - lifecycleRow, - type LifecycleTestMarketRow, -} from "./lifecycle-test-markets.ts"; - -export type TradingFixtureCase = { - base: BaseAsset; - row: LifecycleTestMarketRow; -}; - -/** - * Expands the active e2e base set × lifecycle row for data-driven describes. - */ -export function activeTradingFixtureCases(): TradingFixtureCase[] { - return activeLifecycleTestBases().map((base) => ({ - base, - row: lifecycleRow(base), - })); -} diff --git a/test/helpers/wlp-pool-price-refresh.ts b/test/helpers/wlp-pool-price-refresh.ts deleted file mode 100644 index fca1fe3..0000000 --- a/test/helpers/wlp-pool-price-refresh.ts +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Mirrors `refreshAllPoolTokensAndGetDepositPriceResult` in `tx-builders.ts` (private): - * Hermes Pyth refresh (optional) + `lp_pool::update_token_value` for **each** configured collateral - * so `assert_prices_fresh` passes before `request_redeem` / mint / settle paths. - */ -import { Transaction } from "@mysten/sui/transactions"; -import { - buildOracleFeed, - PYTH_TESTNET_FEED_IDS, - PythCache, - updatePythPrices, - type WaterXClient, -} from "@waterx/perp-sdk"; - -import { updateTokenValue as updateTokenValueCall } from "../../src/generated/waterx_perp/lp_pool.ts"; - -export type AppendWlpPoolPriceRefreshOpts = { - updatePythPrice?: boolean; - pythCache?: PythCache; -}; - -/** - * Appends oracle wiring to `tx` so WLP pool token timestamps are fresh (testnet simulate). - */ -export async function appendWlpPoolTokenRefreshesForSimulate( - client: WaterXClient, - tx: Transaction, - opts: AppendWlpPoolPriceRefreshOpts = {}, -): Promise { - const cfg = client.config; - const pythCfg = cfg.pythConfig; - const feedIds = PYTH_TESTNET_FEED_IDS; - - for (const [, coll] of Object.entries(cfg.collaterals)) { - if (opts.updatePythPrice && pythCfg && coll.feedKey) { - const feedId = feedIds[coll.feedKey]; - if (feedId) { - try { - await updatePythPrices( - tx, - client.grpcClient, - pythCfg, - [feedId.replace(/^0x/, "")], - opts.pythCache ?? new PythCache(), - ); - } catch { - /* Hermes down — on-chain Pyth may still be within tolerance */ - } - } - } - - const priceResult = buildOracleFeed( - client, - tx, - coll.type, - coll.aggregatorId, - coll.priceInfoId, - ); - - updateTokenValueCall({ - package: cfg.packageId, - arguments: { pool: cfg.wlpPool, priceResult }, - typeArguments: [cfg.wlpType, coll.type], - })(tx); - } -} diff --git a/test/integration/setup.ts b/test/integration/setup.ts index b8364bf..eb79379 100644 --- a/test/integration/setup.ts +++ b/test/integration/setup.ts @@ -47,7 +47,7 @@ if (existsSync(envLocalPath)) { export const INTEGRATION_TRADER_KEYSTORE_PATH = path.join(repoRoot, ".integration-trader.keystore"); -/** Full testnet config (Pyth + Supra) — same oracle path as `WaterXClient.testnet()` / e2e simulate. */ +/** Full testnet config (SDK v2 Pyth-only) — same as `WaterXClient.testnet()` / e2e simulate. */ export const client = new WaterXClient(createTestnetConfig()); export { TESTNET_OBJECTS, TESTNET_TYPES }; @@ -196,10 +196,10 @@ function isCooldownNotElapsedError(e: unknown): boolean { } /** - * Testnet Supra push oracle abort during PTB resolution — infra / pair registration, not SDK logic. + * Testnet oracle infra abort during PTB (Pyth feed, aggregator weight, legacy `supra_rule` text). * Matches `isOracleTransientFailureMessage` in simulate helpers for consistent skip behavior. */ -export function isSupraOracleInfrastructureError(e: unknown): boolean { +export function isOracleInfrastructureError(e: unknown): boolean { const s = e instanceof Error ? e.message : String(e); return ( s.includes("supra_rule::feed") || @@ -212,20 +212,20 @@ export function isSupraOracleInfrastructureError(e: unknown): boolean { export type IntegrationSkipContext = { skip: (reason?: string) => void }; /** - * Runs an async integration action; on testnet oracle infra failure (Supra / Pyth / aggregator - * weight), marks the test skipped instead of failing (same policy as simulate + * Runs an async integration action; on testnet oracle infra failure (Pyth / aggregator weight, + * legacy rule strings), marks the test skipped instead of failing (same policy as simulate * `isOracleTransientFailureMessage`). * * @returns `undefined` when skipped (caller should `return`); otherwise the action result. */ -export async function execIntegrationOrSkipSupra( +export async function execIntegrationOrSkipOracle( ctx: IntegrationSkipContext, run: () => Promise, ): Promise { try { return await run(); } catch (e) { - if (isSupraOracleInfrastructureError(e)) { + if (isOracleInfrastructureError(e)) { ctx.skip( `Testnet oracle unavailable (transient): ${e instanceof Error ? e.message : String(e)}`, ); diff --git a/test/integration/user/trader-close-position.test.ts b/test/integration/user/trader-close-position.test.ts index 1376b5f..62a6d30 100644 --- a/test/integration/user/trader-close-position.test.ts +++ b/test/integration/user/trader-close-position.test.ts @@ -65,7 +65,7 @@ async function tryPinnedPosition( /** * WATERX_INTEGRATION_CLOSE_BASE + optional WATERX_INTEGRATION_POSITION_ID, * or legacy WATERX_INTEGRATION_BTC_POSITION_ID (BTC pin, optional), - * or auto-scan configured lifecycle bases (see `test/helpers/lifecycle-test-markets.ts`). + * or auto-scan configured lifecycle bases (see `test/fixtures/trading/trading-config.json`). */ async function resolvePositionToClose( ctx: SkipCtx, @@ -106,7 +106,7 @@ async function resolvePositionToClose( "No open perp position in configured lifecycle markets (scan cap applies). " + "Open a position, or set WATERX_INTEGRATION_CLOSE_BASE (+ optional WATERX_INTEGRATION_POSITION_ID), " + "or legacy WATERX_INTEGRATION_BTC_POSITION_ID if closing BTC. " + - "Edit `test/helpers/lifecycle-test-markets.ts` to change which bases are scanned.", + "Edit `enabledE2eBases` in test/fixtures/trading/trading-config.json to change which bases are scanned.", ); return null; } diff --git a/test/integration/user/trader-e2e-persistent-state.test.ts b/test/integration/user/trader-e2e-persistent-state.test.ts index df3f1d0..010ae38 100644 --- a/test/integration/user/trader-e2e-persistent-state.test.ts +++ b/test/integration/user/trader-e2e-persistent-state.test.ts @@ -35,7 +35,7 @@ import { assertSuccess, client, execBuiltTxWithCooldownRetries, - execIntegrationOrSkipSupra, + execIntegrationOrSkipOracle, execTx, isIntegrationTraderConfigured, loadIntegrationTraderKeypair, @@ -82,7 +82,7 @@ describe.skipIf(!isIntegrationTraderConfigured())( assertMarketSnapshotTradeable(snap, base); const openSize = alignPositionSizeToMarket(row.openSize); - const result = await execIntegrationOrSkipSupra(ctx, () => + const result = await execIntegrationOrSkipOracle(ctx, () => execBuiltTxWithCooldownRetries( () => buildOpenPositionTx(client, { diff --git a/test/integration/user/trader-position-lifecycle.test.ts b/test/integration/user/trader-position-lifecycle.test.ts index 3ef6bc2..5fa6d8f 100644 --- a/test/integration/user/trader-position-lifecycle.test.ts +++ b/test/integration/user/trader-position-lifecycle.test.ts @@ -25,7 +25,7 @@ import { assertSuccess, client, execBuiltTxWithCooldownRetries, - execIntegrationOrSkipSupra, + execIntegrationOrSkipOracle, execTx, extractEvent, isIntegrationTraderConfigured, @@ -61,7 +61,7 @@ describe.skipIf(!isIntegrationTraderConfigured())( client, trader, execBuiltTxWithCooldownRetries, - execIntegrationOrSkipSupra, + execIntegrationOrSkipOracle, extractEvent, assertSuccess, marketAtStart, @@ -122,7 +122,7 @@ describe.skipIf(!isIntegrationTraderConfigured())( const lev = row.simulateLeverage ?? row.leverage; const collateral = row.simulateOpenCollateral; - const openResult = await execIntegrationOrSkipSupra(ctx, () => + const openResult = await execIntegrationOrSkipOracle(ctx, () => execBuiltTxWithCooldownRetries( () => buildOpenPositionTx(client, { diff --git a/test/scripts/regen-trading-fixtures.ts b/test/scripts/regen-trading-fixtures.ts index a98d3d6..41d9294 100644 --- a/test/scripts/regen-trading-fixtures.ts +++ b/test/scripts/regen-trading-fixtures.ts @@ -3,10 +3,10 @@ * Placeholder for regenerating `test/fixtures/trading/*.json` golden baselines from testnet simulate. * * Usage (future): `pnpm test:regen-fixtures -- --base BTC` - * For now: edit `lifecycle-markets.json` by hand when market params change; run `pnpm typecheck`. + * For now: edit `trading-config.json` by hand when market params change; run `pnpm typecheck`. */ console.log( - "[regen-trading-fixtures] No-op: update test/fixtures/trading/lifecycle-markets.json manually. " + + "[regen-trading-fixtures] No-op: update test/fixtures/trading/trading-config.json manually. " + "Optional future: snapshot simulate events into per-base expected JSON.", ); process.exit(0); diff --git a/test/simulate/collateral-order-simulate.test.ts b/test/simulate/collateral-order-simulate.test.ts index f400318..234c0e2 100644 --- a/test/simulate/collateral-order-simulate.test.ts +++ b/test/simulate/collateral-order-simulate.test.ts @@ -293,9 +293,7 @@ describe("placeOrder / cancelOrder (single-PTB simulate, no keys)", () => { if (skipSimulateIfOracleTransient(ctx, outcome.lastResult)) return; const meta = parseSimulateFailure(outcome.lastResult); if (meta?.abortCode === "300") { - ctx.skip( - "testnet orderId raced even after retries — TODO(contracts#cancel-by-key)", - ); + ctx.skip("testnet orderId raced even after retries — TODO(contracts#cancel-by-key)"); return; } assertSimulateSuccessOrSkipOracleWeak(ctx, outcome.lastResult, 22, outcome.lastTx); diff --git a/test/simulate/delegate-lifecycle-simulate.test.ts b/test/simulate/delegate-lifecycle-simulate.test.ts index 6bcb3dc..8e7ca99 100644 --- a/test/simulate/delegate-lifecycle-simulate.test.ts +++ b/test/simulate/delegate-lifecycle-simulate.test.ts @@ -10,13 +10,15 @@ import { DELEGATE_PERM } from "../helpers/delegate-perms.ts"; import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; -import { assertSimulateMoveAbort, skipSimulateIfOracleTransient } from "../helpers/simulate-assertions.ts"; +import { + assertSimulateMoveAbort, + skipSimulateIfOracleTransient, +} from "../helpers/simulate-assertions.ts"; import { client } from "../helpers/testnet.ts"; import { WATERX_PERP_ABORT } from "../helpers/waterx-perp-error-codes.ts"; /** Not the owner / not a delegate — must fail `place_order_request` permission check. */ -const STRANGER = - "0x2222222222222222222222222222222222222222222222222222222222222222" as const; +const STRANGER = "0x2222222222222222222222222222222222222222222222222222222222222222" as const; const ORDER_COLLATERAL = 10_000_000n; const ORDER_SIZE = 2_000n; @@ -78,9 +80,7 @@ describe("delegate lifecycle (simulate)", () => { } const acc = accounts.find((a) => a.accountId === accountId) ?? accounts[0]!; - const delegate = acc.delegates.find( - (d) => (d.permissions & DELEGATE_PERM.PLACE_ORDER) !== 0, - ); + const delegate = acc.delegates.find((d) => (d.permissions & DELEGATE_PERM.PLACE_ORDER) !== 0); if (!delegate) { ctx.skip( "No delegate with PLACE_ORDER on this account — add one on-chain or extend test account setup.", diff --git a/test/simulate/delegate-permission-matrix-simulate.test.ts b/test/simulate/delegate-permission-matrix-simulate.test.ts index d3447ca..7961cdb 100644 --- a/test/simulate/delegate-permission-matrix-simulate.test.ts +++ b/test/simulate/delegate-permission-matrix-simulate.test.ts @@ -10,11 +10,14 @@ import { DELEGATE_PERM } from "../helpers/delegate-perms.ts"; import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; -import { assertSimulateMoveAbort, skipSimulateIfOracleTransient } from "../helpers/simulate-assertions.ts"; +import { + assertSimulateMoveAbort, + skipSimulateIfOracleTransient, +} from "../helpers/simulate-assertions.ts"; import { client } from "../helpers/testnet.ts"; import { WATERX_PERP_ABORT } from "../helpers/waterx-perp-error-codes.ts"; -const STRANGER = - "0x3333333333333333333333333333333333333333333333333333333333333333" as const; + +const STRANGER = "0x3333333333333333333333333333333333333333333333333333333333333333" as const; describe("delegate permission matrix", () => { it("fixture bits match DELEGATE_PERM constants", () => { diff --git a/test/simulate/prd-product-coverage.test.ts b/test/simulate/prd-product-coverage.test.ts index 654186b..2a2b786 100644 --- a/test/simulate/prd-product-coverage.test.ts +++ b/test/simulate/prd-product-coverage.test.ts @@ -481,9 +481,7 @@ describe("PRD §3.4 — TC-ORDER-004: cancel pending limit (simulate)", () => { if (skipSimulateIfOracleTransient(ctx, outcome.lastResult)) return; const meta = parseSimulateFailure(outcome.lastResult); if (meta?.abortCode === "300") { - ctx.skip( - "testnet orderId raced even after retries — TODO(contracts#cancel-by-key)", - ); + ctx.skip("testnet orderId raced even after retries — TODO(contracts#cancel-by-key)"); return; } assertSimulateSuccess(outcome.lastResult, 20, { transaction: outcome.lastTx }); diff --git a/test/simulate/tx-builders-simulate.test.ts b/test/simulate/tx-builders-simulate.test.ts index 3350596..636a492 100644 --- a/test/simulate/tx-builders-simulate.test.ts +++ b/test/simulate/tx-builders-simulate.test.ts @@ -205,9 +205,7 @@ describe("tx-builders stateful ops (simulate)", () => { if (skipSimulateIfOracleTransient(ctx, outcome.lastResult)) return; const meta = parseSimulateFailure(outcome.lastResult); if (meta?.abortCode === "300") { - ctx.skip( - "testnet orderId raced even after retries — TODO(contracts#cancel-by-key)", - ); + ctx.skip("testnet orderId raced even after retries — TODO(contracts#cancel-by-key)"); return; } assertSimulateSuccess(outcome.lastResult, 20, { transaction: outcome.lastTx }); diff --git a/test/simulate/wlp-simulate.test.ts b/test/simulate/wlp-simulate.test.ts index e7e621c..ae07e42 100644 --- a/test/simulate/wlp-simulate.test.ts +++ b/test/simulate/wlp-simulate.test.ts @@ -10,10 +10,7 @@ import { describe, expect, it } from "vitest"; import type { CollateralAsset } from "../../src/constants.ts"; import { e2eWalletCollateralMinForMintSimulate } from "../helpers/e2e-wlp-readiness.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; -import { - assertSimulateSuccess, - parseSimulateFailure, -} from "../helpers/simulate-assertions.ts"; +import { assertSimulateSuccess, parseSimulateFailure } from "../helpers/simulate-assertions.ts"; import { client } from "../helpers/testnet.ts"; /** `waterx_perp::error::ERedeemNotReady` — settle before 24h (`err_redeem_not_ready`). */ From 1a58c7f9c70c27b09021d387fa477a0ee73f0d20 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Fri, 17 Apr 2026 20:58:07 +0800 Subject: [PATCH 3/9] fix(e2e): align preflight with lifecycle positions and stabilize leverage sim tests - Preflight and e2e:prepare require recent on-chain positions per activeLifecycleTestBases; document persistentPerp coverage for bootstrap/integration. - trading-config: add persistentPerp rows for xStock bases so bootstrap can open slots. - Simulate: use on-chain resize for above-max leverage tests; assertSimulateMoveAbortOneOf for 104/105. - Docs: README and e2e helper comments for preflight vs persistentPerp. Note: .e2e-fixed-positions.local.json left unstaged (local snapshot). Made-with: Cursor --- scripts/README.md | 2 +- scripts/e2e-preflight.ts | 17 ++++--- scripts/e2e-prepare.ts | 4 +- test/README.md | 4 +- test/fixtures/trading/trading-config.json | 44 ++++++++++++++++++- test/helpers/e2e-active-bases.ts | 4 +- test/helpers/e2e-persistent-state.ts | 3 ++ test/helpers/simulate-assertions.ts | 33 ++++++++++++++ test/simulate/prd-product-coverage.test.ts | 23 ++++++---- .../trading-negative-simulate.test.ts | 25 +++++++---- 10 files changed, 130 insertions(+), 29 deletions(-) diff --git a/scripts/README.md b/scripts/README.md index f1e842f..7faf716 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -44,7 +44,7 @@ CI also chains `e2e-preflight.ts` before simulate tests (`test:ci:e2e`). | File | Purpose | | ---- | ------- | -| `e2e-preflight.ts` | Wallet / account / positions / oracle simulate gates before `test:e2e`. | +| `e2e-preflight.ts` | Wallet / account / **required on-chain position per lifecycle base** + cooldown + oracle simulate, before `test:e2e`. | | `e2e-prepare.ts` | TTO split, cooldown, collateral / WLP top-up (needs integration key). | | `bootstrap-e2e-lifecycle-positions.ts` | Open small persistent perp slots per `test/fixtures/trading/trading-config.json`. | | `diagnose-integration-positions.ts` | Inspect reference account positions / refresh local fixed-position hints. | diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index b0e1da8..4f47c18 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -6,7 +6,7 @@ * pnpm e2e:preflight -- --owner 0x... * pnpm e2e:preflight -- --allow-oracle-transient * pnpm e2e:preflight -- --allow-missing-positions - * (treat missing recent open positions as non-blocking — local/optional only; CI is strict) + * (missing on-chain open position for an enabled lifecycle base — non-blocking locally; CI is strict) * pnpm e2e:preflight -- --allow-missing-tto-split * (fewer than 2 funded TTO USDC coins — non-blocking; CI has no key to run e2e:prepare; tests skip as needed) * pnpm e2e:preflight -- --allow-cooldown-not-elapsed @@ -16,8 +16,12 @@ * pnpm e2e:preflight -- --no-update-local-fixed-positions * (skip writing `.e2e-fixed-positions.local.json`; default on local success is to refresh it) * - * Oracle path: one `buildOpenPositionTx` + simulate per enabled lifecycle base (same set as cooldown / - * position checks), not a single hard-coded market. + * Position + cooldown: `activeLifecycleTestBases()` — every enabled scratch/simulate market must have a + * **recent on-chain open position** on the reference account (strict check). Open slots via + * `pnpm e2e:bootstrap-positions` / `persistentPerp.markets` (must cover those bases) or + * `pnpm test:integration:persistent-state`. + * + * Oracle path: same `activeLifecycleTestBases()` set — one `buildOpenPositionTx` + simulate per base. */ import { pathToFileURL } from "node:url"; @@ -267,12 +271,15 @@ export async function runPreflight( const openHit = await resolveE2eOpenPosition(client, accountId, base); if (!openHit) { rows.push({ - name: `${base} recent open position`, + name: `${base} recent open position (required)`, status: "FAIL", kind: "recent_position_missing", base, detail: "No recent open position owned by this account", - action: `Run \`pnpm e2e:bootstrap-positions\` (or integration persistent-state) to create ${base} slot.`, + action: + `Run \`pnpm e2e:bootstrap-positions\` (opens every base in persistentPerp.markets) or ` + + `\`pnpm test:integration:persistent-state\`. Ensure test/fixtures/trading/trading-config.json ` + + `lists each required base under persistentPerp.markets.`, }); continue; } diff --git a/scripts/e2e-prepare.ts b/scripts/e2e-prepare.ts index 1b0cbf3..641c70d 100644 --- a/scripts/e2e-prepare.ts +++ b/scripts/e2e-prepare.ts @@ -2,7 +2,7 @@ * Auto-prepare common e2e prerequisites: * - ensure >= N funded TTO USDC coin objects in UserAccount (default: 2) * - open missing **persistent e2e** perps (`e2e-persistent-state.ts`, includes SOL) when absent - * - wait until cooldown windows elapse for markets that already have open positions + * - wait until cooldown windows elapse for **every** enabled lifecycle base with an open position (same as preflight) * - top up **wallet** WLP + per-collateral coins for `wlp-simulate` (pull from UserAccount when possible) * * Requires integration trader key (same as `pnpm test:integration`). @@ -241,7 +241,7 @@ async function main() { ); } - // 4) Wait for cooldown windows to elapse for existing lifecycle positions. + // 4) Wait for cooldown windows to elapse for enabled lifecycle markets (aligns with e2e:preflight). let maxWaitMs = 0; for (const base of activeLifecycleTestBases()) { const openHit = await resolveE2eOpenPosition(client, accountId, base); diff --git a/test/README.md b/test/README.md index 7777417..4d71c13 100644 --- a/test/README.md +++ b/test/README.md @@ -42,7 +42,7 @@ PRs to `main` run [`.github/workflows/ci.yml`](../.github/workflows/ci.yml): `Li | Command | Purpose | | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- | -| `pnpm e2e:preflight` | Check testnet objects / oracle / **wallet WLP + collaterals** for `wlp-simulate` (`scripts/e2e-preflight.ts`; CI adds `--allow-missing-wlp`) | +| `pnpm e2e:preflight` | Check testnet objects / oracle / **wallet WLP + collaterals** for `wlp-simulate` (`scripts/e2e-preflight.ts`; CI adds `--allow-missing-wlp`). **Requires a recent on-chain open position per `activeLifecycleTestBases()`**; use `e2e:bootstrap-positions` with `persistentPerp.markets` covering those bases. | | `pnpm e2e:prepare` | TTO USDC split, cooldown wait, **wallet WLP + collateral top-up** from account when possible (`scripts/e2e-prepare.ts`) | | `pnpm e2e:bootstrap-positions` | Bootstrap lifecycle positions for e2e | @@ -62,7 +62,7 @@ Simulate tests resolve the reference **`UserAccount`** via **`resolveE2eAccountF 2. Env **`E2E_FIXED_BTC_POSITION_ID`** (and `E2E_FIXED_ETH_POSITION_ID`, …) 3. **`.e2e-fixed-positions.local.json`** (committable) — same `accountId` only; auto-refreshed when you run **`pnpm e2e:preflight`** (runs **even if preflight exits 1**, so stale/missed BTC ids can be captured), **`pnpm e2e:prepare`**, **`pnpm e2e:bootstrap-positions`**, or **`pnpm diagnose:positions`** — skipped on **`GITHUB_ACTIONS`** or if **`E2E_NO_LOCAL_FIXED_POSITIONS=1`** - **CI:** GitHub Actions never writes this file; **`pnpm test:ci:e2e`** uses **strict** preflight. Simulate tests can still skip stateful cases when runtime state is missing, but preflight no longer relaxes missing-position checks. + **CI:** GitHub Actions never writes this file; **`pnpm test:ci:e2e`** uses **strict** preflight. Preflight expects an **on-chain open position for every enabled lifecycle base**; `persistentPerp.markets` should list each so `e2e:bootstrap-positions` can open them. Simulate tests can still skip other stateful cases when runtime state is missing. 4. Fallback: scan the latest **10** global position ids on that market diff --git a/test/fixtures/trading/trading-config.json b/test/fixtures/trading/trading-config.json index 4dd17e9..493e704 100644 --- a/test/fixtures/trading/trading-config.json +++ b/test/fixtures/trading/trading-config.json @@ -248,7 +248,7 @@ } }, "persistentPerp": { - "description": "Target open positions for the integration reference UserAccount (bootstrap / persistent-state tests). Bases without a row here are simulate-only (e.g. xStock). Rows are still filtered by enabledE2eBases.", + "description": "On-chain slots opened by bootstrap / integration persistent-state. Must include every base in enabledE2eBases that has a lifecycle row — e2e:preflight requires a recent open position per activeLifecycleTestBases(). Rows are still filtered by enabledE2eBases.", "markets": { "BTC": { "isLong": true, @@ -286,6 +286,48 @@ "leverage": 4, "openCollateral": "10000000", "openSize": "2000" + }, + "AAPLX": { + "isLong": true, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "GOOGLX": { + "isLong": false, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "METAX": { + "isLong": true, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "NVDAX": { + "isLong": false, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "QQQX": { + "isLong": true, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "SPYX": { + "isLong": false, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "TSLAX": { + "isLong": true, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" } } } diff --git a/test/helpers/e2e-active-bases.ts b/test/helpers/e2e-active-bases.ts index 3e4d3d7..839cce8 100644 --- a/test/helpers/e2e-active-bases.ts +++ b/test/helpers/e2e-active-bases.ts @@ -3,7 +3,9 @@ * * The list is **`enabledE2eBases` in** [test/fixtures/trading/trading-config.json](../fixtures/trading/trading-config.json). * `activeLifecycleTestBases()` intersects this with `lifecycleMarkets` rows and `baseOrder`. - * Persistent perp slots use {@link activeE2ePersistentPerpBases} (intersection with `persistentPerp.markets`). + * Persistent perp slots: {@link activeE2ePersistentPerpBases} (`persistentPerp.markets` ∩ enabled list). + * **`e2e:preflight`** requires on-chain positions for **full** {@link activeLifecycleTestBases} — keep + * `persistentPerp.markets` in sync with every enabled lifecycle base you expect to pass preflight. */ import type { BaseAsset } from "../../src/constants.ts"; import { ENABLED_E2E_BASES } from "./load-trading-fixtures.ts"; diff --git a/test/helpers/e2e-persistent-state.ts b/test/helpers/e2e-persistent-state.ts index 58b1ecf..a1b4bfd 100644 --- a/test/helpers/e2e-persistent-state.ts +++ b/test/helpers/e2e-persistent-state.ts @@ -5,6 +5,9 @@ * * Perp: at least one open position per listed base — rows from * `persistentPerp.markets` in [test/fixtures/trading/trading-config.json](../fixtures/trading/trading-config.json). + * **`pnpm e2e:bootstrap-positions`** opens one slot per {@link activeE2ePersistentPerpBases} (this map ∩ + * `enabledE2eBases`). **`pnpm e2e:preflight`** instead gates on {@link activeLifecycleTestBases} — include + * every such base here so bootstrap can satisfy the check. * WLP: mint when **UserAccount** balance is below `E2E_PERSISTENT_WLP.minBalanceRaw`. * Wallet-level WLP/collateral for simulate is covered by `e2e-wlp-readiness.ts` + preflight/prepare. */ diff --git a/test/helpers/simulate-assertions.ts b/test/helpers/simulate-assertions.ts index 71bff59..f100e8a 100644 --- a/test/helpers/simulate-assertions.ts +++ b/test/helpers/simulate-assertions.ts @@ -285,3 +285,36 @@ export function assertSimulateMoveAbort( ); } } + +/** + * Like {@link assertSimulateMoveAbort}, but the dry-run may abort with any one of several + * codes — e.g. `execute_open_position` checks per-market OI before max leverage, so extreme + * sizing can hit `err_exceed_max_open_interest` (105) before `err_exceed_max_leverage` (104). + */ +export function assertSimulateMoveAbortOneOf( + result: unknown, + alternatives: Array<{ abortCode: number; locationIncludes?: string }>, +): void { + expect(result).toBeDefined(); + const r = result as SimulateResult; + expect(r.$kind, `expected FailedTransaction, got ${String(r.$kind)}`).toBe("FailedTransaction"); + const meta = parseSimulateFailure(result); + expect(meta, "FailedTransaction should yield parseable MoveAbort metadata").not.toBeNull(); + const parsed = + meta!.abortCode != null && meta!.abortCode !== "" ? Number(meta!.abortCode) : Number.NaN; + expect( + Number.isFinite(parsed), + `expected numeric MoveAbort code, got ${meta!.abortCode ?? "(missing)"}; message=${meta!.message}`, + ).toBe(true); + const match = alternatives.find((a) => a.abortCode === parsed); + expect( + match, + `${meta!.message}: expected abort code one of [${alternatives.map((a) => a.abortCode).join(", ")}], got ${parsed}`, + ).toBeDefined(); + if (match!.locationIncludes != null) { + const locText = serializeSimulateResultForDebug(meta!.moveAbortLocation ?? null); + expect(locText, "MoveAbort.location should include expected substring").toContain( + match!.locationIncludes, + ); + } +} diff --git a/test/simulate/prd-product-coverage.test.ts b/test/simulate/prd-product-coverage.test.ts index 2a2b786..91c5e6f 100644 --- a/test/simulate/prd-product-coverage.test.ts +++ b/test/simulate/prd-product-coverage.test.ts @@ -36,6 +36,7 @@ import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts" import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { assertSimulateMoveAbort, + assertSimulateMoveAbortOneOf, assertSimulateSuccess, parseSimulateFailure, skipSimulateIfOracleTransient, @@ -280,30 +281,36 @@ describe("PRD §2.3 — TC-TRADE-003: max leverage vs above-max (per MARKET_DEFI await trySimulate(ctx, tx, 9); }, 90_000); - it(`${base}: open with leverage ${LEVERAGE_ABOVE_MAX} → err_exceed_max_leverage (104)`, async (ctx) => { + it(`${base}: open with leverage ${LEVERAGE_ABOVE_MAX} → 104 (max lev) or 105 (max OI first)`, async (ctx) => { const accountId = await firstAccountId(ctx); if (!accountId) return; - const prices = await lifecycleOracleUsdOrSkip(client, ctx); - if (!prices) return; + if (!(await lifecycleOracleUsdOrSkip(client, ctx))) return; const row = lifecycleRow(base); + // Omit `approxPrice` — use on-chain `resize` (lot-aligned). Off-chain sizing can truncate + // to 0 vs `lot_size`, masking `err_exceed_max_leverage` (104). const tx = await buildOpenPositionTx(client, { accountId, base, isLong: row.isLong, leverage: LEVERAGE_ABOVE_MAX, collateralAmount: row.simulateOpenCollateral, - approxPrice: prices[base], updatePythPrice: true, }); tx.setSender(OWNER); const result = await client.simulate(tx); if (skipSimulateIfOracleTransient(ctx, result)) return; - assertSimulateMoveAbort(result, { - abortCode: WATERX_PERP_ABORT.EXCEED_MAX_LEVERAGE, - locationIncludes: "err_exceed_max_leverage", - }); + assertSimulateMoveAbortOneOf(result, [ + { + abortCode: WATERX_PERP_ABORT.EXCEED_MAX_LEVERAGE, + locationIncludes: "err_exceed_max_leverage", + }, + { + abortCode: WATERX_PERP_ABORT.EXCEED_MAX_OPEN_INTEREST, + locationIncludes: "err_exceed_max_open_interest", + }, + ]); }, 90_000); } }); diff --git a/test/simulate/trading-negative-simulate.test.ts b/test/simulate/trading-negative-simulate.test.ts index b75c21a..7188559 100644 --- a/test/simulate/trading-negative-simulate.test.ts +++ b/test/simulate/trading-negative-simulate.test.ts @@ -1,6 +1,6 @@ /** * Simulate-only negative tests: expect `FailedTransaction` with specific `waterx_perp::error` abort codes. - * Per-base coverage matches `activeLifecycleTestBases()` / PRD TC-TRADE-003 (no SOL-only oracle wording). + * Per-base coverage matches `activeLifecycleTestBases()` / PRD TC-TRADE-003 (104 or 105 per on-chain check order; no SOL-only oracle wording). */ import { buildOpenPositionTx, getAccountsByOwner, getMarketSummary } from "@waterx/perp-sdk"; import { describe, it } from "vitest"; @@ -12,6 +12,7 @@ import { openInvalidSizeAbortPossible } from "../helpers/market-summary-assertio import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { assertSimulateMoveAbort, + assertSimulateMoveAbortOneOf, skipSimulateIfOracleTransient, } from "../helpers/simulate-assertions.ts"; import { clientTxBuildersSimulate as client } from "../helpers/testnet.ts"; @@ -46,29 +47,35 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { for (const base of activeLifecycleTestBases()) { const row = lifecycleRow(base); - it(`${base}: open with leverage ${LEVERAGE_ABOVE_MAX} → err_exceed_max_leverage (104)`, async (ctx) => { + it(`${base}: open with leverage ${LEVERAGE_ABOVE_MAX} → 104 (max lev) or 105 (max OI first)`, async (ctx) => { const accountId = await firstAccountId(ctx); if (!accountId) return; - const prices = await lifecycleOracleUsdOrSkip(client, ctx); - if (!prices) return; + if (!(await lifecycleOracleUsdOrSkip(client, ctx))) return; + // Omit `approxPrice` so size comes from on-chain `resize` (lot-aligned). Off-chain sizing + // can truncate to 0 under `lot_size`, letting the open succeed without 104. const tx = await buildOpenPositionTx(client, { accountId, base, isLong: row.isLong, leverage: LEVERAGE_ABOVE_MAX, collateralAmount: row.simulateOpenCollateral, - approxPrice: prices[base], updatePythPrice: true, }); tx.setSender(OWNER); const result = await client.simulate(tx); if (skipSimulateIfOracleTransient(ctx, result)) return; - assertSimulateMoveAbort(result, { - abortCode: WATERX_PERP_ABORT.EXCEED_MAX_LEVERAGE, - locationIncludes: "err_exceed_max_leverage", - }); + assertSimulateMoveAbortOneOf(result, [ + { + abortCode: WATERX_PERP_ABORT.EXCEED_MAX_LEVERAGE, + locationIncludes: "err_exceed_max_leverage", + }, + { + abortCode: WATERX_PERP_ABORT.EXCEED_MAX_OPEN_INTEREST, + locationIncludes: "err_exceed_max_open_interest", + }, + ]); }, 60_000); it(`${base}: open with collateral below min_coll_value → err_invalid_size (201)`, async (ctx) => { From 28416f0a62938b0cde55fc3717bb529afebb05a5 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Fri, 17 Apr 2026 22:19:32 +0800 Subject: [PATCH 4/9] test: e2e delegate harness, fixtures, and unit coverage - Add setup-e2e-delegate script, ensure-e2e-delegate helper, and simulate coverage for delegate flows; integrate with e2e-preflight, e2e-prepare, and npm scripts. - Update trading fixtures, load-trading-fixtures, and local e2e position metadata; refresh README notes. - Raise unit branch coverage: rawPrice bigint path; account PTB paths for bucketAccount and receiveCoin (v1 shape, amount, empty-input error). Add e2e-delegate-helpers unit tests. Made-with: Cursor --- .e2e-fixed-positions.local.json | 7 ++ package.json | 5 +- scripts/README.md | 3 +- scripts/e2e-preflight.ts | 47 +++++++- scripts/e2e-prepare.ts | 30 +++++ scripts/setup-e2e-delegate.ts | 77 ++++++++++++ test/README.md | 5 +- test/fixtures/trading/trading-config.json | 5 + test/helpers/ensure-e2e-delegate.ts | 113 ++++++++++++++++++ test/helpers/load-trading-fixtures.ts | 12 ++ .../delegate-lifecycle-simulate.test.ts | 2 +- test/simulate/e2e-delegate-simulate.test.ts | 46 +++++++ test/unit/constants.test.ts | 12 ++ test/unit/e2e-delegate-helpers.test.ts | 21 ++++ test/unit/user-account.test.ts | 58 +++++++++ 15 files changed, 435 insertions(+), 8 deletions(-) create mode 100644 scripts/setup-e2e-delegate.ts create mode 100644 test/helpers/ensure-e2e-delegate.ts create mode 100644 test/simulate/e2e-delegate-simulate.test.ts create mode 100644 test/unit/e2e-delegate-helpers.test.ts diff --git a/.e2e-fixed-positions.local.json b/.e2e-fixed-positions.local.json index 8ae16d1..a7b6602 100644 --- a/.e2e-fixed-positions.local.json +++ b/.e2e-fixed-positions.local.json @@ -2,10 +2,17 @@ "version": 1, "accountId": "0xab4795318525c9a6113fcba320a785345f3a8b66c523ec1a517ac040d2cd945b", "positions": { + "AAPLX": 2, "BTC": 6, "ETH": 4, + "GOOGLX": 2, + "METAX": 2, + "NVDAX": 2, + "QQQX": 2, "SOL": 2, + "SPYX": 2, "SUI": 2, + "TSLAX": 2, "WAL": 2 }, "disclaimer": "Auto-generated from public on-chain position ids. Safe to commit. Re-run preflight/bootstrap after closes/liquidations." diff --git a/package.json b/package.json index 4162e20..b8e84d0 100644 --- a/package.json +++ b/package.json @@ -31,8 +31,8 @@ "test:coverage": "vitest run --project unit --project e2e --coverage", "test:ci:unit": "vitest run --project unit --coverage --reporter=verbose --reporter=junit --outputFile=test-results-unit.xml", "test:ci:simulate": "vitest run --project e2e --reporter=verbose --reporter=junit --outputFile=test-results-simulate.xml", - "test:ci:e2e": "tsx scripts/e2e-preflight.ts --allow-oracle-transient --allow-missing-positions --allow-missing-tto-split && pnpm test:ci:simulate", - "test:ci:e2e:coverage": "tsx scripts/e2e-preflight.ts --allow-oracle-transient --allow-missing-positions --allow-missing-tto-split && pnpm test:e2e -- --coverage", + "test:ci:e2e": "tsx scripts/e2e-preflight.ts --allow-oracle-transient --allow-missing-positions --allow-missing-tto-split --allow-missing-e2e-delegate && pnpm test:ci:simulate", + "test:ci:e2e:coverage": "tsx scripts/e2e-preflight.ts --allow-oracle-transient --allow-missing-positions --allow-missing-tto-split --allow-missing-e2e-delegate && pnpm test:e2e -- --coverage", "test:ci:full": "pnpm test:ci:unit && pnpm test:ci:e2e", "test:ci": "pnpm test:ci:full", "diagnose:positions": "tsx scripts/diagnose-integration-positions.ts", @@ -45,6 +45,7 @@ "rewarder:smoke": "tsx scripts/reward-distributor-smoke.ts", "close-all-btc": "tsx scripts/close-all-my-btc-positions.ts", "e2e:bootstrap-positions": "tsx scripts/bootstrap-e2e-lifecycle-positions.ts", + "e2e:setup-delegate": "tsx scripts/setup-e2e-delegate.ts", "lint": "pnpm lint:eslint && pnpm lint:prettier", "lint:eslint": "eslint \"src/**/*.ts\" \"test/**/*.ts\" \"scripts/**/*.ts\"", "lint:prettier": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\" \"scripts/**/*.ts\"", diff --git a/scripts/README.md b/scripts/README.md index 7faf716..2c022fc 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -16,6 +16,7 @@ Operational and admin helpers for WaterX perp on Sui testnet. **v2 is Pyth-only* | `e2e:preflight` | `e2e-preflight.ts` | | `e2e:prepare` | `e2e-prepare.ts` | | `e2e:bootstrap-positions` | `bootstrap-e2e-lifecycle-positions.ts` | +| `e2e:setup-delegate` | `setup-e2e-delegate.ts` — pinned `addDelegate` / `updateDelegatePermissions` (see `trading-config` `e2eDelegate`) | | `diagnose:positions` | `diagnose-integration-positions.ts` | | `oracle:aggregates` | `print-oracle-aggregates.ts` | | `query-output` | `query-output.ts` | @@ -45,7 +46,7 @@ CI also chains `e2e-preflight.ts` before simulate tests (`test:ci:e2e`). | File | Purpose | | ---- | ------- | | `e2e-preflight.ts` | Wallet / account / **required on-chain position per lifecycle base** + cooldown + oracle simulate, before `test:e2e`. | -| `e2e-prepare.ts` | TTO split, cooldown, collateral / WLP top-up (needs integration key). | +| `e2e-prepare.ts` | TTO split, cooldown, collateral / WLP top-up; optional `--ensure-delegate` (needs integration key). | | `bootstrap-e2e-lifecycle-positions.ts` | Open small persistent perp slots per `test/fixtures/trading/trading-config.json`. | | `diagnose-integration-positions.ts` | Inspect reference account positions / refresh local fixed-position hints. | diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index 4f47c18..7778841 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -11,6 +11,8 @@ * (fewer than 2 funded TTO USDC coins — non-blocking; CI has no key to run e2e:prepare; tests skip as needed) * pnpm e2e:preflight -- --allow-cooldown-not-elapsed * (per-market cooldown after last position change — non-blocking; shared testnet account can be “hot”) + * pnpm e2e:preflight -- --allow-missing-e2e-delegate + * (pinned delegate missing PLACE_ORDER — non-blocking when unset in fixture; use once `e2eDelegate` is configured) * pnpm e2e:preflight -- --allow-missing-wlp * (wallet WLP / per-collateral coins — non-blocking only with this flag; CI uses strict preflight) * pnpm e2e:preflight -- --no-update-local-fixed-positions @@ -40,6 +42,10 @@ import { collectE2eWlpReadinessIssues } from "../test/helpers/e2e-wlp-readiness. import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../test/helpers/lifecycle-test-markets.ts"; import { resolveE2eOpenPosition } from "../test/helpers/resolve-e2e-open-position.ts"; +import { + checkE2eDelegateReady, + resolvePinnedE2eDelegateAddress, +} from "../test/helpers/ensure-e2e-delegate.ts"; import { resolveE2eAccountForOwner } from "../test/helpers/resolve-e2e-reference-account.ts"; export type CheckStatus = "OK" | "FAIL"; @@ -51,6 +57,7 @@ export type CheckKind = | "oracle_transient" | "oracle_other" | "wlp_readiness" + | "e2e_delegate_missing" | "info"; export type CheckRow = { @@ -131,6 +138,9 @@ function printRemediationGuide(rows: CheckRow[]) { lines.push( " pnpm e2e:bootstrap-positions # Open lifecycle positions missing on reference account", ); + lines.push( + " pnpm e2e:setup-delegate # Pinned delegate PLACE_ORDER (see trading-config e2eDelegate)", + ); lines.push( " pnpm test:integration:persistent-state # Perp slots + WLP maintenance (optional but thorough)", ); @@ -152,6 +162,7 @@ function isNonBlockingFail( allowMissingWlp: boolean; allowMissingTtoSplit: boolean; allowCooldownNotElapsed: boolean; + allowMissingE2eDelegate: boolean; }, ): boolean { if (r.status !== "FAIL") return false; @@ -160,6 +171,7 @@ function isNonBlockingFail( if (opts.allowMissingWlp && r.kind === "wlp_readiness") return true; if (opts.allowMissingTtoSplit && r.kind === "tto_coin_split") return true; if (opts.allowCooldownNotElapsed && r.kind === "cooldown_not_elapsed") return true; + if (opts.allowMissingE2eDelegate && r.kind === "e2e_delegate_missing") return true; return false; } @@ -171,6 +183,7 @@ export async function runPreflight( allowMissingWlp?: boolean; allowMissingTtoSplit?: boolean; allowCooldownNotElapsed?: boolean; + allowMissingE2eDelegate?: boolean; }, ): Promise { const allowOracleTransient = options?.allowOracleTransient ?? false; @@ -178,6 +191,7 @@ export async function runPreflight( const allowMissingWlp = options?.allowMissingWlp ?? false; const allowMissingTtoSplit = options?.allowMissingTtoSplit ?? false; const allowCooldownNotElapsed = options?.allowCooldownNotElapsed ?? false; + const allowMissingE2eDelegate = options?.allowMissingE2eDelegate ?? false; const client = WaterXClient.testnet(); const rows: CheckRow[] = []; @@ -267,6 +281,30 @@ export async function runPreflight( } } + { + const pinned = resolvePinnedE2eDelegateAddress(); + if (pinned) { + const chk = await checkE2eDelegateReady(client, owner, accountId, pinned); + if (chk.ok) { + rows.push({ + name: `E2E pinned delegate (${pinned.slice(0, 10)}…)`, + status: "OK", + kind: "info", + detail: "PLACE_ORDER (and fixture permissions) satisfied on reference account", + }); + } else { + rows.push({ + name: `E2E pinned delegate (${pinned.slice(0, 10)}…)`, + status: "FAIL", + kind: "e2e_delegate_missing", + detail: chk.detail, + action: + "Run `pnpm e2e:setup-delegate` (owner signs). Set `e2eDelegate` in test/fixtures/trading/trading-config.json or WATERX_E2E_DELEGATE_ADDRESS.", + }); + } + } + } + for (const base of activeLifecycleTestBases()) { const openHit = await resolveE2eOpenPosition(client, accountId, base); if (!openHit) { @@ -370,6 +408,7 @@ export async function runPreflight( allowMissingWlp, allowMissingTtoSplit, allowCooldownNotElapsed, + allowMissingE2eDelegate, }), ).length; const blockingFailCount = failRows.length - nonBlockingFailCount; @@ -392,6 +431,7 @@ async function main() { const allowMissingWlp = argv.includes("--allow-missing-wlp"); const allowMissingTtoSplit = argv.includes("--allow-missing-tto-split"); const allowCooldownNotElapsed = argv.includes("--allow-cooldown-not-elapsed"); + const allowMissingE2eDelegate = argv.includes("--allow-missing-e2e-delegate"); const noUpdateLocalFixed = argv.includes("--no-update-local-fixed-positions"); console.log(`e2e preflight owner=${owner}`); @@ -401,6 +441,7 @@ async function main() { allowMissingWlp, allowMissingTtoSplit, allowCooldownNotElapsed, + allowMissingE2eDelegate, }); printRows(result.rows); console.log(`\nsummary: ${result.okCount} OK, ${result.failCount} FAIL`); @@ -410,7 +451,8 @@ async function main() { allowMissingPositions || allowMissingWlp || allowMissingTtoSplit || - allowCooldownNotElapsed + allowCooldownNotElapsed || + allowMissingE2eDelegate ? " (exit code uses blocking count only; non-blocking kinds match your --allow-* flags)" : " (strict: every FAIL row is blocking)"), ); @@ -442,7 +484,8 @@ async function main() { !allowMissingPositions && !allowMissingWlp && !allowMissingTtoSplit && - !allowCooldownNotElapsed + !allowCooldownNotElapsed && + !allowMissingE2eDelegate ) { printRemediationGuide(result.rows); } diff --git a/scripts/e2e-prepare.ts b/scripts/e2e-prepare.ts index 641c70d..475278e 100644 --- a/scripts/e2e-prepare.ts +++ b/scripts/e2e-prepare.ts @@ -12,6 +12,7 @@ * pnpm e2e:prepare -- --owner 0x... --dry-run * pnpm e2e:prepare -- --no-update-local-fixed-positions * pnpm e2e:prepare -- --no-open-positions # skip opening missing perps (faster if slots exist) + * pnpm e2e:prepare -- --ensure-delegate # add/update pinned delegate (needs e2eDelegate / WATERX_E2E_DELEGATE_ADDRESS) */ import { Transaction } from "@mysten/sui/transactions"; @@ -65,6 +66,7 @@ async function main() { const dryRun = argv.includes("--dry-run"); const noOpenPositions = argv.includes("--no-open-positions"); const noUpdateLocalFixed = argv.includes("--no-update-local-fixed-positions"); + const ensureDelegate = argv.includes("--ensure-delegate"); const ownerArg = parseOwnerArg(argv); const client = WaterXClient.testnet(); @@ -130,6 +132,34 @@ async function main() { console.log("[prepare] --no-open-positions: skipping perp slot check"); } + if (ensureDelegate) { + const { ensureE2eDelegateOnChain, resolvePinnedE2eDelegateAddress } = await import( + "../test/helpers/ensure-e2e-delegate.ts", + ); + if (!resolvePinnedE2eDelegateAddress()) { + console.log( + "[prepare] --ensure-delegate: skip (set trading-config `e2eDelegate.delegateAddress` or WATERX_E2E_DELEGATE_ADDRESS)", + ); + } else { + const d = await ensureE2eDelegateOnChain({ + client, + owner: signerOwner, + accountId, + signer: trader, + dryRun, + execTx, + }); + if (d.outcome === "executed" && "txResult" in d) { + assertSuccess(d.txResult); + console.log(`[prepare] e2e delegate on-chain digest=${d.digest ?? "(unknown)"}`); + } else if (d.outcome === "already_ok") { + console.log("[prepare] e2e delegate already satisfies PLACE_ORDER"); + } else if (d.outcome === "dry_run") { + console.log("[prepare] e2e delegate dry-run (see logs above)"); + } + } + } + // 3) Wallet: collaterals + WLP for `test/simulate/wlp-simulate.test.ts`. if (!dryRun) { const wlpType = client.config.wlpType; diff --git a/scripts/setup-e2e-delegate.ts b/scripts/setup-e2e-delegate.ts new file mode 100644 index 0000000..6355438 --- /dev/null +++ b/scripts/setup-e2e-delegate.ts @@ -0,0 +1,77 @@ +/** + * One-shot: add or update a pinned delegate on the integration reference UserAccount so + * `delegate-lifecycle-simulate` (PLACE_ORDER positive path) and optional preflight checks pass. + * + * Configure address in test/fixtures/trading/trading-config.json → `e2eDelegate.delegateAddress` + * or env `WATERX_E2E_DELEGATE_ADDRESS`. Permissions default to fixture `e2eDelegate.permissions` (12 = PLACE_ORDER|CANCEL_ORDER). + * + * Requires the same key as `pnpm test:integration` (owner must match reference wallet). + * + * Usage: + * pnpm e2e:setup-delegate + * pnpm e2e:setup-delegate -- --dry-run + */ +import { WaterXClient } from "../src/index.ts"; +import { ensureE2eDelegateOnChain, resolvePinnedE2eDelegateAddress } from "../test/helpers/ensure-e2e-delegate.ts"; +import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; +import { ensureUserAccountForIntegration } from "../test/integration/helpers/account-bootstrap.ts"; +import { assertSuccess, execTx, loadIntegrationTraderKeypair } from "../test/integration/setup.ts"; + +function normAddr(a: string): string { + return a.replace(/^0x/i, "").toLowerCase(); +} + +async function main() { + const dryRun = process.argv.includes("--dry-run"); + const trader = loadIntegrationTraderKeypair(); + const owner = trader.getPublicKey().toSuiAddress(); + if (normAddr(owner) !== normAddr(INTEGRATION_REFERENCE_WALLET_ADDRESS)) { + console.error( + `Signer ${owner} does not match INTEGRATION_REFERENCE_WALLET_ADDRESS (${INTEGRATION_REFERENCE_WALLET_ADDRESS}).`, + ); + process.exit(1); + } + + const pinned = resolvePinnedE2eDelegateAddress(); + if (!pinned) { + console.error( + "No pinned delegate address. Set test/fixtures/trading/trading-config.json → e2eDelegate.delegateAddress " + + "or WATERX_E2E_DELEGATE_ADDRESS, then re-run.", + ); + process.exit(1); + } + + const client = WaterXClient.testnet(); + const { accountId } = await ensureUserAccountForIntegration(client, trader, execTx); + + const result = await ensureE2eDelegateOnChain({ + client, + owner, + accountId, + signer: trader, + dryRun, + execTx, + }); + + switch (result.outcome) { + case "already_ok": + console.log( + `[e2e:setup-delegate] OK — delegate ${pinned.slice(0, 12)}… already has PLACE_ORDER on ${accountId.slice(0, 12)}…`, + ); + break; + case "dry_run": + console.log("[e2e:setup-delegate] dry-run done."); + break; + case "executed": + assertSuccess(result.txResult); + console.log(`[e2e:setup-delegate] success digest=${result.digest ?? "(unknown)"}`); + break; + default: + break; + } +} + +main().catch((e) => { + console.error(e); + process.exit(1); +}); diff --git a/test/README.md b/test/README.md index 4d71c13..f263261 100644 --- a/test/README.md +++ b/test/README.md @@ -42,8 +42,9 @@ PRs to `main` run [`.github/workflows/ci.yml`](../.github/workflows/ci.yml): `Li | Command | Purpose | | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- | -| `pnpm e2e:preflight` | Check testnet objects / oracle / **wallet WLP + collaterals** for `wlp-simulate` (`scripts/e2e-preflight.ts`; CI adds `--allow-missing-wlp`). **Requires a recent on-chain open position per `activeLifecycleTestBases()`**; use `e2e:bootstrap-positions` with `persistentPerp.markets` covering those bases. | -| `pnpm e2e:prepare` | TTO USDC split, cooldown wait, **wallet WLP + collateral top-up** from account when possible (`scripts/e2e-prepare.ts`) | +| `pnpm e2e:preflight` | Check testnet objects / oracle / **wallet WLP + collaterals** for `wlp-simulate` (`scripts/e2e-preflight.ts`; CI adds `--allow-missing-wlp`, `--allow-missing-e2e-delegate`). **Requires a recent on-chain open position per `activeLifecycleTestBases()`**; use `e2e:bootstrap-positions` with `persistentPerp.markets` covering those bases. If `e2eDelegate.delegateAddress` or `WATERX_E2E_DELEGATE_ADDRESS` is set, verifies that address has **PLACE_ORDER** on the reference account (`pnpm e2e:setup-delegate`). | +| `pnpm e2e:prepare` | TTO USDC split, cooldown wait, **wallet WLP + collateral top-up** from account when possible (`scripts/e2e-prepare.ts`). Optional `--ensure-delegate` runs `e2e:setup-delegate` logic when `e2eDelegate` / `WATERX_E2E_DELEGATE_ADDRESS` is set. | +| `pnpm e2e:setup-delegate` | Owner-signed **addDelegate** / **updateDelegatePermissions** for the pinned address in `trading-config` `e2eDelegate` (or env). | | `pnpm e2e:bootstrap-positions` | Bootstrap lifecycle positions for e2e | ## Integration (trader) diff --git a/test/fixtures/trading/trading-config.json b/test/fixtures/trading/trading-config.json index 493e704..0668156 100644 --- a/test/fixtures/trading/trading-config.json +++ b/test/fixtures/trading/trading-config.json @@ -330,5 +330,10 @@ "openSize": "2000" } } + }, + "e2eDelegate": { + "description": "Optional pinned delegate for delegate placeOrder simulate + preflight. Leave delegateAddress empty to skip checks. Env WATERX_E2E_DELEGATE_ADDRESS overrides. permissions is u16 bitmask (12 = PLACE_ORDER|CANCEL_ORDER). After setting, run pnpm e2e:setup-delegate (owner signs addDelegate).", + "delegateAddress": "", + "permissions": 12 } } diff --git a/test/helpers/ensure-e2e-delegate.ts b/test/helpers/ensure-e2e-delegate.ts new file mode 100644 index 0000000..b3a6b2f --- /dev/null +++ b/test/helpers/ensure-e2e-delegate.ts @@ -0,0 +1,113 @@ +/** + * Pinned delegate for `e2e:preflight` / `e2e:setup-delegate` / `e2e:prepare --ensure-delegate`. + * Address: `test/fixtures/trading/trading-config.json` → `e2eDelegate.delegateAddress`, overridden by + * `WATERX_E2E_DELEGATE_ADDRESS`. + */ +import { Transaction } from "@mysten/sui/transactions"; +import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; + +import type { WaterXClient } from "../../src/client.ts"; +import { getAccountDelegates } from "../../src/fetch.ts"; +import { addDelegate, updateDelegatePermissions } from "../../src/user/account.ts"; +import { DELEGATE_PERM } from "./delegate-perms.ts"; +import { E2E_DELEGATE_CONFIG } from "./load-trading-fixtures.ts"; + +export function normalizeSuiAddress(a: string): string { + return a.replace(/^0x/i, "").toLowerCase(); +} + +/** Env wins over fixture. Returns undefined if unset — preflight skips delegate check. */ +export function resolvePinnedE2eDelegateAddress(): string | undefined { + const env = process.env.WATERX_E2E_DELEGATE_ADDRESS?.trim(); + if (env) return env; + const a = E2E_DELEGATE_CONFIG.delegateAddress.trim(); + return a || undefined; +} + +export function getE2eDelegateTargetPermissions(): number { + return E2E_DELEGATE_CONFIG.permissions; +} + +export function delegateHasPlaceOrder(permissions: number): boolean { + return (permissions & DELEGATE_PERM.PLACE_ORDER) !== 0; +} + +export async function checkE2eDelegateReady( + client: WaterXClient, + owner: string, + accountId: string, + delegateAddress: string, +): Promise<{ ok: boolean; detail: string }> { + const delegates = await getAccountDelegates(client, owner, accountId); + const want = normalizeSuiAddress(delegateAddress); + const d = delegates.find((x) => normalizeSuiAddress(x.delegateAddress) === want); + if (!d) return { ok: false, detail: "no delegate row for pinned address" }; + if (!delegateHasPlaceOrder(d.permissions)) { + return { ok: false, detail: "PLACE_ORDER permission not set for pinned delegate" }; + } + return { ok: true, detail: "ok" }; +} + +type ExecTx = ( + tx: Transaction, + signer: Ed25519Keypair, + opts?: { gasBudget?: number }, +) => Promise<{ digest?: string; effects?: unknown }>; + +/** + * Ensures the pinned delegate exists with at least target permissions (including PLACE_ORDER). + * Owner must sign. No-op if `resolvePinnedE2eDelegateAddress()` is undefined (caller should skip). + */ +export async function ensureE2eDelegateOnChain(opts: { + client: WaterXClient; + owner: string; + accountId: string; + signer: Ed25519Keypair; + dryRun: boolean; + execTx: ExecTx; + log?: (msg: string) => void; +}): Promise< + | { outcome: "skipped_no_pin" | "dry_run" | "already_ok" } + | { outcome: "executed"; digest?: string; txResult: unknown } +> { + const pinned = resolvePinnedE2eDelegateAddress(); + const log = opts.log ?? console.log; + if (!pinned) return { outcome: "skipped_no_pin" }; + + const targetPerms = getE2eDelegateTargetPermissions(); + const pre = await checkE2eDelegateReady(opts.client, opts.owner, opts.accountId, pinned); + if (pre.ok) return { outcome: "already_ok" }; + + const delegates = await getAccountDelegates(opts.client, opts.owner, opts.accountId); + const want = normalizeSuiAddress(pinned); + const row = delegates.find((x) => normalizeSuiAddress(x.delegateAddress) === want); + + if (opts.dryRun) { + log( + `[e2e-delegate] dry-run: would ${row ? "updateDelegatePermissions" : "addDelegate"} for ${pinned.slice(0, 10)}… (${pre.detail})`, + ); + return { outcome: "dry_run" }; + } + + const tx = new Transaction(); + tx.setSender(opts.owner); + tx.setGasBudget(200_000_000); + + if (!row) { + addDelegate(opts.client, tx, { + accountObjectAddress: opts.accountId, + delegate: pinned, + permissions: targetPerms, + }); + } else { + const merged = row.permissions | targetPerms; + updateDelegatePermissions(opts.client, tx, { + accountObjectAddress: opts.accountId, + delegate: pinned, + newPermissions: merged, + }); + } + + const r = await opts.execTx(tx, opts.signer, { gasBudget: 200_000_000 }); + return { outcome: "executed", digest: r.digest, txResult: r }; +} diff --git a/test/helpers/load-trading-fixtures.ts b/test/helpers/load-trading-fixtures.ts index 5a98a62..fe7689a 100644 --- a/test/helpers/load-trading-fixtures.ts +++ b/test/helpers/load-trading-fixtures.ts @@ -65,6 +65,11 @@ type TradingConfigJson = { } >; }; + e2eDelegate?: { + description?: string; + delegateAddress?: string; + permissions?: number; + }; }; const cfg = raw as TradingConfigJson; @@ -159,6 +164,13 @@ export const E2E_PERSISTENT_WLP = { export const E2E_PERSISTENT_ACCOUNT_BUFFER_USDC = BigInt(cfg.persistentWlp.accountBufferUsdc); +/** Pinned delegate for preflight / `e2e:setup-delegate` (env `WATERX_E2E_DELEGATE_ADDRESS` overrides address). */ +export const E2E_DELEGATE_CONFIG = { + delegateAddress: (cfg.e2eDelegate?.delegateAddress ?? "").trim(), + permissions: + typeof cfg.e2eDelegate?.permissions === "number" ? cfg.e2eDelegate.permissions : 12, +} as const; + /** Min raw WLP on the reference **wallet** so redeem/cancel simulate can pick a coin. */ export function getE2eWalletWlpMinRaw(): bigint { return BigInt(cfg.e2eWallet.wlpMinRaw); diff --git a/test/simulate/delegate-lifecycle-simulate.test.ts b/test/simulate/delegate-lifecycle-simulate.test.ts index 8e7ca99..4690d2a 100644 --- a/test/simulate/delegate-lifecycle-simulate.test.ts +++ b/test/simulate/delegate-lifecycle-simulate.test.ts @@ -83,7 +83,7 @@ describe("delegate lifecycle (simulate)", () => { const delegate = acc.delegates.find((d) => (d.permissions & DELEGATE_PERM.PLACE_ORDER) !== 0); if (!delegate) { ctx.skip( - "No delegate with PLACE_ORDER on this account — add one on-chain or extend test account setup.", + "No delegate with PLACE_ORDER on this account — set `e2eDelegate.delegateAddress` + run `pnpm e2e:setup-delegate` (owner signs), or add delegate on-chain.", ); return; } diff --git a/test/simulate/e2e-delegate-simulate.test.ts b/test/simulate/e2e-delegate-simulate.test.ts new file mode 100644 index 0000000..5baecc2 --- /dev/null +++ b/test/simulate/e2e-delegate-simulate.test.ts @@ -0,0 +1,46 @@ +/** + * Simulate-only checks for pinned delegate configuration (no private key). + * On-chain setup: `pnpm e2e:setup-delegate` (owner signs). + */ +import { getAccountsByOwner } from "@waterx/perp-sdk"; +import { describe, expect, it } from "vitest"; + +import { checkE2eDelegateReady, resolvePinnedE2eDelegateAddress } from "../helpers/ensure-e2e-delegate.ts"; +import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; +import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; +import { client } from "../helpers/testnet.ts"; + +describe("E2E delegate (simulate, fixture-driven)", () => { + it("when pinned address is configured, chain state matches or preflight would FAIL", async (ctx) => { + const pinned = resolvePinnedE2eDelegateAddress(); + if (!pinned) { + ctx.skip("No e2eDelegate.delegateAddress / WATERX_E2E_DELEGATE_ADDRESS — optional."); + return; + } + + const accounts = await getAccountsByOwner(client, INTEGRATION_REFERENCE_WALLET_ADDRESS); + if (!accounts.length) { + ctx.skip("No UserAccount for reference owner"); + return; + } + let accountId: string; + try { + accountId = pickE2eAccountIdForOwner(INTEGRATION_REFERENCE_WALLET_ADDRESS, accounts); + } catch (e) { + ctx.skip(e instanceof Error ? e.message : String(e)); + return; + } + + const chk = await checkE2eDelegateReady( + client, + INTEGRATION_REFERENCE_WALLET_ADDRESS, + accountId, + pinned, + ); + expect( + chk.ok, + chk.detail + + " — run `pnpm e2e:setup-delegate` from a machine with the integration owner key.", + ).toBe(true); + }, 60_000); +}); diff --git a/test/unit/constants.test.ts b/test/unit/constants.test.ts index f3739ed..e07be45 100644 --- a/test/unit/constants.test.ts +++ b/test/unit/constants.test.ts @@ -12,6 +12,7 @@ import { PERM_PLACE_ORDER, PERM_RELEASE_COLLATERAL, PYTH_TESTNET_FEED_IDS, + rawPrice, TESTNET_OBJECTS, TESTNET_PACKAGE_IDS, } from "@waterx/perp-sdk"; @@ -35,6 +36,17 @@ describe("permission bitmasks", () => { }); }); +describe("rawPrice", () => { + it("passes through already-scaled bigint values", () => { + expect(rawPrice(65_000_000_000_000n)).toBe(65_000_000_000_000n); + }); + + it("scales human USD numbers to 1e9 fixed-point", () => { + expect(rawPrice(65_000)).toBe(65_000_000_000_000n); + expect(rawPrice(0.088)).toBe(88_000_000n); + }); +}); + describe("order type tags", () => { it("matches Move convention 0–3", () => { expect(ORDER_LIMIT_BUY).toBe(0); diff --git a/test/unit/e2e-delegate-helpers.test.ts b/test/unit/e2e-delegate-helpers.test.ts new file mode 100644 index 0000000..6b8da16 --- /dev/null +++ b/test/unit/e2e-delegate-helpers.test.ts @@ -0,0 +1,21 @@ +import { describe, expect, it } from "vitest"; + +import { + delegateHasPlaceOrder, + normalizeSuiAddress, +} from "../helpers/ensure-e2e-delegate.ts"; +import { DELEGATE_PERM } from "../helpers/delegate-perms.ts"; + +describe("e2e delegate helpers", () => { + it("normalizeSuiAddress strips 0x and lowercases", () => { + expect(normalizeSuiAddress("0xAbC")).toBe("abc"); + expect(normalizeSuiAddress("F00")).toBe("f00"); + }); + + it("delegateHasPlaceOrder detects bit 4", () => { + expect(delegateHasPlaceOrder(0)).toBe(false); + expect(delegateHasPlaceOrder(DELEGATE_PERM.PLACE_ORDER)).toBe(true); + expect(delegateHasPlaceOrder(DELEGATE_PERM.CANCEL_ORDER)).toBe(false); + expect(delegateHasPlaceOrder(DELEGATE_PERM.PLACE_ORDER | DELEGATE_PERM.CANCEL_ORDER)).toBe(true); + }); +}); diff --git a/test/unit/user-account.test.ts b/test/unit/user-account.test.ts index 41a2c4e..9c6ec59 100644 --- a/test/unit/user-account.test.ts +++ b/test/unit/user-account.test.ts @@ -6,6 +6,7 @@ import { describe, expect, it } from "vitest"; import { WaterXClient } from "../../src/client"; import { PERM_OPEN_POSITION, TESTNET_TYPES } from "../../src/constants"; +import type { CreateAccountParams } from "../../src/user/account"; import { addDelegate, createAccount, @@ -35,6 +36,20 @@ describe("user/account PTB builders", () => { expect(data.commands?.length).toBeGreaterThanOrEqual(1); }); + it("createAccount with params uses request_with_account when bucketAccount is an object id string", () => { + const tx = new Transaction(); + const params: CreateAccountParams = { name: "shared-acct", bucketAccount: PTB_DUMMY_OBJECT_DD }; + createAccount(client, tx, params); + expect(tx.getData().commands?.length).toBeGreaterThanOrEqual(2); + }); + + it("createAccount with params uses request_with_account when bucketAccount is a PTB argument", () => { + const tx = new Transaction(); + const bucket = tx.object(PTB_DUMMY_OBJECT_DD); + createAccount(client, tx, { name: "arg-acct", bucketAccount: bucket }); + expect(tx.getData().commands?.length).toBeGreaterThanOrEqual(2); + }); + it("transferToAccount appends transfer_coin move call", () => { const tx = new Transaction(); transferToAccount(client, tx, { @@ -68,6 +83,49 @@ describe("user/account PTB builders", () => { expect(data.commands?.length).toBeGreaterThanOrEqual(1); }); + it("receiveCoin accepts v1 single-coin shape (coinObjectId triple)", () => { + const tx = new Transaction(); + receiveCoin(client, tx, { + accountObjectAddress: accountId, + coinObjectId: PTB_DUMMY_LP_COIN_EE, + coinType: TESTNET_TYPES.USDC, + }); + expect(tx.getData().commands?.length).toBeGreaterThanOrEqual(1); + }); + + it("receiveCoin v1 shape uses explicit version and digest when provided", () => { + const tx = new Transaction(); + receiveCoin(client, tx, { + accountObjectAddress: accountId, + coinObjectId: PTB_DUMMY_LP_COIN_EE, + coinVersion: 2n, + coinDigest: "abc", + coinType: TESTNET_TYPES.USDC, + }); + expect(tx.getData().commands?.length).toBeGreaterThanOrEqual(1); + }); + + it("receiveCoin passes optional amount into option u64", () => { + const tx = new Transaction(); + receiveCoin(client, tx, { + accountObjectAddress: accountId, + coins: [{ objectId: PTB_DUMMY_LP_COIN_EE, version: "1", digest: "digest" }], + coinType: TESTNET_TYPES.USDC, + amount: 1_000_000n, + }); + expect(tx.getData().commands?.length).toBeGreaterThanOrEqual(1); + }); + + it("receiveCoin throws when neither coins nor v1 coinObjectId is provided", () => { + const tx = new Transaction(); + expect(() => + receiveCoin(client, tx, { + accountObjectAddress: accountId, + coinType: TESTNET_TYPES.USDC, + }), + ).toThrow(/receiveCoin: pass `coins/); + }); + it("addDelegate", () => { const tx = new Transaction(); addDelegate(client, tx, { From efd90d1885b4069f57544b70968c0d3bc2b3a574 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Fri, 17 Apr 2026 23:18:02 +0800 Subject: [PATCH 5/9] test(e2e): trading fixtures, lifecycle harness, and diagnostic scripts - Extend e2e-prepare, e2e-preflight, and bootstrap-e2e-lifecycle-positions - Add check-account-usdsui, check-eth-sui-positions, close-legacy-collateral-mismatch - Add e2e-tto-split-thresholds helper; update persistent state and scratch scenarios - Refresh integration/simulate tests and trading-config fixture; update docs - Remove scripts/clear-supra-weights.sh Made-with: Cursor --- .e2e-fixed-positions.local.json | 4 +- CLAUDE.md | 3 +- MIGRATION.md | 4 +- scripts/README.md | 8 +-- scripts/bootstrap-e2e-lifecycle-positions.ts | 43 +++++++++-- scripts/check-account-usdsui.ts | 21 ++++++ scripts/check-eth-sui-positions.ts | 17 +++++ scripts/clear-supra-weights.sh | 55 -------------- scripts/close-legacy-collateral-mismatch.ts | 72 +++++++++++++++++++ scripts/e2e-preflight.ts | 46 ++++++++++-- scripts/e2e-prepare.ts | 56 +++++++++++++-- scripts/print-oracle-aggregates.ts | 15 +++- test/fixtures/trading/trading-config.json | 8 ++- test/helpers/e2e-persistent-perp-slots.ts | 2 + test/helpers/e2e-persistent-state.ts | 26 +++++-- test/helpers/e2e-tto-split-thresholds.ts | 30 ++++++++ test/helpers/lifecycle-test-markets.ts | 6 +- test/helpers/load-trading-fixtures.ts | 12 ++++ ...un-scratch-trading-scenario-integration.ts | 9 +++ .../run-scratch-trading-scenario-simulate.ts | 11 ++- test/helpers/scratch-trading-scenarios.ts | 5 +- test/integration/helpers/account-bootstrap.ts | 33 ++++++--- test/integration/helpers/scratch-lifecycle.ts | 31 +++++--- .../user/trader-e2e-persistent-state.test.ts | 17 +++-- .../user/trader-position-lifecycle.test.ts | 10 ++- test/simulate/prd-product-coverage.test.ts | 6 ++ .../trading-negative-simulate.test.ts | 2 + test/simulate/tx-builders-simulate.test.ts | 4 +- 28 files changed, 433 insertions(+), 123 deletions(-) create mode 100644 scripts/check-account-usdsui.ts create mode 100644 scripts/check-eth-sui-positions.ts delete mode 100755 scripts/clear-supra-weights.sh create mode 100644 scripts/close-legacy-collateral-mismatch.ts create mode 100644 test/helpers/e2e-tto-split-thresholds.ts diff --git a/.e2e-fixed-positions.local.json b/.e2e-fixed-positions.local.json index a7b6602..8f7ae87 100644 --- a/.e2e-fixed-positions.local.json +++ b/.e2e-fixed-positions.local.json @@ -4,14 +4,14 @@ "positions": { "AAPLX": 2, "BTC": 6, - "ETH": 4, + "ETH": 20, "GOOGLX": 2, "METAX": 2, "NVDAX": 2, "QQQX": 2, "SOL": 2, "SPYX": 2, - "SUI": 2, + "SUI": 13, "TSLAX": 2, "WAL": 2 }, diff --git a/CLAUDE.md b/CLAUDE.md index 0e0276f..60c1147 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -178,7 +178,7 @@ Each `PriceAggregator` has `PythRule` set via `set_rule_weight` SDK flow in `tx-builders.ts`: `buildOracleFeed(client, tx, tokenType, aggregatorId, priceInfoObjectId)` creates a collector, feeds Pyth (optionally preceded by Hermes update), then aggregates. -> **Legacy Supra**: dropped in v2. The SDK has no `utils/supra.ts` and no `supraRule*` / `supraOracleHolder` config fields. `scripts/clear-supra-weights.sh` removes the stale `SupraRule` weight from any v1-era collateral aggregators. +> **Legacy Supra**: dropped in v2. The SDK has no `utils/supra.ts` and no `supraRule*` / `supraOracleHolder` config fields. If an ancient deployment still had `SupraRule` weight on collateral aggregators, that had to be zeroed for Pyth-only aggregation (no helper script in-repo anymore). ## Contract Packages @@ -276,7 +276,6 @@ All setup scripts are admin-gated and assume `sui client active-address` owns th | ------ | ------- | | `setup-markets.sh` | One PTB per market_symbol: `aggregator::new` + `set_rule_weight` + share + `pyth_rule::set_identifier` + `trading::create_market` + share. Re-runnable per row. | | `setup-wlp-tokens.sh` | Registers USDC + USDSUI as WLP deposit tokens via `lp_pool::add_token` (stablecoin defaults). | -| `clear-supra-weights.sh` | Drops the legacy `SupraRule` weight from the USDC + USDSUI `PriceAggregator`s (Pyth-only in v2). | | `create-markets.ts` | Admin TS wrapper around `trading::create_market` for all 13 markets (superseded by `setup-markets.sh` for greenfield setup). | | `market-params.ts` | v2 schema: `minCollValue`, `u128` OI, no `lot_size` / `size_decimal`. | | `setup-pyth-tolerance.sh` | Sets `pyth_rule::set_tolerance_sec` per token type (crypto=310s, xStock=310s, stables=large). | diff --git a/MIGRATION.md b/MIGRATION.md index 1611c78..b44b7ec 100644 --- a/MIGRATION.md +++ b/MIGRATION.md @@ -376,7 +376,7 @@ Off-chain event consumers MUST update parsers accordingly. |---|---|---| | Create all markets | `create-markets.ts` (plus manual Pyth setup) | `setup-markets.sh` (one PTB per market: aggregator + Pyth weight + share + Pyth identifier + create_market + share) | | Wire Pyth per-token | `setup-oracle.ts`, `setup-pyth-identifiers.sh`, legacy `setup-supra-oracle.sh` | `setup-markets.sh` + `setup-pyth-identifiers.sh` (Pyth-only); Supra setup script removed | -| Clear legacy Supra weights | — | `clear-supra-weights.sh` | +| Clear legacy Supra weights | — | (one-time; zero `SupraRule` weight via admin if any v1 collateral aggregators still had it — no repo script) | | Register WLP deposit tokens | — | `setup-wlp-tokens.sh` (USDC + USDSUI via `lp_pool::add_token`) | | Refresh Pyth prices (ops) | (manual) | `update-pyth-prices.ts` | @@ -431,5 +431,5 @@ Run `pnpm codegen` after pulling contract updates. Generated `src/generated/` is ### On-chain operational steps -- [ ] If you had `supra_rule::SupraRule` weight on any collateral aggregator, run `./scripts/clear-supra-weights.sh` (otherwise `aggregator::aggregate` aborts with `err_missing_price_source (201)`). +- [ ] If you still had `supra_rule::SupraRule` weight on any collateral aggregator from v1, zero it with an admin PTB (`aggregator::set_rule_weight`) so only `PythRule` contributes — otherwise `aggregator::aggregate` can abort with `err_missing_price_source (201)`. - [ ] Before first WLP mint, run `./scripts/setup-wlp-tokens.sh` to register USDC + USDSUI (otherwise `mint_wlp` aborts with `err_token_not_supported (401)`). diff --git a/scripts/README.md b/scripts/README.md index 2c022fc..41e402d 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -1,6 +1,6 @@ # Scripts -Operational and admin helpers for WaterX perp on Sui testnet. **v2 is Pyth-only** on the SDK path; legacy Supra cleanup is a one-shot shell script only. +Operational and admin helpers for WaterX perp on Sui testnet. **v2 is Pyth-only** on the SDK path. ## Prerequisites @@ -73,12 +73,6 @@ CI also chains `e2e-preflight.ts` before simulate tests (`test:ci:e2e`). | `fix-generated-imports.ts` | Post-`sui-ts-codegen` import normalization (used by `pnpm codegen`). | | `query-output.ts` | Dump SDK query results to `query-output/*.json`. | -### Legacy migration - -| File | Purpose | -| ---- | ------- | -| `clear-supra-weights.sh` | **One-shot**: zero `SupraRule` weight on USDC/USDSUI aggregators after v2 migration. Remove when no longer needed on your network. | - ## Adding a new market (high level) 1. Extend `BaseAsset` / `TESTNET_MARKETS` in `src/constants.ts`. diff --git a/scripts/bootstrap-e2e-lifecycle-positions.ts b/scripts/bootstrap-e2e-lifecycle-positions.ts index 9d96f0d..dd599db 100644 --- a/scripts/bootstrap-e2e-lifecycle-positions.ts +++ b/scripts/bootstrap-e2e-lifecycle-positions.ts @@ -27,10 +27,11 @@ import { } from "../test/helpers/e2e-persistent-perp-slots.ts"; import { activeE2ePersistentPerpBases, - e2ePersistentMinAccountUsdcRough, + e2ePersistentMinAccountCollateralRough, } from "../test/helpers/e2e-persistent-state.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; import { + buildDepositCollateralFromWalletTx, buildDepositUsdcFromWalletTx, ensureUserAccountForIntegration, } from "../test/integration/helpers/account-bootstrap.ts"; @@ -60,8 +61,8 @@ function parseArgs(argv: string[]) { }; } -function bootstrapMinAccountUsdc(): bigint { - return e2ePersistentMinAccountUsdcRough(); +function bootstrapMinAccountRough() { + return e2ePersistentMinAccountCollateralRough(); } async function main() { @@ -83,7 +84,10 @@ async function main() { const { accountId } = await ensureUserAccountForIntegration(client, trader, execTx); const usdcType = client.config.collaterals.USDC.type; - const minUsdc = bootstrapMinAccountUsdc(); + const usdsuiType = client.config.collaterals.USDSUI.type; + const rough = bootstrapMinAccountRough(); + const minUsdc = rough.minUsdc; + const minUsdsui = rough.minUsdsui; let balance = await getAccountBalance(client, accountId, usdcType); if (balance < minUsdc) { @@ -107,6 +111,37 @@ async function main() { throw new Error(`Account USDC still below ${minUsdc} after deposit attempt (have ${balance}).`); } + if (minUsdsui > 0n) { + let balSui = await getAccountBalance(client, accountId, usdsuiType); + if (balSui < minUsdsui) { + const need = minUsdsui - balSui; + if (dryRun) { + console.log( + `[dry-run] Would deposit ${need} USDSUI (raw); account has ${balSui}, need ${minUsdsui}.`, + ); + } else { + console.log( + `Depositing ${need} USDSUI (raw) from wallet into account ${accountId.slice(0, 12)}…`, + ); + const depTx = await buildDepositCollateralFromWalletTx( + client, + owner, + accountId, + need, + "USDSUI", + ); + const depResult = await execTx(depTx, trader, { gasBudget: 50_000_000 }); + assertSuccess(depResult); + balSui = await getAccountBalance(client, accountId, usdsuiType); + } + } + if (!dryRun && balSui < minUsdsui) { + throw new Error( + `Account USDSUI still below ${minUsdsui} after deposit attempt (have ${balSui}).`, + ); + } + } + const bases = activeE2ePersistentPerpBases(); console.log( `Account ${accountId.slice(0, 14)}… | USDC balance ${balance} | markets: ${bases.join(", ")}`, diff --git a/scripts/check-account-usdsui.ts b/scripts/check-account-usdsui.ts new file mode 100644 index 0000000..943e260 --- /dev/null +++ b/scripts/check-account-usdsui.ts @@ -0,0 +1,21 @@ +import { WaterXClient, getAccountCoins, getAccountBalance } from "../src/index.ts"; +import { INTEGRATION_REFERENCE_USER_ACCOUNT_ID } from "../test/helpers/integration-reference-wallet.ts"; + +async function main() { + const client = WaterXClient.testnet(); + const accountId = INTEGRATION_REFERENCE_USER_ACCOUNT_ID; + const usdsuiType = client.config.collaterals.USDSUI.type; + const usdcType = client.config.collaterals.USDC.type; + + const usdsuiCoins = await getAccountCoins(client, accountId, usdsuiType); + const usdsuiBal = await getAccountBalance(client, accountId, usdsuiType); + const usdcCoins = await getAccountCoins(client, accountId, usdcType); + const usdcBal = await getAccountBalance(client, accountId, usdcType); + + console.log(`accountId=${accountId}`); + console.log(`USDSUI balance=${usdsuiBal}, coins=${usdsuiCoins.length}`); + for (const c of usdsuiCoins) console.log(` - ${c.objectId} = ${c.balance}`); + console.log(`USDC balance=${usdcBal}, coins=${usdcCoins.length}`); + for (const c of usdcCoins) console.log(` - ${c.objectId} = ${c.balance}`); +} +main().catch((e) => { console.error(e); process.exit(1); }); diff --git a/scripts/check-eth-sui-positions.ts b/scripts/check-eth-sui-positions.ts new file mode 100644 index 0000000..89e3d1c --- /dev/null +++ b/scripts/check-eth-sui-positions.ts @@ -0,0 +1,17 @@ +import { WaterXClient } from "../src/index.ts"; +import { getPosition } from "../src/fetch.ts"; + +async function main() { + const client = WaterXClient.testnet(); + for (const base of ["ETH", "SUI"] as const) { + const entry = client.getMarketEntry(base); + const pid = base === "ETH" ? 4n : 2n; + const info = await getPosition(client, entry.marketId, pid, entry.baseType); + console.log(`${base} position ${pid}:`); + console.log(` collateralType: ${info.collateralType}`); + console.log(` collateralAmount: ${info.collateralAmount}`); + console.log(` size: ${info.size}`); + console.log(` isLong: ${info.isLong}`); + } +} +main().catch((e) => { console.error(e); process.exit(1); }); diff --git a/scripts/clear-supra-weights.sh b/scripts/clear-supra-weights.sh deleted file mode 100755 index fe181e4..0000000 --- a/scripts/clear-supra-weights.sh +++ /dev/null @@ -1,55 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail - -# Legacy migration (one-shot): run after upgrading testnet aggregators to Pyth-only v2. -# Once all collateral `PriceAggregator`s have no SupraRule weight on-chain, delete this script. -# -# Drop the legacy SupraRule weight from the USDC + USDSUI collateral PriceAggregators -# so v2 (Pyth-only) `aggregate()` calls stop failing with err_missing_price_source (201). -# -# Setting `set_rule_weight(weight=0)` removes the rule from the aggregator's -# weights map (see bucket_v2_oracle::aggregator::set_rule_weight). -# -# Requires `sui client active-address` to own the ListingCap. -# -# Usage: ./scripts/clear-supra-weights.sh - -# ── Package IDs ───────────────────────────────────────────────────── -ORACLE_PKG="0xa00eb6c923368aef9aade69d75b348f53dc2ee344771ce3c3629dee05a0fb88c" -# Legacy supra_rule package (defines the SupraRule witness type — type identity persists on-chain). -SUPRA_RULE_PKG="0xde280cdb680998d632cca7a1972627854aae9b4acf4cf254fc541395e9471b6d" - -# ── Owned objects ─────────────────────────────────────────────────── -LISTING_CAP="0xa5d55065e5f4dda8d17213e425176198332ac639dee5b732c1892a4d8cc49854" - -# ── Collateral types (TESTNET_COLLATERALS) ────────────────────────── -USDC_TYPE="0x7ccd477e884ec74f960b23a8b34b7d87999e4d7ee0dde738a0c25f46200f201a::mock_usdc::MOCK_USDC" -USDSUI_TYPE="0xc0fad30bc21babe3b8b51c6a4c380d27b61a47e34b26968daf20315da0e35016::mock_usdsui::MOCK_USDSUI" - -# ── Collateral PriceAggregator IDs (TESTNET_COLLATERALS.aggregatorId) ── -USDC_AGG="0x6f9cd2133e7073376ac4de314873e625a8606bddb4daa33affd0a08933b8b2a7" -USDSUI_AGG="0x861d7fe0e5130ca818481f32eff768be1e097c897aa0c35ed9ae10d3f0553179" - -SUPRA_WITNESS="${SUPRA_RULE_PKG}::supra_rule::SupraRule" -GAS=200000000 - -clear_supra() { - local label="$1" - local token_type="$2" - local agg_id="$3" - - echo "" - echo "=== ${label}: set_rule_weight<${label}, SupraRule>(0) → drop from weights ===" - - sui client ptb \ - --move-call "${ORACLE_PKG}::aggregator::set_rule_weight" "<${token_type},${SUPRA_WITNESS}>" \ - "@${agg_id}" "@${LISTING_CAP}" "0u8" \ - --gas-budget ${GAS} - sleep 1 -} - -clear_supra "USDC" "${USDC_TYPE}" "${USDC_AGG}" -clear_supra "USDSUI" "${USDSUI_TYPE}" "${USDSUI_AGG}" - -echo "" -echo "Done. Both collateral aggregators are now Pyth-only." diff --git a/scripts/close-legacy-collateral-mismatch.ts b/scripts/close-legacy-collateral-mismatch.ts new file mode 100644 index 0000000..4e0a21a --- /dev/null +++ b/scripts/close-legacy-collateral-mismatch.ts @@ -0,0 +1,72 @@ +/** + * One-off: close legacy USDC-backed ETH/SUI positions on the reference UserAccount so + * `e2e:prepare` can re-open them with USDSUI margin (per current trading-config.json). + * + * Safe to re-run: skips positions that are already closed / wrong collateral. + */ +import type { BaseAsset, CollateralAsset } from "../src/constants.ts"; +import { getPosition, positionExists } from "../src/fetch.ts"; +import { buildClosePositionTx } from "../src/tx-builders.ts"; +import { INTEGRATION_REFERENCE_USER_ACCOUNT_ID } from "../test/helpers/integration-reference-wallet.ts"; +import { + assertSuccess, + client, + execTx, + loadIntegrationTraderKeypair, + sleep, +} from "../test/integration/setup.ts"; + +type Target = { base: BaseAsset; positionId: number; collateral: CollateralAsset }; + +const TARGETS: Target[] = [ + { base: "ETH", positionId: 4, collateral: "USDC" }, + { base: "SUI", positionId: 2, collateral: "USDC" }, +]; + +async function main() { + const signer = loadIntegrationTraderKeypair(); + const accountId = INTEGRATION_REFERENCE_USER_ACCOUNT_ID; + + for (const t of TARGETS) { + const entry = client.getMarketEntry(t.base); + const exists = await positionExists(client, entry.marketId, t.positionId, entry.baseType); + if (!exists) { + console.log(`[skip] ${t.base} position ${t.positionId}: does not exist`); + continue; + } + const info = await getPosition(client, entry.marketId, t.positionId, entry.baseType); + if (info.size === 0n) { + console.log(`[skip] ${t.base} position ${t.positionId}: already closed (size=0)`); + continue; + } + const collType = client.config.collaterals[t.collateral].type; + const norm = (s: string) => s.replace(/^0x/i, "").toLowerCase(); + if (norm(info.collateralType) !== norm(collType)) { + console.log( + `[skip] ${t.base} position ${t.positionId}: collateralType mismatch (on-chain=${info.collateralType}, expected=${collType})`, + ); + continue; + } + + console.log( + `[close] ${t.base} position ${t.positionId} collateral=${t.collateral} amount=${info.collateralAmount} size=${info.size}`, + ); + const tx = await buildClosePositionTx(client, { + accountId, + base: t.base, + positionId: t.positionId, + collateral: t.collateral, + acceptablePrice: 0, + updatePythPrice: true, + }); + const r = await execTx(tx, signer, { gasBudget: 200_000_000 }); + assertSuccess(r); + console.log(`[ok] ${t.base} position ${t.positionId} closed digest=${r.digest}`); + await sleep(800); + } +} + +main().catch((e) => { + console.error(e); + process.exit(1); +}); diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index 7778841..86f9d33 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -23,6 +23,9 @@ * `pnpm e2e:bootstrap-positions` / `persistentPerp.markets` (must cover those bases) or * `pnpm test:integration:persistent-state`. * + * TTO split: **USDC** always (≥2 coins ≥ threshold). **USDSUI** same check when any lifecycle row uses + * `collateralAsset: USDSUI` (see `e2e-tto-split-thresholds.ts`). + * * Oracle path: same `activeLifecycleTestBases()` set — one `buildOpenPositionTx` + simulate per base. */ import { pathToFileURL } from "node:url"; @@ -38,6 +41,10 @@ import { persistE2eFixedPositionsLocal, shouldAutoPersistLocalFixedPositions, } from "../test/helpers/e2e-fixed-positions-persist.ts"; +import { + e2eTtoMinFundedPerCoinUsdc, + e2eTtoMinFundedPerCoinUsdsui, +} from "../test/helpers/e2e-tto-split-thresholds.ts"; import { collectE2eWlpReadinessIssues } from "../test/helpers/e2e-wlp-readiness.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../test/helpers/lifecycle-test-markets.ts"; @@ -52,6 +59,7 @@ export type CheckStatus = "OK" | "FAIL"; export type CheckKind = | "user_account_missing" | "tto_coin_split" + | "tto_usdsui_coin_split" | "recent_position_missing" | "cooldown_not_elapsed" | "oracle_transient" @@ -169,7 +177,11 @@ function isNonBlockingFail( if (opts.allowOracleTransient && r.kind === "oracle_transient") return true; if (opts.allowMissingPositions && r.kind === "recent_position_missing") return true; if (opts.allowMissingWlp && r.kind === "wlp_readiness") return true; - if (opts.allowMissingTtoSplit && r.kind === "tto_coin_split") return true; + if ( + opts.allowMissingTtoSplit && + (r.kind === "tto_coin_split" || r.kind === "tto_usdsui_coin_split") + ) + return true; if (opts.allowCooldownNotElapsed && r.kind === "cooldown_not_elapsed") return true; if (opts.allowMissingE2eDelegate && r.kind === "e2e_delegate_missing") return true; return false; @@ -232,10 +244,7 @@ export async function runPreflight( const usdcType = client.config.collaterals.USDC.type; const usdcCoins = await getAccountCoins(client, accountId, usdcType); const usdcBalance = await getAccountBalance(client, accountId, usdcType); - const minFundedPerCoin = activeLifecycleTestBases().reduce((acc, base) => { - const inc = lifecycleRow(base).e2ePtb.increaseCollateral; - return inc > acc ? inc : acc; - }, 5_000_000n); + const minFundedPerCoin = e2eTtoMinFundedPerCoinUsdc(); const fundedCoinCount = usdcCoins.filter((c) => BigInt(c.balance) >= minFundedPerCoin).length; if (fundedCoinCount >= 2) { rows.push({ @@ -254,6 +263,32 @@ export async function runPreflight( }); } + const minUsdsuiPerCoin = e2eTtoMinFundedPerCoinUsdsui(); + if (minUsdsuiPerCoin !== null) { + const usdsuiType = client.config.collaterals.USDSUI.type; + const usdsuiCoins = await getAccountCoins(client, accountId, usdsuiType); + const usdsuiBalance = await getAccountBalance(client, accountId, usdsuiType); + const fundedUsdsui = usdsuiCoins.filter((c) => BigInt(c.balance) >= minUsdsuiPerCoin).length; + if (fundedUsdsui >= 2) { + rows.push({ + name: "TTO USDSUI coin split readiness", + status: "OK", + kind: "info", + detail: `fundedCoins>=${minUsdsuiPerCoin}: ${fundedUsdsui} (balance=${usdsuiBalance})`, + }); + } else { + rows.push({ + name: "TTO USDSUI coin split readiness", + status: "FAIL", + kind: "tto_usdsui_coin_split", + detail: `need >=2 funded TTO coins (>=${minUsdsuiPerCoin}), now=${fundedUsdsui} (balance=${usdsuiBalance})`, + action: + "Deposit/split USDSUI into at least 2 TTO coin objects (or run `pnpm e2e:prepare`). " + + "Fund the integration wallet with mock USDSUI on testnet if deposits fail.", + }); + } + } + { const wlpIssues = await collectE2eWlpReadinessIssues(client, owner); if (wlpIssues.length === 0) { @@ -355,6 +390,7 @@ export async function runPreflight( base, isLong: row.isLong, collateralAmount: row.e2ePtb.openCollateral, + collateral: row.collateralAsset, size: row.e2ePtb.openSize, }); tx.setSender(owner); diff --git a/scripts/e2e-prepare.ts b/scripts/e2e-prepare.ts index 475278e..e76d30c 100644 --- a/scripts/e2e-prepare.ts +++ b/scripts/e2e-prepare.ts @@ -1,6 +1,7 @@ /** * Auto-prepare common e2e prerequisites: - * - ensure >= N funded TTO USDC coin objects in UserAccount (default: 2) + * - ensure >= N funded TTO USDC coin objects in UserAccount (default: 2), and the same for USDSUI + * when any `lifecycleMarkets` row uses `collateralAsset: USDSUI` * - open missing **persistent e2e** perps (`e2e-persistent-state.ts`, includes SOL) when absent * - wait until cooldown windows elapse for **every** enabled lifecycle base with an open position (same as preflight) * - top up **wallet** WLP + per-collateral coins for `wlp-simulate` (pull from UserAccount when possible) @@ -27,6 +28,10 @@ import { persistE2eFixedPositionsLocal, shouldAutoPersistLocalFixedPositions, } from "../test/helpers/e2e-fixed-positions-persist.ts"; +import { + e2eTtoMinFundedPerCoinUsdc, + e2eTtoMinFundedPerCoinUsdsui, +} from "../test/helpers/e2e-tto-split-thresholds.ts"; import { ensureE2ePersistentPerpSlots } from "../test/helpers/e2e-persistent-perp-slots.ts"; import { E2E_WALLET_WLP_MIN_RAW, @@ -34,9 +39,10 @@ import { sumWalletCoinBalance, } from "../test/helpers/e2e-wlp-readiness.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; -import { activeLifecycleTestBases, lifecycleRow } from "../test/helpers/lifecycle-test-markets.ts"; +import { activeLifecycleTestBases } from "../test/helpers/lifecycle-test-markets.ts"; import { resolveE2eOpenPosition } from "../test/helpers/resolve-e2e-open-position.ts"; import { + buildDepositCollateralFromWalletTx, buildDepositUsdcFromWalletTx, ensureUserAccountForIntegration, } from "../test/integration/helpers/account-bootstrap.ts"; @@ -81,10 +87,8 @@ async function main() { const { accountId } = await ensureUserAccountForIntegration(client, trader, execTx); const usdcType = client.config.collaterals.USDC.type; - const minFundedPerCoin = activeLifecycleTestBases().reduce((acc, base) => { - const inc = lifecycleRow(base).e2ePtb.increaseCollateral; - return inc > acc ? inc : acc; - }, 5_000_000n); + const minFundedPerCoin = e2eTtoMinFundedPerCoinUsdc(); + const minUsdsuiPerCoin = e2eTtoMinFundedPerCoinUsdsui(); // 1) Ensure at least 2 funded TTO USDC coin objects. const coins = await getAccountCoins(client, accountId, usdcType); @@ -113,6 +117,37 @@ async function main() { console.log(`[prepare] funded TTO USDC coin readiness OK (${funded} >= 2)`); } + // 1b) Same for USDSUI when lifecycle rows use USDSUI margin (stateful / split-coin paths). + if (minUsdsuiPerCoin !== null) { + const usdsuiType = client.config.collaterals.USDSUI.type; + const usdsuiCoins = await getAccountCoins(client, accountId, usdsuiType); + const fundedSui = usdsuiCoins.filter((c) => BigInt(c.balance) >= minUsdsuiPerCoin).length; + if (fundedSui < 2) { + const need = 2 - fundedSui; + console.log( + `[prepare] funded TTO USDSUI coins=${fundedSui}, need +${need} (threshold=${minUsdsuiPerCoin})`, + ); + for (let i = 0; i < need; i++) { + if (dryRun) { + console.log(`[dry-run] would deposit one split USDSUI coin amount=${minUsdsuiPerCoin}`); + continue; + } + const tx = await buildDepositCollateralFromWalletTx( + client, + signerOwner, + accountId, + minUsdsuiPerCoin, + "USDSUI", + ); + const r = await execTx(tx, trader, { gasBudget: 80_000_000 }); + assertSuccess(r); + console.log(`[prepare] deposited USDSUI split coin ${i + 1}/${need} digest=${r.digest}`); + } + } else { + console.log(`[prepare] funded TTO USDSUI coin readiness OK (${fundedSui} >= 2)`); + } + } + // 2) Missing persistent e2e perps (BTC, ETH, SUI, SOL, WAL, DEEP — see `e2e-persistent-state.ts`). if (!dryRun && !noOpenPositions) { await ensureE2ePersistentPerpSlots({ @@ -299,7 +334,14 @@ async function main() { // final visibility const finalCoins = await getAccountCoins(client, accountId, usdcType); const finalFunded = finalCoins.filter((c) => BigInt(c.balance) >= minFundedPerCoin).length; - console.log(`[prepare] done. funded TTO USDC coins>=${minFundedPerCoin}: ${finalFunded}`); + let tail = `funded TTO USDC coins>=${minFundedPerCoin}: ${finalFunded}`; + if (minUsdsuiPerCoin !== null) { + const usdsuiType = client.config.collaterals.USDSUI.type; + const fc = await getAccountCoins(client, accountId, usdsuiType); + const fu = fc.filter((c) => BigInt(c.balance) >= minUsdsuiPerCoin).length; + tail += `; USDSUI>=${minUsdsuiPerCoin}: ${fu}`; + } + console.log(`[prepare] done. ${tail}`); if (!dryRun && !noUpdateLocalFixed && shouldAutoPersistLocalFixedPositions()) { try { diff --git a/scripts/print-oracle-aggregates.ts b/scripts/print-oracle-aggregates.ts index 7841bbc..116f488 100644 --- a/scripts/print-oracle-aggregates.ts +++ b/scripts/print-oracle-aggregates.ts @@ -1,5 +1,11 @@ import { Transaction } from "@mysten/sui/transactions"; -import { buildOracleFeed, PYTH_PRICE_FEED_IDS, PYTH_TESTNET_FEED_IDS } from "@waterx/perp-sdk"; +import { + buildOracleFeed, + PythCache, + PYTH_PRICE_FEED_IDS, + PYTH_TESTNET_FEED_IDS, + updatePythPrices, +} from "@waterx/perp-sdk"; import { client, DUMMY_SENDER } from "../test/helpers/testnet.ts"; @@ -308,7 +314,10 @@ function eventsFromSimulateResult(result: unknown): SuiEventRecord[] { return []; } -const GAS_ORACLE_SCRIPT = 280_000_000; +/** Hermes `updatePythPrices` + `buildOracleFeed` needs headroom (matches oracle-simulate-multi-asset). */ +const GAS_ORACLE_SCRIPT = 1_200_000_000; + +const scriptPythCache = new PythCache(); async function runOne(feed: TokenFeed, format: OutputFormat) { const tx = new Transaction(); @@ -321,7 +330,7 @@ async function runOne(feed: TokenFeed, format: OutputFormat) { const pythCfg = client.config.pythConfig; if (pythCfg && feed.pythFeedId) { try { - // await updatePythPrices(tx, client.grpcClient, pythCfg, [feed.pythFeedId], scriptPythCache); + await updatePythPrices(tx, client.grpcClient, pythCfg, [feed.pythFeedId], scriptPythCache); } catch { // Same as addPriceFeeds: Hermes flaky — still feed on-chain Pyth + Supra below. } diff --git a/test/fixtures/trading/trading-config.json b/test/fixtures/trading/trading-config.json index 0668156..8194a11 100644 --- a/test/fixtures/trading/trading-config.json +++ b/test/fixtures/trading/trading-config.json @@ -1,6 +1,6 @@ { "version": 2, - "description": "Single source for e2e/simulate trading tests: market rows, persistent perp targets, iteration order, which bases run in preflight/scratch, and USDC/WLP thresholds. Edit this file only — do not duplicate lists in TypeScript.", + "description": "Single source for e2e/simulate trading tests: market rows, persistent perp targets, iteration order, which bases run in preflight/scratch, and USDC/WLP thresholds. Optional per-market `collateralAsset`: \"USDC\" (default) or \"USDSUI\" for perp margin — set on `lifecycleMarkets.` and/or `persistentPerp.markets.`. ETH+SUI use USDSUI for e2e coverage; `e2e:preflight` / `e2e:prepare` then require 2 funded TTO USDSUI coins (same threshold heuristic as USDC). Edit this file only — do not duplicate lists in TypeScript.", "baseOrder": [ "BTC", "ETH", @@ -69,6 +69,7 @@ "ETH": { "approxPrice": 3800, "leverage": 4, + "collateralAsset": "USDSUI", "openCollateral": "42000000", "isLong": false, "sizeLot": "1000", @@ -84,6 +85,7 @@ "SUI": { "approxPrice": 1, "leverage": 5, + "collateralAsset": "USDSUI", "openCollateral": "35000000", "isLong": true, "sizeLot": "1000000", @@ -259,12 +261,14 @@ "ETH": { "isLong": false, "leverage": 4, + "collateralAsset": "USDSUI", "openCollateral": "10000000", "openSize": "2000" }, "SUI": { "isLong": true, "leverage": 5, + "collateralAsset": "USDSUI", "openCollateral": "10000000", "openSize": "10000000" }, @@ -333,7 +337,7 @@ }, "e2eDelegate": { "description": "Optional pinned delegate for delegate placeOrder simulate + preflight. Leave delegateAddress empty to skip checks. Env WATERX_E2E_DELEGATE_ADDRESS overrides. permissions is u16 bitmask (12 = PLACE_ORDER|CANCEL_ORDER). After setting, run pnpm e2e:setup-delegate (owner signs addDelegate).", - "delegateAddress": "", + "delegateAddress": "0xa221d213ba6c08fa885cab1103a89aab5cd1fba910d2ecf77ae99df62dfb9659", "permissions": 12 } } diff --git a/test/helpers/e2e-persistent-perp-slots.ts b/test/helpers/e2e-persistent-perp-slots.ts index 1625369..dc268bd 100644 --- a/test/helpers/e2e-persistent-perp-slots.ts +++ b/test/helpers/e2e-persistent-perp-slots.ts @@ -78,7 +78,9 @@ export async function ensureE2ePersistentPerpSlots(opts: { isLong: row.isLong, leverage: lev, collateralAmount: row.openCollateral, + collateral: row.collateralAsset, size: row.openSize, + updatePythPrice: true, }; if (dryRun) { diff --git a/test/helpers/e2e-persistent-state.ts b/test/helpers/e2e-persistent-state.ts index a1b4bfd..3327c11 100644 --- a/test/helpers/e2e-persistent-state.ts +++ b/test/helpers/e2e-persistent-state.ts @@ -47,11 +47,27 @@ export function e2ePersistentPerpRow(base: BaseAsset): E2ePersistentPerpRow { /** Below `minBalanceRaw`, pull `mintPullUsdc` from the account and mint WLP back to the account. */ export { E2E_PERSISTENT_WLP }; -/** Rough min USDC for bootstrap scripts: sum of perp collaterals + one WLP round + buffer. */ -export function e2ePersistentMinAccountUsdcRough(): bigint { - let sum = E2E_PERSISTENT_WLP.mintPullUsdc + E2E_PERSISTENT_ACCOUNT_BUFFER_USDC; +/** Minima by margin asset for bootstrap / funding checks (raw stablecoin units). */ +export type E2ePersistentAccountCollateralRough = { + /** USDC: WLP mint buffer + account buffer + persistent perp rows using USDC. */ + minUsdc: bigint; + /** USDSUI: sum of `openCollateral` for persistent perp rows using USDSUI. */ + minUsdsui: bigint; +}; + +/** Rough minimum balances for bootstrap scripts: perp collaterals split by asset + one WLP round + buffer (USDC side). */ +export function e2ePersistentMinAccountCollateralRough(): E2ePersistentAccountCollateralRough { + let minUsdc = E2E_PERSISTENT_WLP.mintPullUsdc + E2E_PERSISTENT_ACCOUNT_BUFFER_USDC; + let minUsdsui = 0n; for (const base of activeE2ePersistentPerpBases()) { - sum += e2ePersistentPerpRow(base).openCollateral; + const row = e2ePersistentPerpRow(base); + if (row.collateralAsset === "USDSUI") minUsdsui += row.openCollateral; + else minUsdc += row.openCollateral; } - return sum; + return { minUsdc, minUsdsui }; +} + +/** USDC-only rough minimum (WLP buffer + USDC persistent perp rows); see {@link e2ePersistentMinAccountCollateralRough}. */ +export function e2ePersistentMinAccountUsdcRough(): bigint { + return e2ePersistentMinAccountCollateralRough().minUsdc; } diff --git a/test/helpers/e2e-tto-split-thresholds.ts b/test/helpers/e2e-tto-split-thresholds.ts new file mode 100644 index 0000000..d6bb80e --- /dev/null +++ b/test/helpers/e2e-tto-split-thresholds.ts @@ -0,0 +1,30 @@ +/** + * Thresholds for e2e preflight / prepare: UserAccount should hold **≥2** funded TTO coin objects + * per collateral type when that type is used as margin in {@link activeLifecycleTestBases}. + */ +import { activeLifecycleTestBases, lifecycleRow } from "./lifecycle-test-markets.ts"; + +const TTO_FUNDED_FLOOR = 5_000_000n; + +/** Max `e2ePtb.increaseCollateral` across all active lifecycle bases (USDC split heuristic). */ +export function e2eTtoMinFundedPerCoinUsdc(): bigint { + return activeLifecycleTestBases().reduce((acc, base) => { + const inc = lifecycleRow(base).e2ePtb.increaseCollateral; + return inc > acc ? inc : acc; + }, TTO_FUNDED_FLOOR); +} + +/** + * When any active lifecycle row uses USDSUI margin: max `increaseCollateral` among those bases. + * Returns `null` if no base uses USDSUI — callers skip USDSUI TTO checks. + */ +export function e2eTtoMinFundedPerCoinUsdsui(): bigint | null { + const bases = activeLifecycleTestBases().filter( + (b) => lifecycleRow(b).collateralAsset === "USDSUI", + ); + if (bases.length === 0) return null; + return bases.reduce((acc, base) => { + const inc = lifecycleRow(base).e2ePtb.increaseCollateral; + return inc > acc ? inc : acc; + }, TTO_FUNDED_FLOOR); +} diff --git a/test/helpers/lifecycle-test-markets.ts b/test/helpers/lifecycle-test-markets.ts index a9209a4..58f0ef1 100644 --- a/test/helpers/lifecycle-test-markets.ts +++ b/test/helpers/lifecycle-test-markets.ts @@ -5,7 +5,7 @@ * Iteration order is {@link LIFECYCLE_TEST_BASE_ORDER} intersected with rows in `lifecycleMarkets` * and {@link ENABLED_E2E_BASES} (see {@link activeLifecycleTestBases}). */ -import type { BaseAsset } from "../../src/constants.ts"; +import type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; import { ENABLED_E2E_BASES, LIFECYCLE_TEST_BASE_ORDER, @@ -19,7 +19,7 @@ export type LifecycleTestMarketRow = { */ approxPrice: number; leverage: number; - /** Integration `buildOpenPositionTx` collateral (USDC 6dp). */ + /** Integration `buildOpenPositionTx` collateral amount (stablecoin smallest units, typically 6dp). */ openCollateral: bigint; isLong: boolean; /** @@ -37,6 +37,8 @@ export type LifecycleTestMarketRow = { * `simulateOpenCollateral` would otherwise exceed effective max leverage. */ simulateLeverage?: number; + /** Which stablecoin funds margin for this row’s opens (default USDC). Config: `lifecycleMarkets..collateralAsset`. */ + collateralAsset: CollateralAsset; /** * E2E `lifecycle-single-ptb` fixed-size PTB (raw position size units — respect market min/lot). */ diff --git a/test/helpers/load-trading-fixtures.ts b/test/helpers/load-trading-fixtures.ts index fe7689a..bdcd204 100644 --- a/test/helpers/load-trading-fixtures.ts +++ b/test/helpers/load-trading-fixtures.ts @@ -5,6 +5,12 @@ import type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; import raw from "../fixtures/trading/trading-config.json"; +function parseCollateralAsset(value: unknown, field: string): CollateralAsset { + if (value === undefined || value === null || value === "") return "USDC"; + if (value === "USDC" || value === "USDSUI") return value; + throw new Error(`Invalid ${field} in trading-config.json: ${String(value)}`); +} + /** Mirrors {@link import("./lifecycle-test-markets.ts").LifecycleTestMarketRow} — local to avoid circular imports. */ type FixtureLifecycleRow = { approxPrice: number; @@ -14,6 +20,8 @@ type FixtureLifecycleRow = { sizeLot: bigint; simulateOpenCollateral: bigint; simulateLeverage?: number; + /** Perp margin asset for opens driven by this row (default USDC). */ + collateralAsset: CollateralAsset; e2ePtb: { openCollateral: bigint; increaseCollateral: bigint; @@ -29,6 +37,7 @@ export type E2ePersistentPerpRow = { simulateLeverage?: number; openCollateral: bigint; openSize: bigint; + collateralAsset: CollateralAsset; }; type TradingConfigJson = { @@ -62,6 +71,7 @@ type TradingConfigJson = { simulateLeverage?: number; openCollateral: string; openSize: string; + collateralAsset?: string; } >; }; @@ -84,6 +94,7 @@ function lifecycleRowFromJson(j: Record): FixtureLifecycleRow { sizeLot: BigInt(j.sizeLot as string), simulateOpenCollateral: BigInt(j.simulateOpenCollateral as string), simulateLeverage: j.simulateLeverage !== undefined ? (j.simulateLeverage as number) : undefined, + collateralAsset: parseCollateralAsset(j.collateralAsset, "lifecycleMarkets.collateralAsset"), e2ePtb: { openCollateral: BigInt(e2e.openCollateral), increaseCollateral: BigInt(e2e.increaseCollateral), @@ -147,6 +158,7 @@ for (const [k, v] of Object.entries(cfg.persistentPerp.markets)) { leverage: v.leverage, openCollateral: BigInt(v.openCollateral), openSize: BigInt(v.openSize), + collateralAsset: parseCollateralAsset(v.collateralAsset, "persistentPerp.markets.collateralAsset"), }; if (v.simulateLeverage !== undefined) row.simulateLeverage = v.simulateLeverage; parsedPersistent[k as BaseAsset] = row; diff --git a/test/helpers/run-scratch-trading-scenario-integration.ts b/test/helpers/run-scratch-trading-scenario-integration.ts index 03359e2..b82704f 100644 --- a/test/helpers/run-scratch-trading-scenario-integration.ts +++ b/test/helpers/run-scratch-trading-scenario-integration.ts @@ -71,10 +71,12 @@ export async function runScratchTradingScenarioIntegration( const cooldownMarketIds = [entry.marketId]; const snap = marketAtStart[base]!; assertMarketSnapshotTradeable(snap, base); + const col = scenario.collateralAsset; const openProbe = await simulateResizeForIntegrationOrSkip(ctx, client, base, { collateralAmount: scenario.integrationOpen.collateral, leverage: scenario.integrationOpen.leverage, + collateral: col, }); if (openProbe === undefined) return; expectResizeProbeMatchesSnapshot(base, openProbe, snap); @@ -88,6 +90,7 @@ export async function runScratchTradingScenarioIntegration( isLong: scenario.integrationOpen.isLong, leverage: scenario.integrationOpen.leverage, collateralAmount: scenario.integrationOpen.collateral, + collateral: col, }), trader, { cooldownMarketIds }, @@ -106,6 +109,7 @@ export async function runScratchTradingScenarioIntegration( const increaseProbe = await simulateResizeForIntegrationOrSkip(ctx, client, base, { collateralAmount: scenario.increase.collateral, leverage: scenario.increase.leverage, + collateral: col, }); if (increaseProbe === undefined) return; expectResizeProbeMatchesSnapshot(base, increaseProbe, snap); @@ -120,6 +124,7 @@ export async function runScratchTradingScenarioIntegration( base, positionId, collateralAmount: scenario.depositCollateral, + collateral: col, }), trader, { cooldownMarketIds }, @@ -138,6 +143,7 @@ export async function runScratchTradingScenarioIntegration( base, positionId, amount: scenario.withdrawCollateral, + collateral: col, }), trader, { cooldownMarketIds }, @@ -154,6 +160,7 @@ export async function runScratchTradingScenarioIntegration( positionId, collateralAmount: scenario.increase.collateral, leverage: scenario.increase.leverage, + collateral: col, }), trader, { cooldownMarketIds }, @@ -172,6 +179,7 @@ export async function runScratchTradingScenarioIntegration( base, positionId, size: decSize, + collateral: col, }), trader, { cooldownMarketIds }, @@ -187,6 +195,7 @@ export async function runScratchTradingScenarioIntegration( base, positionId, acceptablePrice: 0, + collateral: col, }), trader, { cooldownMarketIds }, diff --git a/test/helpers/run-scratch-trading-scenario-simulate.ts b/test/helpers/run-scratch-trading-scenario-simulate.ts index f589b06..09a3f53 100644 --- a/test/helpers/run-scratch-trading-scenario-simulate.ts +++ b/test/helpers/run-scratch-trading-scenario-simulate.ts @@ -63,6 +63,7 @@ export async function scratchSimulateOpenApproxOracle( isLong: scenario.simulateOpen.isLong, leverage: scenario.simulateOpen.leverage, collateralAmount: scenario.simulateOpen.collateral, + collateral: scenario.collateralAsset, approxPrice: prices[scenario.base], updatePythPrice: true, }); @@ -86,7 +87,7 @@ export async function scratchSimulateOpenExplicitSizeWithFee( [marketBefore, poolBefore, collateralOracle] = await Promise.all([ getMarketSummary(client, entry.marketId, entry.baseType), getPoolSummary(client), - fetchSimulatedCollateralUsdPrice(client, "USDC"), + fetchSimulatedCollateralUsdPrice(client, scenario.collateralAsset), ]); } catch (e) { ctx.skip(`prefetch for fee assertion failed: ${e instanceof Error ? e.message : String(e)}`); @@ -98,6 +99,7 @@ export async function scratchSimulateOpenExplicitSizeWithFee( base: scenario.base, isLong: scenario.simulateOpen.isLong, collateralAmount: scenario.simulateOpen.collateral, + collateral: scenario.collateralAsset, size: scenario.row.e2ePtb.openSize, updatePythPrice: true, }); @@ -138,6 +140,7 @@ export async function scratchSimulateOpenResize( isLong: scenario.simulateOpen.isLong, leverage: scenario.simulateOpen.leverage, collateralAmount: scenario.simulateOpen.collateral, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(tx); @@ -163,6 +166,7 @@ export async function scratchSimulateOpenTableApproxPrice( isLong: scenario.simulateOpen.isLong, leverage: scenario.simulateOpen.leverage, collateralAmount: scenario.simulateOpen.collateral, + collateral: scenario.collateralAsset, approxPrice: scenario.row.approxPrice, updatePythPrice: true, }); @@ -196,6 +200,7 @@ export async function scratchSimulateStatefulOps( positionId: pid, collateralAmount: st.increaseCollateral, size: st.increaseSize, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(incTx); @@ -206,6 +211,7 @@ export async function scratchSimulateStatefulOps( base, positionId: pid, size: st.decreaseSize, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(decTx); @@ -216,6 +222,7 @@ export async function scratchSimulateStatefulOps( base, positionId: pid, collateralAmount: st.depositCollateral, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(depTx); @@ -226,6 +233,7 @@ export async function scratchSimulateStatefulOps( base, positionId: pid, amount: st.withdrawAmount, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(withTx); @@ -235,6 +243,7 @@ export async function scratchSimulateStatefulOps( accountId, base, positionId: pid, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(closeTx); diff --git a/test/helpers/scratch-trading-scenarios.ts b/test/helpers/scratch-trading-scenarios.ts index 2bd45d3..14ab7dd 100644 --- a/test/helpers/scratch-trading-scenarios.ts +++ b/test/helpers/scratch-trading-scenarios.ts @@ -4,7 +4,7 @@ * * To add a market: extend `lifecycleMarkets` in test/fixtures/trading/trading-config.json and enable the base in `enabledE2eBases`. */ -import type { BaseAsset } from "../../src/constants.ts"; +import type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; import type { LifecycleTestMarketRow } from "./lifecycle-test-markets.ts"; import { activeLifecycleTestBases, @@ -22,6 +22,8 @@ export type ScratchTradingScenario = { base: BaseAsset; /** Full lifecycle row (approx table, e2ePtb, flags). */ row: LifecycleTestMarketRow; + /** Margin asset for this scratch flow (from `lifecycleMarkets` / {@link LifecycleTestMarketRow.collateralAsset}). */ + collateralAsset: CollateralAsset; /** `buildOpenPositionTx` on integration (larger collateral). */ integrationOpen: { collateral: bigint; @@ -62,6 +64,7 @@ export function scratchTradingScenarios(): ScratchTradingScenario[] { id: `scratch-${base}`, base, row, + collateralAsset: row.collateralAsset, integrationOpen: { collateral: row.openCollateral, leverage: row.leverage, diff --git a/test/integration/helpers/account-bootstrap.ts b/test/integration/helpers/account-bootstrap.ts index 6b72eea..2990fc5 100644 --- a/test/integration/helpers/account-bootstrap.ts +++ b/test/integration/helpers/account-bootstrap.ts @@ -2,6 +2,7 @@ import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; import { Transaction } from "@mysten/sui/transactions"; import type { WaterXClient } from "../../../src/client.ts"; +import type { CollateralAsset } from "../../../src/constants.ts"; import { getAccountsByOwner, selectCoinsForAmount } from "../../../src/fetch.ts"; import { createAccount, transferToAccount } from "../../../src/user/account.ts"; import { pickE2eAccountIdForOwner } from "../../helpers/resolve-e2e-reference-account.ts"; @@ -66,21 +67,22 @@ export async function ensureUserAccountForIntegration( } /** - * Build a PTB that moves `amount` USDC (smallest units) from the signer's wallet into the + * Build a PTB that moves `amount` collateral (smallest units) from the signer's wallet into the * UserAccount via TTO (`transferToAccount`). Caller must sign as `owner`. */ -export async function buildDepositUsdcFromWalletTx( +export async function buildDepositCollateralFromWalletTx( client: WaterXClient, owner: string, accountId: string, amount: bigint, + asset: CollateralAsset, ): Promise { - const usdcType = client.config.collaterals.USDC.type; - const { coins, totalBalance } = await selectCoinsForAmount(client, owner, usdcType, amount); + const coinType = client.config.collaterals[asset].type; + const { coins, totalBalance } = await selectCoinsForAmount(client, owner, coinType, amount); if (totalBalance < amount) { throw new Error( - `Wallet USDC insufficient: need ${amount}, have ${totalBalance} at ${owner}. ` + - `Fund the integration wallet with mock USDC on testnet.`, + `Wallet ${asset} insufficient: need ${amount}, have ${totalBalance} at ${owner}. ` + + `Fund the integration wallet on testnet.`, ); } @@ -91,7 +93,7 @@ export async function buildDepositUsdcFromWalletTx( transferToAccount(client, tx, { accountObjectAddress: accountId, coin: coins[0]!.objectId, - coinType: usdcType, + coinType, }); return tx; } @@ -108,7 +110,7 @@ export async function buildDepositUsdcFromWalletTx( transferToAccount(client, tx, { accountObjectAddress: accountId, coin: primary, - coinType: usdcType, + coinType, }); return tx; } @@ -117,8 +119,21 @@ export async function buildDepositUsdcFromWalletTx( transferToAccount(client, tx, { accountObjectAddress: accountId, coin: depositCoin, - coinType: usdcType, + coinType, }); tx.transferObjects([primary], owner); return tx; } + +/** + * Build a PTB that moves `amount` USDC (smallest units) from the signer's wallet into the + * UserAccount via TTO (`transferToAccount`). Caller must sign as `owner`. + */ +export async function buildDepositUsdcFromWalletTx( + client: WaterXClient, + owner: string, + accountId: string, + amount: bigint, +): Promise { + return buildDepositCollateralFromWalletTx(client, owner, accountId, amount, "USDC"); +} diff --git a/test/integration/helpers/scratch-lifecycle.ts b/test/integration/helpers/scratch-lifecycle.ts index e97fadc..b051484 100644 --- a/test/integration/helpers/scratch-lifecycle.ts +++ b/test/integration/helpers/scratch-lifecycle.ts @@ -8,7 +8,7 @@ import { Transaction } from "@mysten/sui/transactions"; import { getAccountBalance, type WaterXClient } from "@waterx/perp-sdk"; import { expect } from "vitest"; -import type { BaseAsset } from "../../../src/constants.ts"; +import type { BaseAsset, CollateralAsset } from "../../../src/constants.ts"; import type { MarketData } from "../../../src/view-types.ts"; import { activeLifecycleTestBases } from "../../helpers/lifecycle-test-markets.ts"; import { @@ -21,7 +21,7 @@ import { type ResizeSizingProbeParams, } from "../../helpers/simulate-resize-size.ts"; import { assertSuccess } from "../setup.ts"; -import { buildDepositUsdcFromWalletTx } from "./account-bootstrap.ts"; +import { buildDepositCollateralFromWalletTx } from "./account-bootstrap.ts"; export type IntegrationExecTx = ( tx: Transaction, @@ -90,28 +90,43 @@ export function decreaseStepSize(sizeAmount: bigint): bigint { } /** - * Top up account USDC to at least `minBalance` (smallest units) from the signer's wallet. + * Top up account collateral (`asset`) to at least `minBalance` (smallest units) from the signer's wallet. */ -export async function ensureScratchLifecycleMinUsdc( +export async function ensureScratchLifecycleMinCollateral( client: WaterXClient, trader: Ed25519Keypair, accountId: string, owner: string, minBalance: bigint, + asset: CollateralAsset, execTx: IntegrationExecTx, ): Promise { - const usdcType = client.config.collaterals.USDC.type; - let balance = await getAccountBalance(client, accountId, usdcType); + const coinType = client.config.collaterals[asset].type; + let balance = await getAccountBalance(client, accountId, coinType); if (balance < minBalance) { const need = minBalance - balance; - const depTx = await buildDepositUsdcFromWalletTx(client, owner, accountId, need); + const depTx = await buildDepositCollateralFromWalletTx(client, owner, accountId, need, asset); const depResult = await execTx(depTx, trader, { gasBudget: 50_000_000 }); assertSuccess(depResult); - balance = await getAccountBalance(client, accountId, usdcType); + balance = await getAccountBalance(client, accountId, coinType); } expect(balance).toBeGreaterThanOrEqual(minBalance); } +/** + * Top up account USDC to at least `minBalance` (smallest units) from the signer's wallet. + */ +export async function ensureScratchLifecycleMinUsdc( + client: WaterXClient, + trader: Ed25519Keypair, + accountId: string, + owner: string, + minBalance: bigint, + execTx: IntegrationExecTx, +): Promise { + return ensureScratchLifecycleMinCollateral(client, trader, accountId, owner, minBalance, "USDC", execTx); +} + /** * Dry-run `trading::resize` for one base (same wiring as {@link buildResolveSize}). On transient * oracle failure, calls `ctx.skip` and returns `undefined`. diff --git a/test/integration/user/trader-e2e-persistent-state.test.ts b/test/integration/user/trader-e2e-persistent-state.test.ts index 010ae38..05e05d2 100644 --- a/test/integration/user/trader-e2e-persistent-state.test.ts +++ b/test/integration/user/trader-e2e-persistent-state.test.ts @@ -21,6 +21,7 @@ import { e2ePersistentPerpRow, } from "../../helpers/e2e-persistent-state.ts"; import { + buildDepositCollateralFromWalletTx, buildDepositUsdcFromWalletTx, ensureUserAccountForIntegration, } from "../helpers/account-bootstrap.ts"; @@ -65,15 +66,22 @@ describe.skipIf(!isIntegrationTraderConfigured())( const row = e2ePersistentPerpRow(base); const lev = row.simulateLeverage ?? row.leverage; - const usdcType = client.config.collaterals.USDC.type; + const asset = row.collateralAsset; + const coinType = client.config.collaterals[asset].type; const minFree = row.openCollateral + 15_000_000n; - let balance = await getAccountBalance(client, accountId, usdcType); + let balance = await getAccountBalance(client, accountId, coinType); if (balance < minFree) { const need = minFree - balance; - const depTx = await buildDepositUsdcFromWalletTx(client, owner, accountId, need); + const depTx = await buildDepositCollateralFromWalletTx( + client, + owner, + accountId, + need, + asset, + ); const depResult = await execTx(depTx, trader, { gasBudget: 50_000_000 }); assertSuccess(depResult); - balance = await getAccountBalance(client, accountId, usdcType); + balance = await getAccountBalance(client, accountId, coinType); } expect(balance).toBeGreaterThanOrEqual(minFree); @@ -91,6 +99,7 @@ describe.skipIf(!isIntegrationTraderConfigured())( isLong: row.isLong, leverage: lev, collateralAmount: row.openCollateral, + collateral: asset, size: openSize, }), trader, diff --git a/test/integration/user/trader-position-lifecycle.test.ts b/test/integration/user/trader-position-lifecycle.test.ts index 5fa6d8f..9690546 100644 --- a/test/integration/user/trader-position-lifecycle.test.ts +++ b/test/integration/user/trader-position-lifecycle.test.ts @@ -17,7 +17,7 @@ import { type IntegrationMarketSnapshotMap, } from "../helpers/integration-market-snapshot.ts"; import { - ensureScratchLifecycleMinUsdc, + ensureScratchLifecycleMinCollateral, positionIdFromOpened, selectedIntegrationLifecycleBasesFromEnv, } from "../helpers/scratch-lifecycle.ts"; @@ -74,12 +74,13 @@ describe.skipIf(!isIntegrationTraderConfigured())( console.info(`[integration scratch][${scenario.id}] start`); const { accountId } = await ensureUserAccountForIntegration(client, trader, execTx); - await ensureScratchLifecycleMinUsdc( + await ensureScratchLifecycleMinCollateral( client, trader, accountId, owner, LIFECYCLE_MIN_ACCOUNT_USDC, + scenario.collateralAsset, execTx, ); @@ -105,12 +106,13 @@ describe.skipIf(!isIntegrationTraderConfigured())( ); const { accountId } = await ensureUserAccountForIntegration(client, trader, execTx); - await ensureScratchLifecycleMinUsdc( + await ensureScratchLifecycleMinCollateral( client, trader, accountId, owner, LIFECYCLE_APPROX_PRICE_CHAIN_SMOKE_MIN_USDC, + row.collateralAsset, execTx, ); @@ -131,6 +133,7 @@ describe.skipIf(!isIntegrationTraderConfigured())( isLong: row.isLong, leverage: lev, collateralAmount: collateral, + collateral: row.collateralAsset, approxPrice: row.approxPrice, }), trader, @@ -151,6 +154,7 @@ describe.skipIf(!isIntegrationTraderConfigured())( base, positionId, acceptablePrice: 0, + collateral: row.collateralAsset, }), trader, { cooldownMarketIds }, diff --git a/test/simulate/prd-product-coverage.test.ts b/test/simulate/prd-product-coverage.test.ts index 91c5e6f..64a36d9 100644 --- a/test/simulate/prd-product-coverage.test.ts +++ b/test/simulate/prd-product-coverage.test.ts @@ -189,6 +189,7 @@ describe("PRD §2.3 — TC-TRADE-001: BTC market long ~10x (simulate)", () => { isLong: true, leverage: 10, collateralAmount: row.simulateOpenCollateral, + collateral: row.collateralAsset, approxPrice: prices.BTC, updatePythPrice: true, }); @@ -218,6 +219,7 @@ describe("PRD §2.3 — TC-TRADE-002: ETH market short (simulate)", () => { isLong: false, leverage: 10, collateralAmount: row.simulateOpenCollateral, + collateral: row.collateralAsset, approxPrice: prices.ETH, updatePythPrice: true, }); @@ -275,6 +277,7 @@ describe("PRD §2.3 — TC-TRADE-003: max leverage vs above-max (per MARKET_DEFI isLong: row.isLong, leverage: maxLev, collateralAmount: row.simulateOpenCollateral, + collateral: row.collateralAsset, approxPrice: sizingUsd, updatePythPrice: true, }); @@ -296,6 +299,7 @@ describe("PRD §2.3 — TC-TRADE-003: max leverage vs above-max (per MARKET_DEFI isLong: row.isLong, leverage: LEVERAGE_ABOVE_MAX, collateralAmount: row.simulateOpenCollateral, + collateral: row.collateralAsset, updatePythPrice: true, }); tx.setSender(OWNER); @@ -593,11 +597,13 @@ describe("PRD §13 — TC-EDGE-001: insufficient collateral for intent (simulate const accountId = await firstAccountId(ctx); if (!accountId) return; + const row = lifecycleRow("BTC"); const tx = await buildOpenPositionTx(client, { accountId, base: "BTC", isLong: true, collateralAmount: 1_000_000n, + collateral: row.collateralAsset, size: 80_000_000n, updatePythPrice: true, }); diff --git a/test/simulate/trading-negative-simulate.test.ts b/test/simulate/trading-negative-simulate.test.ts index 7188559..1e7be30 100644 --- a/test/simulate/trading-negative-simulate.test.ts +++ b/test/simulate/trading-negative-simulate.test.ts @@ -61,6 +61,7 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { isLong: row.isLong, leverage: LEVERAGE_ABOVE_MAX, collateralAmount: row.simulateOpenCollateral, + collateral: row.collateralAsset, updatePythPrice: true, }); tx.setSender(OWNER); @@ -99,6 +100,7 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { base, isLong: row.isLong, collateralAmount: TINY_COLLATERAL_RAW, + collateral: row.collateralAsset, approxPrice: prices[base], leverage: 2, updatePythPrice: true, diff --git a/test/simulate/tx-builders-simulate.test.ts b/test/simulate/tx-builders-simulate.test.ts index 636a492..4984c22 100644 --- a/test/simulate/tx-builders-simulate.test.ts +++ b/test/simulate/tx-builders-simulate.test.ts @@ -253,7 +253,7 @@ describe("tx-builders stateful ops (simulate)", () => { describe("open position with TP/SL (single PTB simulate)", () => { for (const scenario of scenarios) { - const { base, row, simulateOpen } = scenario; + const { base, row, simulateOpen, collateralAsset } = scenario; it(`${base}: open + takeProfit + stopLoss in one PTB`, async (ctx) => { const accountId = await getFirstAccountId(ctx); @@ -270,6 +270,7 @@ describe("open position with TP/SL (single PTB simulate)", () => { base, isLong: simulateOpen.isLong, collateralAmount: simulateOpen.collateral, + collateral: collateralAsset, size: row.e2ePtb.openSize, takeProfit: { triggerPrice: tpPrice }, stopLoss: { triggerPrice: slPrice }, @@ -290,6 +291,7 @@ describe("open position with TP/SL (single PTB simulate)", () => { base, isLong: simulateOpen.isLong, collateralAmount: simulateOpen.collateral, + collateral: collateralAsset, size: row.e2ePtb.openSize, takeProfit: { triggerPrice: tpPrice }, updatePythPrice: true, From dd7b5def55586e8f9bb28503db7bf17a2da2f08f Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Fri, 17 Apr 2026 23:59:06 +0800 Subject: [PATCH 6/9] test: collateral-aware TTO simulate harness and e2e script cleanup - Generalize ensure-tto helper for USDC/USDSUI; document auto-split limits - Add X_STOCK_BASES / isXStockBase for oracle market-hours gating - Extend e2e preflight/prepare and scratch integration lifecycle - Remove legacy one-off position/collateral scripts - Harden simulate tests (collateral order, lifecycle PTB, negative cases) Made-with: Cursor --- scripts/README.md | 2 +- scripts/check-account-usdsui.ts | 21 ---- scripts/check-eth-sui-positions.ts | 17 ---- scripts/close-legacy-collateral-mismatch.ts | 72 -------------- scripts/e2e-preflight.ts | 35 ++++++- scripts/e2e-prepare.ts | 95 +++++++++++-------- src/constants.ts | 22 +++++ src/index.ts | 3 + test/helpers/e2e-persistent-perp-slots.ts | 23 ++++- ...sure-tto-collateral-coins-for-simulate.ts} | 52 +++++++--- ...un-scratch-trading-scenario-integration.ts | 65 +++++++++---- test/integration/helpers/scratch-lifecycle.ts | 68 ++++++++++--- .../collateral-order-simulate.test.ts | 7 +- test/simulate/lifecycle-single-ptb.test.ts | 89 ++++++++++------- .../trading-negative-simulate.test.ts | 90 +++++++++++++++++- 15 files changed, 420 insertions(+), 241 deletions(-) delete mode 100644 scripts/check-account-usdsui.ts delete mode 100644 scripts/check-eth-sui-positions.ts delete mode 100644 scripts/close-legacy-collateral-mismatch.ts rename test/helpers/{ensure-tto-usdc-coins-for-simulate.ts => ensure-tto-collateral-coins-for-simulate.ts} (58%) diff --git a/scripts/README.md b/scripts/README.md index 41e402d..30a16b7 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -46,7 +46,7 @@ CI also chains `e2e-preflight.ts` before simulate tests (`test:ci:e2e`). | File | Purpose | | ---- | ------- | | `e2e-preflight.ts` | Wallet / account / **required on-chain position per lifecycle base** + cooldown + oracle simulate, before `test:e2e`. | -| `e2e-prepare.ts` | TTO split, cooldown, collateral / WLP top-up; optional `--ensure-delegate` (needs integration key). | +| `e2e-prepare.ts` | TTO split (pre + post open), persistent perp slots, cooldown, collateral / WLP top-up; optional `--ensure-delegate` (needs integration key). A single run leaves the account in a state that satisfies `e2e:preflight`. | | `bootstrap-e2e-lifecycle-positions.ts` | Open small persistent perp slots per `test/fixtures/trading/trading-config.json`. | | `diagnose-integration-positions.ts` | Inspect reference account positions / refresh local fixed-position hints. | diff --git a/scripts/check-account-usdsui.ts b/scripts/check-account-usdsui.ts deleted file mode 100644 index 943e260..0000000 --- a/scripts/check-account-usdsui.ts +++ /dev/null @@ -1,21 +0,0 @@ -import { WaterXClient, getAccountCoins, getAccountBalance } from "../src/index.ts"; -import { INTEGRATION_REFERENCE_USER_ACCOUNT_ID } from "../test/helpers/integration-reference-wallet.ts"; - -async function main() { - const client = WaterXClient.testnet(); - const accountId = INTEGRATION_REFERENCE_USER_ACCOUNT_ID; - const usdsuiType = client.config.collaterals.USDSUI.type; - const usdcType = client.config.collaterals.USDC.type; - - const usdsuiCoins = await getAccountCoins(client, accountId, usdsuiType); - const usdsuiBal = await getAccountBalance(client, accountId, usdsuiType); - const usdcCoins = await getAccountCoins(client, accountId, usdcType); - const usdcBal = await getAccountBalance(client, accountId, usdcType); - - console.log(`accountId=${accountId}`); - console.log(`USDSUI balance=${usdsuiBal}, coins=${usdsuiCoins.length}`); - for (const c of usdsuiCoins) console.log(` - ${c.objectId} = ${c.balance}`); - console.log(`USDC balance=${usdcBal}, coins=${usdcCoins.length}`); - for (const c of usdcCoins) console.log(` - ${c.objectId} = ${c.balance}`); -} -main().catch((e) => { console.error(e); process.exit(1); }); diff --git a/scripts/check-eth-sui-positions.ts b/scripts/check-eth-sui-positions.ts deleted file mode 100644 index 89e3d1c..0000000 --- a/scripts/check-eth-sui-positions.ts +++ /dev/null @@ -1,17 +0,0 @@ -import { WaterXClient } from "../src/index.ts"; -import { getPosition } from "../src/fetch.ts"; - -async function main() { - const client = WaterXClient.testnet(); - for (const base of ["ETH", "SUI"] as const) { - const entry = client.getMarketEntry(base); - const pid = base === "ETH" ? 4n : 2n; - const info = await getPosition(client, entry.marketId, pid, entry.baseType); - console.log(`${base} position ${pid}:`); - console.log(` collateralType: ${info.collateralType}`); - console.log(` collateralAmount: ${info.collateralAmount}`); - console.log(` size: ${info.size}`); - console.log(` isLong: ${info.isLong}`); - } -} -main().catch((e) => { console.error(e); process.exit(1); }); diff --git a/scripts/close-legacy-collateral-mismatch.ts b/scripts/close-legacy-collateral-mismatch.ts deleted file mode 100644 index 4e0a21a..0000000 --- a/scripts/close-legacy-collateral-mismatch.ts +++ /dev/null @@ -1,72 +0,0 @@ -/** - * One-off: close legacy USDC-backed ETH/SUI positions on the reference UserAccount so - * `e2e:prepare` can re-open them with USDSUI margin (per current trading-config.json). - * - * Safe to re-run: skips positions that are already closed / wrong collateral. - */ -import type { BaseAsset, CollateralAsset } from "../src/constants.ts"; -import { getPosition, positionExists } from "../src/fetch.ts"; -import { buildClosePositionTx } from "../src/tx-builders.ts"; -import { INTEGRATION_REFERENCE_USER_ACCOUNT_ID } from "../test/helpers/integration-reference-wallet.ts"; -import { - assertSuccess, - client, - execTx, - loadIntegrationTraderKeypair, - sleep, -} from "../test/integration/setup.ts"; - -type Target = { base: BaseAsset; positionId: number; collateral: CollateralAsset }; - -const TARGETS: Target[] = [ - { base: "ETH", positionId: 4, collateral: "USDC" }, - { base: "SUI", positionId: 2, collateral: "USDC" }, -]; - -async function main() { - const signer = loadIntegrationTraderKeypair(); - const accountId = INTEGRATION_REFERENCE_USER_ACCOUNT_ID; - - for (const t of TARGETS) { - const entry = client.getMarketEntry(t.base); - const exists = await positionExists(client, entry.marketId, t.positionId, entry.baseType); - if (!exists) { - console.log(`[skip] ${t.base} position ${t.positionId}: does not exist`); - continue; - } - const info = await getPosition(client, entry.marketId, t.positionId, entry.baseType); - if (info.size === 0n) { - console.log(`[skip] ${t.base} position ${t.positionId}: already closed (size=0)`); - continue; - } - const collType = client.config.collaterals[t.collateral].type; - const norm = (s: string) => s.replace(/^0x/i, "").toLowerCase(); - if (norm(info.collateralType) !== norm(collType)) { - console.log( - `[skip] ${t.base} position ${t.positionId}: collateralType mismatch (on-chain=${info.collateralType}, expected=${collType})`, - ); - continue; - } - - console.log( - `[close] ${t.base} position ${t.positionId} collateral=${t.collateral} amount=${info.collateralAmount} size=${info.size}`, - ); - const tx = await buildClosePositionTx(client, { - accountId, - base: t.base, - positionId: t.positionId, - collateral: t.collateral, - acceptablePrice: 0, - updatePythPrice: true, - }); - const r = await execTx(tx, signer, { gasBudget: 200_000_000 }); - assertSuccess(r); - console.log(`[ok] ${t.base} position ${t.positionId} closed digest=${r.digest}`); - await sleep(800); - } -} - -main().catch((e) => { - console.error(e); - process.exit(1); -}); diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index 86f9d33..9e04bf3 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -34,6 +34,7 @@ import { getAccountBalance, getAccountCoins, getMarketCooldownMs, + isXStockBase, WaterXClient, } from "../src/index.ts"; import { buildOpenPositionTx } from "../src/tx-builders.ts"; @@ -55,7 +56,7 @@ import { } from "../test/helpers/ensure-e2e-delegate.ts"; import { resolveE2eAccountForOwner } from "../test/helpers/resolve-e2e-reference-account.ts"; -export type CheckStatus = "OK" | "FAIL"; +export type CheckStatus = "OK" | "FAIL" | "SKIP"; export type CheckKind = | "user_account_missing" | "tto_coin_split" @@ -84,6 +85,7 @@ export type PreflightResult = { rows: CheckRow[]; okCount: number; failCount: number; + skipCount: number; blockingFailCount: number; nonBlockingFailCount: number; }; @@ -116,7 +118,7 @@ function cooldownElapsed(updateTimestampMs: bigint, cooldownMs: bigint, slackMs function printRows(rows: CheckRow[]) { for (const r of rows) { - const head = r.status === "OK" ? "[OK] " : "[FAIL]"; + const head = r.status === "OK" ? "[OK] " : r.status === "SKIP" ? "[SKIP]" : "[FAIL]"; console.log(`${head} ${r.name} — ${r.detail}`); if (r.action) console.log(` fix: ${r.action}`); } @@ -229,6 +231,7 @@ export async function runPreflight( rows, okCount: 0, failCount: 1, + skipCount: 0, blockingFailCount: 1, nonBlockingFailCount: 0, }; @@ -383,8 +386,28 @@ export async function runPreflight( } for (const base of activeLifecycleTestBases()) { + // xStock Pyth feeds publish only during US cash-equity market hours. Off-hours the + // Hermes price is stale and on-chain `pyth_rule` refuses it → `err_total_weight_not_enough`. + // That is a structural, time-of-day truth about the feed — not a preflight prerequisite — + // so we defer oracle liveness for xStocks to the e2e runtime (tests can skip by + // market-hour when/if they need it) rather than inflate preflight FAIL counts here. + if (isXStockBase(base)) { + rows.push({ + name: `${base} oracle readiness (simulate open)`, + status: "SKIP", + kind: "info", + detail: + "skipped: xStock — Pyth publishes during US market hours only; oracle liveness deferred to e2e runtime", + }); + continue; + } const row = lifecycleRow(base); try { + // `updatePythPrice: true` inlines a Pyth price-feed update (fetched from Hermes) into the + // simulated PTB. Without it, preflight depends on whichever Pyth price objects happened to + // be pushed on-chain most recently; when those lag, the aggregator fails with + // `err_total_weight_not_enough` and every market reports a false transient. The e2e tests + // themselves push updates per tx, so preflight must mirror that to match runtime behaviour. const tx = await buildOpenPositionTx(client, { accountId, base, @@ -392,6 +415,7 @@ export async function runPreflight( collateralAmount: row.e2ePtb.openCollateral, collateral: row.collateralAsset, size: row.e2ePtb.openSize, + updatePythPrice: true, }); tx.setSender(owner); const result: any = await client.simulate(tx); @@ -437,6 +461,7 @@ export async function runPreflight( } const failRows = rows.filter((r) => r.status === "FAIL"); + const skipCount = rows.filter((r) => r.status === "SKIP").length; const nonBlockingFailCount = failRows.filter((r) => isNonBlockingFail(r, { allowOracleTransient, @@ -452,8 +477,9 @@ export async function runPreflight( owner, accountId, rows, - okCount: rows.length - failRows.length, + okCount: rows.length - failRows.length - skipCount, failCount: failRows.length, + skipCount, blockingFailCount, nonBlockingFailCount, }; @@ -480,7 +506,8 @@ async function main() { allowMissingE2eDelegate, }); printRows(result.rows); - console.log(`\nsummary: ${result.okCount} OK, ${result.failCount} FAIL`); + const skipSuffix = result.skipCount > 0 ? `, ${result.skipCount} SKIP` : ""; + console.log(`\nsummary: ${result.okCount} OK, ${result.failCount} FAIL${skipSuffix}`); console.log( `blocking=${result.blockingFailCount}, non-blocking=${result.nonBlockingFailCount}` + (allowOracleTransient || diff --git a/scripts/e2e-prepare.ts b/scripts/e2e-prepare.ts index e76d30c..68ced44 100644 --- a/scripts/e2e-prepare.ts +++ b/scripts/e2e-prepare.ts @@ -17,6 +17,7 @@ */ import { Transaction } from "@mysten/sui/transactions"; +import type { CollateralAsset } from "../src/constants.ts"; import { getAccountBalance, getAccountCoins, @@ -43,7 +44,6 @@ import { activeLifecycleTestBases } from "../test/helpers/lifecycle-test-markets import { resolveE2eOpenPosition } from "../test/helpers/resolve-e2e-open-position.ts"; import { buildDepositCollateralFromWalletTx, - buildDepositUsdcFromWalletTx, ensureUserAccountForIntegration, } from "../test/integration/helpers/account-bootstrap.ts"; import { @@ -90,62 +90,54 @@ async function main() { const minFundedPerCoin = e2eTtoMinFundedPerCoinUsdc(); const minUsdsuiPerCoin = e2eTtoMinFundedPerCoinUsdsui(); - // 1) Ensure at least 2 funded TTO USDC coin objects. - const coins = await getAccountCoins(client, accountId, usdcType); - const funded = coins.filter((c) => BigInt(c.balance) >= minFundedPerCoin).length; - if (funded < 2) { + /** + * Ensure the UserAccount holds at least 2 funded TTO split coins for `asset`. + * Idempotent — safe to call before and after perp opens so that coins consumed by + * `ensureE2ePersistentPerpSlots` (or wallet WLP top-up) are replenished before preflight. + */ + const ensureTtoSplit = async ( + asset: CollateralAsset, + minPerCoin: bigint, + phase: "pre-open" | "post-open", + ) => { + const coinType = client.config.collaterals[asset].type; + const have = await getAccountCoins(client, accountId, coinType); + const funded = have.filter((c) => BigInt(c.balance) >= minPerCoin).length; + const label = `${phase}`; + if (funded >= 2) { + console.log( + `[prepare/${label}] funded TTO ${asset} coin readiness OK (${funded} >= 2, threshold=${minPerCoin})`, + ); + return; + } const need = 2 - funded; console.log( - `[prepare] funded TTO USDC coins=${funded}, need +${need} (threshold=${minFundedPerCoin})`, + `[prepare/${label}] funded TTO ${asset} coins=${funded}, need +${need} (threshold=${minPerCoin})`, ); for (let i = 0; i < need; i++) { if (dryRun) { - console.log(`[dry-run] would deposit one split USDC coin amount=${minFundedPerCoin}`); + console.log(`[dry-run/${label}] would deposit one split ${asset} coin amount=${minPerCoin}`); continue; } - const tx = await buildDepositUsdcFromWalletTx( + const tx = await buildDepositCollateralFromWalletTx( client, signerOwner, accountId, - minFundedPerCoin, + minPerCoin, + asset, ); const r = await execTx(tx, trader, { gasBudget: 80_000_000 }); assertSuccess(r); - console.log(`[prepare] deposited split coin ${i + 1}/${need} digest=${r.digest}`); - } - } else { - console.log(`[prepare] funded TTO USDC coin readiness OK (${funded} >= 2)`); - } - - // 1b) Same for USDSUI when lifecycle rows use USDSUI margin (stateful / split-coin paths). - if (minUsdsuiPerCoin !== null) { - const usdsuiType = client.config.collaterals.USDSUI.type; - const usdsuiCoins = await getAccountCoins(client, accountId, usdsuiType); - const fundedSui = usdsuiCoins.filter((c) => BigInt(c.balance) >= minUsdsuiPerCoin).length; - if (fundedSui < 2) { - const need = 2 - fundedSui; console.log( - `[prepare] funded TTO USDSUI coins=${fundedSui}, need +${need} (threshold=${minUsdsuiPerCoin})`, + `[prepare/${label}] deposited ${asset} split coin ${i + 1}/${need} digest=${r.digest}`, ); - for (let i = 0; i < need; i++) { - if (dryRun) { - console.log(`[dry-run] would deposit one split USDSUI coin amount=${minUsdsuiPerCoin}`); - continue; - } - const tx = await buildDepositCollateralFromWalletTx( - client, - signerOwner, - accountId, - minUsdsuiPerCoin, - "USDSUI", - ); - const r = await execTx(tx, trader, { gasBudget: 80_000_000 }); - assertSuccess(r); - console.log(`[prepare] deposited USDSUI split coin ${i + 1}/${need} digest=${r.digest}`); - } - } else { - console.log(`[prepare] funded TTO USDSUI coin readiness OK (${fundedSui} >= 2)`); } + }; + + // 1) Pre-open TTO readiness — opens below pull collateral from these split coins. + await ensureTtoSplit("USDC", minFundedPerCoin, "pre-open"); + if (minUsdsuiPerCoin !== null) { + await ensureTtoSplit("USDSUI", minUsdsuiPerCoin, "pre-open"); } // 2) Missing persistent e2e perps (BTC, ETH, SUI, SOL, WAL, DEEP — see `e2e-persistent-state.ts`). @@ -158,6 +150,19 @@ async function main() { force: false, logStyle: "prepare", execBuiltTxWithCooldownRetries, + // Each open can drain the 2 TTO split coins for its collateral. Re-check before the + // next open so back-to-back same-collateral markets (e.g. ETH + SUI both on USDSUI) + // don't trip `fetchAccountCoins` with "No coins found". + beforeOpen: async ({ collateral }) => { + const minPerCoin = + collateral === "USDC" + ? minFundedPerCoin + : collateral === "USDSUI" + ? minUsdsuiPerCoin + : null; + if (minPerCoin === null) return; + await ensureTtoSplit(collateral, minPerCoin, "pre-open"); + }, }); } else if (dryRun && !noOpenPositions) { console.log( @@ -306,6 +311,14 @@ async function main() { ); } + // 3b) Post-open TTO replenish — `ensureE2ePersistentPerpSlots` and the WLP/collateral top-up + // above both consume split coins. Re-run the same idempotent check so a single + // `pnpm e2e:prepare` invocation is sufficient for CI `e2e:preflight` to pass. + await ensureTtoSplit("USDC", minFundedPerCoin, "post-open"); + if (minUsdsuiPerCoin !== null) { + await ensureTtoSplit("USDSUI", minUsdsuiPerCoin, "post-open"); + } + // 4) Wait for cooldown windows to elapse for enabled lifecycle markets (aligns with e2e:preflight). let maxWaitMs = 0; for (const base of activeLifecycleTestBases()) { diff --git a/src/constants.ts b/src/constants.ts index 23ebe5d..ca28a87 100644 --- a/src/constants.ts +++ b/src/constants.ts @@ -17,6 +17,28 @@ export type BaseAsset = | "TSLAX"; export type CollateralAsset = "USDC" | "USDSUI"; +/** + * Bases backed by xStock Pyth feeds — publish only during US cash-equity market hours + * (incl. extended). Off-hours their Hermes `publish_time` goes stale and `pyth_rule` + * refuses them on-chain, causing `err_total_weight_not_enough` in the aggregator. + * + * Callers that care about oracle liveness (preflight, UI banners, …) can use this set to + * decide whether to attempt a live oracle path or defer to runtime market-hours gating. + */ +export const X_STOCK_BASES: ReadonlySet = new Set([ + "AAPLX", + "GOOGLX", + "METAX", + "NVDAX", + "QQQX", + "SPYX", + "TSLAX", +]); + +export function isXStockBase(base: BaseAsset): boolean { + return X_STOCK_BASES.has(base); +} + // ======== Permission Constants ======== export const PERM_OPEN_POSITION = 1; export const PERM_CLOSE_POSITION = 2; diff --git a/src/index.ts b/src/index.ts index 9191254..0d1aaec 100644 --- a/src/index.ts +++ b/src/index.ts @@ -35,6 +35,9 @@ export { ORDER_LIMIT_SELL, ORDER_STOP_BUY, ORDER_STOP_SELL, + // Market-class helpers (preflight / UI gating) + X_STOCK_BASES, + isXStockBase, } from "./constants.ts"; export type { BaseAsset, CollateralAsset } from "./constants.ts"; diff --git a/test/helpers/e2e-persistent-perp-slots.ts b/test/helpers/e2e-persistent-perp-slots.ts index dc268bd..544e52a 100644 --- a/test/helpers/e2e-persistent-perp-slots.ts +++ b/test/helpers/e2e-persistent-perp-slots.ts @@ -2,7 +2,7 @@ import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; import type { Transaction } from "@mysten/sui/transactions"; import type { WaterXClient } from "../../src/client.ts"; -import type { BaseAsset } from "../../src/constants.ts"; +import type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; import { buildOpenPositionTx } from "../../src/tx-builders.ts"; import { listAccountPositionsInMarket, @@ -40,9 +40,23 @@ export async function ensureE2ePersistentPerpSlots(opts: { force: boolean; logStyle: E2ePerpSlotLogStyle; execBuiltTxWithCooldownRetries: ExecBuiltTxWithCooldownRetries; + /** + * Optional hook invoked right before each open so the caller can replenish TTO split + * coins consumed by prior iterations. Prevents "No coins found" when multiple + * markets in the loop share the same collateral asset. + */ + beforeOpen?: (ctx: { base: BaseAsset; collateral: CollateralAsset }) => Promise | void; }): Promise>> { - const { client, accountId, signer, dryRun, force, logStyle, execBuiltTxWithCooldownRetries } = - opts; + const { + client, + accountId, + signer, + dryRun, + force, + logStyle, + execBuiltTxWithCooldownRetries, + beforeOpen, + } = opts; const positionsForLocal: Partial> = {}; const bases = activeE2ePersistentPerpBases(); @@ -94,6 +108,9 @@ export async function ensureE2ePersistentPerpSlots(opts: { if (logStyle === "prepare") { console.log(`[prepare] ${base}: opening missing e2e persistent position…`); } + if (beforeOpen) { + await beforeOpen({ base, collateral: row.collateralAsset }); + } const result = await execBuiltTxWithCooldownRetries( () => buildOpenPositionTx(client, openParams), signer, diff --git a/test/helpers/ensure-tto-usdc-coins-for-simulate.ts b/test/helpers/ensure-tto-collateral-coins-for-simulate.ts similarity index 58% rename from test/helpers/ensure-tto-usdc-coins-for-simulate.ts rename to test/helpers/ensure-tto-collateral-coins-for-simulate.ts index 490ee19..5369863 100644 --- a/test/helpers/ensure-tto-usdc-coins-for-simulate.ts +++ b/test/helpers/ensure-tto-collateral-coins-for-simulate.ts @@ -1,13 +1,18 @@ /** - * E2e simulate tests that need multiple TTO USDC {@link CoinForReceiving} refs in one PTB cannot - * use a single on-account coin: the remainder after `open_position_request` is created mid-tx and - * is not addressable via static `receivingRef` for a second op. When the account has fewer funded - * coins than required, we optionally run the same wallet→account split deposit as `pnpm e2e:prepare` + * E2e simulate tests that need multiple TTO {@link CoinForReceiving} refs in one PTB cannot use a + * single on-account coin: the remainder after `open_position_request` is created mid-tx and is not + * addressable via static `receivingRef` for a second op. When the account has fewer funded coins + * than required, we optionally run the same wallet→account split deposit as `pnpm e2e:prepare` * (requires integration signer = {@link INTEGRATION_REFERENCE_WALLET_ADDRESS}). + * + * Auto-split fallback is currently only wired for USDC (`buildDepositUsdcFromWalletTx`). For other + * collateral assets (e.g. USDSUI) callers must run `pnpm e2e:prepare` beforehand; we surface a + * skip with that guidance instead of failing silently. */ import { getAccountCoins } from "@waterx/perp-sdk"; import type { WaterXClient } from "../../src/client.ts"; +import type { CollateralAsset } from "../../src/constants.ts"; import { buildDepositUsdcFromWalletTx } from "../integration/helpers/account-bootstrap.ts"; import { assertSuccess, @@ -30,28 +35,51 @@ function normAddr(a: string): string { type VitestSkipCtx = { skip: (reason?: string) => void }; /** - * Ensures at least `needCount` on-account USDC coins with balance ≥ `minBalancePerCoin` each. - * When short and integration key is configured for the reference wallet, submits split deposits from - * the wallet (mutates testnet state). + * Ensures at least `needCount` on-account {@link collateralAsset} coins with balance ≥ + * `minBalancePerCoin` each. When short and `collateralAsset === "USDC"` with the integration key + * configured for the reference wallet, submits split deposits from the wallet (mutates testnet + * state). For other assets (e.g. USDSUI) the caller is skipped with guidance to run + * `pnpm e2e:prepare`. */ -export async function ensureAtLeastFundedTtoUsdcCoinsForSimulate(opts: { +export async function ensureAtLeastFundedTtoCollateralCoinsForSimulate(opts: { ctx: VitestSkipCtx; client: WaterXClient; accountId: string; - usdcType: string; + collateralAsset: CollateralAsset; + collateralType: string; minBalancePerCoin: bigint; needCount: number; }): Promise { - const { ctx, client, accountId, usdcType, minBalancePerCoin, needCount } = opts; + const { + ctx, + client, + accountId, + collateralAsset, + collateralType, + minBalancePerCoin, + needCount, + } = opts; async function listFunded(): Promise { - const usdcCoins = await getAccountCoins(client, accountId, usdcType); - return usdcCoins + const coins = await getAccountCoins(client, accountId, collateralType); + return coins .filter((c) => BigInt(c.balance) >= minBalancePerCoin) .map((c) => ({ objectId: c.objectId, version: BigInt(c.version), digest: c.digest })); } let funded = await listFunded(); + if (funded.length >= needCount) return funded.slice(0, needCount); + + // Auto-split fallback is USDC-only for now. + if (collateralAsset !== "USDC") { + ctx.skip( + `Need ${needCount} TTO ${collateralAsset} coins with balance ≥ ${minBalancePerCoin} each ` + + `(have ${funded.length}). Run \`pnpm e2e:prepare\` to split ${collateralAsset} into TTO coin ` + + `objects (no wallet-split fallback is wired for ${collateralAsset}).`, + ); + return null; + } + let attempts = 0; while (funded.length < needCount) { if (!isIntegrationTraderConfigured()) { diff --git a/test/helpers/run-scratch-trading-scenario-integration.ts b/test/helpers/run-scratch-trading-scenario-integration.ts index b82704f..d4adf6a 100644 --- a/test/helpers/run-scratch-trading-scenario-integration.ts +++ b/test/helpers/run-scratch-trading-scenario-integration.ts @@ -2,7 +2,7 @@ * Integration runner for {@link ScratchTradingScenario}: full scratch lifecycle on testnet. */ import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; -import type { WaterXClient } from "@waterx/perp-sdk"; +import { PythCache, type WaterXClient } from "@waterx/perp-sdk"; import { expect } from "vitest"; import { getPosition, positionExists } from "../../src/fetch.ts"; @@ -26,6 +26,9 @@ import { import { SCRATCH_EXPECT } from "./scratch-scenario-steps.ts"; import type { ScratchTradingScenario } from "./scratch-trading-scenarios.ts"; +/** Hermes `updatePythPrices` + oracle feed + trading ops need headroom on testnet. */ +const SCRATCH_INTEGRATION_GAS = 1_200_000_000; + export type IntegrationScratchRunnerDeps = { client: WaterXClient; trader: Ed25519Keypair; @@ -72,12 +75,28 @@ export async function runScratchTradingScenarioIntegration( const snap = marketAtStart[base]!; assertMarketSnapshotTradeable(snap, base); const col = scenario.collateralAsset; + const pythCache = new PythCache(); + const feedOpts = { + updatePythPrice: true as const, + pythCache, + gasBudget: SCRATCH_INTEGRATION_GAS, + }; + const execOracleOpts = { + cooldownMarketIds, + gasBudget: SCRATCH_INTEGRATION_GAS, + }; - const openProbe = await simulateResizeForIntegrationOrSkip(ctx, client, base, { - collateralAmount: scenario.integrationOpen.collateral, - leverage: scenario.integrationOpen.leverage, - collateral: col, - }); + const openProbe = await simulateResizeForIntegrationOrSkip( + ctx, + client, + base, + { + collateralAmount: scenario.integrationOpen.collateral, + leverage: scenario.integrationOpen.leverage, + collateral: col, + }, + { pythCache }, + ); if (openProbe === undefined) return; expectResizeProbeMatchesSnapshot(base, openProbe, snap); @@ -91,9 +110,10 @@ export async function runScratchTradingScenarioIntegration( leverage: scenario.integrationOpen.leverage, collateralAmount: scenario.integrationOpen.collateral, collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ), ); if (openResult === undefined) return; @@ -106,11 +126,17 @@ export async function runScratchTradingScenarioIntegration( expect(openLevBps).toBeLessThanOrEqual(snap.maxLeverageBps); expect(await positionExists(client, entry.marketId, positionId, entry.baseType)).toBe(true); - const increaseProbe = await simulateResizeForIntegrationOrSkip(ctx, client, base, { - collateralAmount: scenario.increase.collateral, - leverage: scenario.increase.leverage, - collateral: col, - }); + const increaseProbe = await simulateResizeForIntegrationOrSkip( + ctx, + client, + base, + { + collateralAmount: scenario.increase.collateral, + leverage: scenario.increase.leverage, + collateral: col, + }, + { pythCache }, + ); if (increaseProbe === undefined) return; expectResizeProbeMatchesSnapshot(base, increaseProbe, snap); @@ -125,9 +151,10 @@ export async function runScratchTradingScenarioIntegration( positionId, collateralAmount: scenario.depositCollateral, collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(depCollResult); const afterDeposit = await getPosition(client, entry.marketId, positionId, entry.baseType); @@ -144,9 +171,10 @@ export async function runScratchTradingScenarioIntegration( positionId, amount: scenario.withdrawCollateral, collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(withCollResult); const afterWithdraw = await getPosition(client, entry.marketId, positionId, entry.baseType); @@ -161,9 +189,10 @@ export async function runScratchTradingScenarioIntegration( collateralAmount: scenario.increase.collateral, leverage: scenario.increase.leverage, collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(incResult); expect(extractEvent(incResult, "PositionModified")).toBeDefined(); @@ -180,9 +209,10 @@ export async function runScratchTradingScenarioIntegration( positionId, size: decSize, collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(decResult); expect(extractEvent(decResult, "PositionModified")).toBeDefined(); @@ -196,9 +226,10 @@ export async function runScratchTradingScenarioIntegration( positionId, acceptablePrice: 0, collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(closeResult); expect(extractEvent(closeResult, "PositionClosed")).toBeDefined(); diff --git a/test/integration/helpers/scratch-lifecycle.ts b/test/integration/helpers/scratch-lifecycle.ts index b051484..2db029d 100644 --- a/test/integration/helpers/scratch-lifecycle.ts +++ b/test/integration/helpers/scratch-lifecycle.ts @@ -5,7 +5,7 @@ */ import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; import { Transaction } from "@mysten/sui/transactions"; -import { getAccountBalance, type WaterXClient } from "@waterx/perp-sdk"; +import { getAccountBalance, type PythCache, type WaterXClient } from "@waterx/perp-sdk"; import { expect } from "vitest"; import type { BaseAsset, CollateralAsset } from "../../../src/constants.ts"; @@ -13,6 +13,8 @@ import type { MarketData } from "../../../src/view-types.ts"; import { activeLifecycleTestBases } from "../../helpers/lifecycle-test-markets.ts"; import { assertSimulateSuccess, + extractSimulateError, + isOracleTransientFailureMessage, skipSimulateIfOracleTransient, } from "../../helpers/simulate-assertions.ts"; import { @@ -20,7 +22,7 @@ import { parseResizeSizingProbeResult, type ResizeSizingProbeParams, } from "../../helpers/simulate-resize-size.ts"; -import { assertSuccess } from "../setup.ts"; +import { assertSuccess, sleep } from "../setup.ts"; import { buildDepositCollateralFromWalletTx } from "./account-bootstrap.ts"; export type IntegrationExecTx = ( @@ -127,27 +129,67 @@ export async function ensureScratchLifecycleMinUsdc( return ensureScratchLifecycleMinCollateral(client, trader, accountId, owner, minBalance, "USDC", execTx); } +function integrationOracleSimMaxAttempts(): number { + const raw = process.env.WATERX_INTEGRATION_ORACLE_SIM_ATTEMPTS?.trim(); + if (!raw) return 3; + const n = Number(raw); + if (!Number.isFinite(n)) return 3; + return Math.min(10, Math.max(1, Math.trunc(n))); +} + +function integrationOracleSimRetryDelayMs(): number { + const raw = process.env.WATERX_INTEGRATION_ORACLE_SIM_RETRY_MS?.trim(); + if (!raw) return 800; + const n = Number(raw); + if (!Number.isFinite(n) || n < 0) return 800; + return Math.trunc(n); +} + /** * Dry-run `trading::resize` for one base (same wiring as {@link buildResolveSize}). On transient - * oracle failure, calls `ctx.skip` and returns `undefined`. + * oracle failure after retries, calls `ctx.skip` and returns `undefined`. + * + * Retries rebuild the PTB (fresh Hermes `updatePythPrices`) — helps flaky `err_total_weight_not_enough`. + * Tune with `WATERX_INTEGRATION_ORACLE_SIM_ATTEMPTS` (default 3, max 10) and + * `WATERX_INTEGRATION_ORACLE_SIM_RETRY_MS` (default 800). */ export async function simulateResizeForIntegrationOrSkip( ctx: { skip: (reason?: string) => void }, client: WaterXClient, base: BaseAsset, params: ResizeSizingProbeParams, + opts?: { pythCache?: PythCache }, ): Promise { const bases = [base]; - const { tx, resizeCommandIndexByBase } = await buildResizeSizingProbeTransaction( - client, - bases, - params, - ); - const raw = await client.simulate(tx); - if (skipSimulateIfOracleTransient(ctx, raw)) return undefined; - assertSimulateSuccess(raw, tx.getData().commands.length, { transaction: tx }); - const sizes = parseResizeSizingProbeResult(raw, bases, resizeCommandIndexByBase); - return sizes[base]!; + const maxAttempts = integrationOracleSimMaxAttempts(); + const retryMs = integrationOracleSimRetryDelayMs(); + + for (let attempt = 0; attempt < maxAttempts; attempt++) { + const { tx, resizeCommandIndexByBase } = await buildResizeSizingProbeTransaction( + client, + bases, + params, + { pythCache: opts?.pythCache }, + ); + const raw = await client.simulate(tx); + const r = raw as { $kind?: string }; + if (r.$kind !== "FailedTransaction") { + assertSimulateSuccess(raw, tx.getData().commands.length, { transaction: tx }); + const sizes = parseResizeSizingProbeResult(raw, bases, resizeCommandIndexByBase); + return sizes[base]!; + } + const msg = extractSimulateError(r); + if (!isOracleTransientFailureMessage(msg)) { + assertSimulateSuccess(raw, tx.getData().commands.length, { transaction: tx }); + } + if (attempt < maxAttempts - 1) { + await sleep(retryMs); + continue; + } + if (skipSimulateIfOracleTransient(ctx, raw)) return undefined; + assertSimulateSuccess(raw, tx.getData().commands.length, { transaction: tx }); + } + return undefined; } /** Assert simulated `resize` output is tradable for the current market snapshot. diff --git a/test/simulate/collateral-order-simulate.test.ts b/test/simulate/collateral-order-simulate.test.ts index 234c0e2..3ab56a9 100644 --- a/test/simulate/collateral-order-simulate.test.ts +++ b/test/simulate/collateral-order-simulate.test.ts @@ -13,7 +13,7 @@ import { cancelOrder, placeOrder } from "../../src/user/order.ts"; import { depositCollateral, openPosition, withdrawCollateral } from "../../src/user/trading.ts"; import { updatePythPrices } from "../../src/utils/pyth.ts"; import { buildOracleFeedForSimulate as buildOracleFeed } from "../helpers/build-oracle-feed-simulate.ts"; -import { ensureAtLeastFundedTtoUsdcCoinsForSimulate } from "../helpers/ensure-tto-usdc-coins-for-simulate.ts"; +import { ensureAtLeastFundedTtoCollateralCoinsForSimulate } from "../helpers/ensure-tto-collateral-coins-for-simulate.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; import { simulatePlaceCancelSinglePtbWithRetries } from "../helpers/place-cancel-probe.ts"; import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; @@ -97,11 +97,12 @@ describe("depositCollateral (single-PTB simulate, no keys)", () => { const cfg = client.config; const minPerCoin = OPEN_COLLATERAL >= DEP_COLLATERAL ? OPEN_COLLATERAL : DEP_COLLATERAL; - const funded = await ensureAtLeastFundedTtoUsdcCoinsForSimulate({ + const funded = await ensureAtLeastFundedTtoCollateralCoinsForSimulate({ ctx, client, accountId, - usdcType: cfg.collaterals.USDC.type, + collateralAsset: "USDC", + collateralType: cfg.collaterals.USDC.type, minBalancePerCoin: minPerCoin, needCount: 2, }); diff --git a/test/simulate/lifecycle-single-ptb.test.ts b/test/simulate/lifecycle-single-ptb.test.ts index f8c1b4e..6caf8d2 100644 --- a/test/simulate/lifecycle-single-ptb.test.ts +++ b/test/simulate/lifecycle-single-ptb.test.ts @@ -15,7 +15,7 @@ import { } from "@waterx/perp-sdk"; import { describe, it } from "vitest"; -import type { BaseAsset } from "../../src/constants.ts"; +import type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; import { PYTH_TESTNET_FEED_IDS, TESTNET_COLLATERALS } from "../../src/constants.ts"; import { closePosition, @@ -27,7 +27,7 @@ import { } from "../../src/user/trading.ts"; import { updatePythPrices } from "../../src/utils/pyth.ts"; import { buildOracleFeedForSimulate as buildOracleFeed } from "../helpers/build-oracle-feed-simulate.ts"; -import { ensureAtLeastFundedTtoUsdcCoinsForSimulate } from "../helpers/ensure-tto-usdc-coins-for-simulate.ts"; +import { ensureAtLeastFundedTtoCollateralCoinsForSimulate } from "../helpers/ensure-tto-collateral-coins-for-simulate.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS as OWNER } from "../helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../helpers/lifecycle-test-markets.ts"; import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; @@ -97,15 +97,20 @@ function assertSimulateSuccessOrSkipOracleWeak( assertSimulateSuccess(result, minCommands, { transaction: tx }); } -/** Best-effort Hermes → Pyth on-chain update for base + USDC feeds. */ -async function appendBestEffortPythUpdates(tx: Transaction, base: BaseAsset) { +/** Best-effort Hermes → Pyth on-chain update for base + collateral feeds. */ +async function appendBestEffortPythUpdates( + tx: Transaction, + base: BaseAsset, + collateralAsset: CollateralAsset, +) { const m = client.getMarketEntry(base); const cfg = client.config; const pythCfg = cfg.pythConfig!; const baseFeedId = PYTH_TESTNET_FEED_IDS[m.feedKey]!.replace(/^0x/, ""); - const usdcFeedId = PYTH_TESTNET_FEED_IDS[TESTNET_COLLATERALS.USDC.feedKey]!.replace(/^0x/, ""); + const collFeedKey = TESTNET_COLLATERALS[collateralAsset].feedKey; + const collFeedId = PYTH_TESTNET_FEED_IDS[collFeedKey]!.replace(/^0x/, ""); try { - await updatePythPrices(tx, client.grpcClient, pythCfg, [baseFeedId, usdcFeedId]); + await updatePythPrices(tx, client.grpcClient, pythCfg, [baseFeedId, collFeedId]); } catch { /* Hermes down */ } @@ -115,17 +120,18 @@ describe("open + increase (single-PTB simulate, no keys)", () => { for (const base of activeLifecycleTestBases()) { const row = lifecycleRow(base); const ptb = row.e2ePtb; - const minUsdc = ptb.openCollateral + ptb.increaseCollateral; + const collateralAsset = row.collateralAsset; + const minCollateral = ptb.openCollateral + ptb.increaseCollateral; it(`${base} ${row.isLong ? "long" : "short"} open → increase (single PTB dry-run)`, async (ctx) => { const accountId = await referenceAccountId(ctx); if (!accountId) return; - const usdc = client.config.collaterals.USDC; - const usdcBalance = await getAccountBalance(client, accountId, usdc.type); - if (usdcBalance < minUsdc) { + const coll = client.config.collaterals[collateralAsset]; + const collBalance = await getAccountBalance(client, accountId, coll.type); + if (collBalance < minCollateral) { ctx.skip( - `Insufficient USDC: have ${usdcBalance}, need ${minUsdc}. ` + + `Insufficient ${collateralAsset}: have ${collBalance}, need ${minCollateral}. ` + `Fund the integration wallet/UserAccount, then run \`pnpm e2e:prepare\` (or deposit manually).`, ); return; @@ -133,11 +139,12 @@ describe("open + increase (single-PTB simulate, no keys)", () => { const minPerCoin = ptb.openCollateral >= ptb.increaseCollateral ? ptb.openCollateral : ptb.increaseCollateral; - const funded = await ensureAtLeastFundedTtoUsdcCoinsForSimulate({ + const funded = await ensureAtLeastFundedTtoCollateralCoinsForSimulate({ ctx, client, accountId, - usdcType: usdc.type, + collateralAsset, + collateralType: coll.type, minBalancePerCoin: minPerCoin, needCount: 2, }); @@ -151,10 +158,10 @@ describe("open + increase (single-PTB simulate, no keys)", () => { tx.setSender(OWNER); tx.setGasBudget(300_000_000); - await appendBestEffortPythUpdates(tx, base); + await appendBestEffortPythUpdates(tx, base, collateralAsset); const cfg = client.config; const tradingBase = { - collateralTokenType: usdc.type, + collateralTokenType: coll.type, baseTokenType: m.baseType, lpTokenType: cfg.wlpType, market: m.marketId, @@ -162,7 +169,7 @@ describe("open + increase (single-PTB simulate, no keys)", () => { }; const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp1 = buildOracleFeed(client, tx, usdc.type, usdc.aggregatorId, usdc.priceInfoId); + const cp1 = buildOracleFeed(client, tx, coll.type, coll.aggregatorId, coll.priceInfoId); openPosition(client, tx, { ...tradingBase, receivingCoins: [funded[0]!], @@ -174,7 +181,7 @@ describe("open + increase (single-PTB simulate, no keys)", () => { }); const bp2 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp2 = buildOracleFeed(client, tx, usdc.type, usdc.aggregatorId, usdc.priceInfoId); + const cp2 = buildOracleFeed(client, tx, coll.type, coll.aggregatorId, coll.priceInfoId); increasePosition(client, tx, { ...tradingBase, positionId, @@ -195,6 +202,7 @@ describe("decrease existing position (single-op PTB simulate, cooldown prechecke for (const base of activeLifecycleTestBases()) { const row = lifecycleRow(base); const decSize = row.e2ePtb.decreaseSize; + const collateralAsset = row.collateralAsset; it(`${base}: decrease only`, async (ctx) => { const accountId = await referenceAccountId(ctx); @@ -225,15 +233,15 @@ describe("decrease existing position (single-op PTB simulate, cooldown prechecke return; } - const usdc = client.config.collaterals.USDC; + const coll = client.config.collaterals[collateralAsset]; const tx = new Transaction(); tx.setSender(OWNER); tx.setGasBudget(300_000_000); - await appendBestEffortPythUpdates(tx, base); + await appendBestEffortPythUpdates(tx, base, collateralAsset); const cfg = client.config; const tradingBase = { - collateralTokenType: usdc.type, + collateralTokenType: coll.type, baseTokenType: m.baseType, lpTokenType: cfg.wlpType, market: m.marketId, @@ -241,7 +249,7 @@ describe("decrease existing position (single-op PTB simulate, cooldown prechecke }; const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp1 = buildOracleFeed(client, tx, usdc.type, usdc.aggregatorId, usdc.priceInfoId); + const cp1 = buildOracleFeed(client, tx, coll.type, coll.aggregatorId, coll.priceInfoId); decreasePosition(client, tx, { ...tradingBase, positionId: existingPositionId, @@ -258,6 +266,9 @@ describe("decrease existing position (single-op PTB simulate, cooldown prechecke describe("deposit collateral on existing position (single-op PTB simulate, cooldown prechecked)", () => { for (const base of activeLifecycleTestBases()) { + const row = lifecycleRow(base); + const collateralAsset = row.collateralAsset; + it(`${base}: deposit collateral only`, async (ctx) => { const accountId = await referenceAccountId(ctx); if (!accountId) return; @@ -281,13 +292,13 @@ describe("deposit collateral on existing position (single-op PTB simulate, coold return; } - const usdc = client.config.collaterals.USDC; - const usdcCoins = await getAccountCoins(client, accountId, usdc.type); - const funded = usdcCoins + const coll = client.config.collaterals[collateralAsset]; + const collCoins = await getAccountCoins(client, accountId, coll.type); + const funded = collCoins .filter((c) => BigInt(c.balance) >= E2E_DEPOSIT_COLLATERAL) .map((c) => ({ objectId: c.objectId, version: BigInt(c.version), digest: c.digest })); if (!funded.length) { - ctx.skip(`No TTO USDC coin with balance ≥ ${E2E_DEPOSIT_COLLATERAL}.`); + ctx.skip(`No TTO ${collateralAsset} coin with balance ≥ ${E2E_DEPOSIT_COLLATERAL}.`); return; } @@ -295,10 +306,10 @@ describe("deposit collateral on existing position (single-op PTB simulate, coold tx.setSender(OWNER); tx.setGasBudget(300_000_000); - await appendBestEffortPythUpdates(tx, base); + await appendBestEffortPythUpdates(tx, base, collateralAsset); const cfg = client.config; const tradingBase = { - collateralTokenType: usdc.type, + collateralTokenType: coll.type, baseTokenType: m.baseType, lpTokenType: cfg.wlpType, market: m.marketId, @@ -306,7 +317,7 @@ describe("deposit collateral on existing position (single-op PTB simulate, coold }; const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp1 = buildOracleFeed(client, tx, usdc.type, usdc.aggregatorId, usdc.priceInfoId); + const cp1 = buildOracleFeed(client, tx, coll.type, coll.aggregatorId, coll.priceInfoId); depositCollateral(client, tx, { ...tradingBase, positionId: existingPositionId, @@ -324,6 +335,9 @@ describe("deposit collateral on existing position (single-op PTB simulate, coold describe("withdraw collateral on existing position (single-op PTB simulate, cooldown prechecked)", () => { for (const base of activeLifecycleTestBases()) { + const row = lifecycleRow(base); + const collateralAsset = row.collateralAsset; + it(`${base}: withdraw collateral only`, async (ctx) => { const accountId = await referenceAccountId(ctx); if (!accountId) return; @@ -354,15 +368,15 @@ describe("withdraw collateral on existing position (single-op PTB simulate, cool return; } - const usdc = client.config.collaterals.USDC; + const coll = client.config.collaterals[collateralAsset]; const tx = new Transaction(); tx.setSender(OWNER); tx.setGasBudget(300_000_000); - await appendBestEffortPythUpdates(tx, base); + await appendBestEffortPythUpdates(tx, base, collateralAsset); const cfg = client.config; const tradingBase = { - collateralTokenType: usdc.type, + collateralTokenType: coll.type, baseTokenType: m.baseType, lpTokenType: cfg.wlpType, market: m.marketId, @@ -370,7 +384,7 @@ describe("withdraw collateral on existing position (single-op PTB simulate, cool }; const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp1 = buildOracleFeed(client, tx, usdc.type, usdc.aggregatorId, usdc.priceInfoId); + const cp1 = buildOracleFeed(client, tx, coll.type, coll.aggregatorId, coll.priceInfoId); withdrawCollateral(client, tx, { ...tradingBase, positionId: existingPositionId, @@ -387,6 +401,9 @@ describe("withdraw collateral on existing position (single-op PTB simulate, cool describe("close existing position (single-op PTB simulate, cooldown prechecked)", () => { for (const base of activeLifecycleTestBases()) { + const row = lifecycleRow(base); + const collateralAsset = row.collateralAsset; + it(`${base}: close only`, async (ctx) => { const accountId = await referenceAccountId(ctx); if (!accountId) return; @@ -410,15 +427,15 @@ describe("close existing position (single-op PTB simulate, cooldown prechecked)" return; } - const usdc = client.config.collaterals.USDC; + const coll = client.config.collaterals[collateralAsset]; const tx = new Transaction(); tx.setSender(OWNER); tx.setGasBudget(300_000_000); - await appendBestEffortPythUpdates(tx, base); + await appendBestEffortPythUpdates(tx, base, collateralAsset); const cfg = client.config; const tradingBase = { - collateralTokenType: usdc.type, + collateralTokenType: coll.type, baseTokenType: m.baseType, lpTokenType: cfg.wlpType, market: m.marketId, @@ -426,7 +443,7 @@ describe("close existing position (single-op PTB simulate, cooldown prechecked)" }; const bp1 = buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); - const cp1 = buildOracleFeed(client, tx, usdc.type, usdc.aggregatorId, usdc.priceInfoId); + const cp1 = buildOracleFeed(client, tx, coll.type, coll.aggregatorId, coll.priceInfoId); closePosition(client, tx, { ...tradingBase, positionId: existingPositionId, diff --git a/test/simulate/trading-negative-simulate.test.ts b/test/simulate/trading-negative-simulate.test.ts index 1e7be30..5dec4bb 100644 --- a/test/simulate/trading-negative-simulate.test.ts +++ b/test/simulate/trading-negative-simulate.test.ts @@ -2,14 +2,22 @@ * Simulate-only negative tests: expect `FailedTransaction` with specific `waterx_perp::error` abort codes. * Per-base coverage matches `activeLifecycleTestBases()` / PRD TC-TRADE-003 (104 or 105 per on-chain check order; no SOL-only oracle wording). */ -import { buildOpenPositionTx, getAccountsByOwner, getMarketSummary } from "@waterx/perp-sdk"; +import { + buildOpenPositionTx, + buildPlaceOrderTx, + getAccountBalance, + getAccountsByOwner, + getMarketSummary, +} from "@waterx/perp-sdk"; import { describe, it } from "vitest"; +import type { CollateralAsset } from "../../src/constants.ts"; import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../helpers/lifecycle-test-markets.ts"; import { openInvalidSizeAbortPossible } from "../helpers/market-summary-assertions.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; +import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; import { assertSimulateMoveAbort, assertSimulateMoveAbortOneOf, @@ -43,6 +51,26 @@ async function firstAccountId(ctx: { skip: (reason?: string) => void }): Promise } } +function normCoinType(t: string): string { + return t.trim().toLowerCase(); +} + +/** Map on-chain position `collateralType` string to SDK {@link CollateralAsset}. */ +function collateralAssetForPositionType( + positionCollateralType: string, +): CollateralAsset | undefined { + const want = normCoinType(positionCollateralType); + for (const { asset, coinType } of client.getCollateralAssets()) { + if (normCoinType(coinType) === want) return asset; + } + return undefined; +} + +function pickOtherCollateralAsset(actual: CollateralAsset): CollateralAsset | undefined { + const assets = client.getCollateralAssets().map((r) => r.asset) as CollateralAsset[]; + return assets.find((a) => a !== actual); +} + describe("Simulate: trading expected failures (MoveAbort)", () => { for (const base of activeLifecycleTestBases()) { const row = lifecycleRow(base); @@ -114,4 +142,64 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { }); }, 60_000); } + + /** + * Reverse path: `trading::execute_place_order` requires the PTB collateral type to match the + * linked position (`err_invalid_collateral_type` / 208). Needs an open position on the reference + * account plus free balance of a *different* configured collateral (often USDSUI). + */ + it( + "linked placeOrder with mismatched collateral vs position → err_invalid_collateral_type (208)", + async (ctx) => { + const accountId = await firstAccountId(ctx); + if (!accountId) return; + + const orderCollateralRaw = 10_000_000n; + + for (const base of activeLifecycleTestBases()) { + const resolved = await resolveE2eOpenPosition(client, accountId, base); + if (!resolved) continue; + + const positionAsset = collateralAssetForPositionType(resolved.info.collateralType); + if (!positionAsset) continue; + + const wrongAsset = pickOtherCollateralAsset(positionAsset); + if (!wrongAsset) { + ctx.skip("Only one collateral in client config — cannot test cross-collateral mismatch."); + return; + } + + const wrongCoinType = client.config.collaterals[wrongAsset].type; + const bal = await getAccountBalance(client, accountId, wrongCoinType); + if (bal < orderCollateralRaw) continue; + + const row = lifecycleRow(base); + const tx = await buildPlaceOrderTx(client, { + accountId, + base, + collateral: wrongAsset, + isLong: !resolved.info.isLong, + reduceOnly: true, + collateralAmount: orderCollateralRaw, + size: row.e2ePtb.decreaseSize, + triggerPrice: row.approxPrice, + linkedPositionId: Number(resolved.positionId), + updatePythPrice: true, + }); + tx.setSender(OWNER); + const result = await client.simulate(tx); + if (skipSimulateIfOracleTransient(ctx, result)) return; + assertSimulateMoveAbort(result, { + abortCode: WATERX_PERP_ABORT.INVALID_COLLATERAL_TYPE, + locationIncludes: "err_invalid_collateral_type", + }); + return; + } + + ctx.skip( + "No open position found with enough non-position collateral on account for mismatch probe (fund alt collateral or bootstrap e2e positions).", + ); + }, + 120_000, + ); }); From f3ee73bf2c878beafd75188f0ff30c922c9a1c7c Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Sat, 18 Apr 2026 00:04:24 +0800 Subject: [PATCH 7/9] ci: run workflows on pull requests to any base branch Made-with: Cursor --- .github/workflows/check-secrets.yml | 2 -- .github/workflows/ci.yml | 4 +--- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/.github/workflows/check-secrets.yml b/.github/workflows/check-secrets.yml index fa9932d..2987bd4 100644 --- a/.github/workflows/check-secrets.yml +++ b/.github/workflows/check-secrets.yml @@ -2,8 +2,6 @@ name: Check Secrets on: pull_request: - branches: - - main jobs: check-secrets: diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f3ebc45..267d860 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,4 +1,4 @@ -# Single PR pipeline for `main`: replaces legacy `lint.yml` + `unit-test.yml` (no duplicate runs). +# PR pipeline for any base branch: replaces legacy `lint.yml` + `unit-test.yml` (no duplicate runs). # Core: pnpm lint, typecheck, build, test:ci (unit + coverage + JUnit, then simulate / e2e + JUnit). # Extra: Trivy, Semgrep, gitleaks, pnpm audit. Integration tests stay local (`pnpm test:integration`). @@ -6,8 +6,6 @@ name: CI on: pull_request: - branches: - - main permissions: contents: read From 7ff7e3358233c0d0ac7d788ee5beb9113eb314b5 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Sat, 18 Apr 2026 00:06:21 +0800 Subject: [PATCH 8/9] style: apply eslint --fix and prettier Made-with: Cursor --- scripts/e2e-preflight.ts | 6 +- scripts/e2e-prepare.ts | 11 ++- scripts/print-oracle-aggregates.ts | 2 +- scripts/setup-e2e-delegate.ts | 5 +- test/helpers/ensure-e2e-delegate.ts | 2 +- ...nsure-tto-collateral-coins-for-simulate.ts | 11 +-- test/helpers/load-trading-fixtures.ts | 8 +- test/integration/helpers/scratch-lifecycle.ts | 10 +- test/simulate/e2e-delegate-simulate.test.ts | 5 +- .../trading-negative-simulate.test.ts | 98 +++++++++---------- test/unit/e2e-delegate-helpers.test.ts | 9 +- 11 files changed, 86 insertions(+), 81 deletions(-) diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index 9e04bf3..d4f3c15 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -47,13 +47,13 @@ import { e2eTtoMinFundedPerCoinUsdsui, } from "../test/helpers/e2e-tto-split-thresholds.ts"; import { collectE2eWlpReadinessIssues } from "../test/helpers/e2e-wlp-readiness.ts"; -import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; -import { activeLifecycleTestBases, lifecycleRow } from "../test/helpers/lifecycle-test-markets.ts"; -import { resolveE2eOpenPosition } from "../test/helpers/resolve-e2e-open-position.ts"; import { checkE2eDelegateReady, resolvePinnedE2eDelegateAddress, } from "../test/helpers/ensure-e2e-delegate.ts"; +import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; +import { activeLifecycleTestBases, lifecycleRow } from "../test/helpers/lifecycle-test-markets.ts"; +import { resolveE2eOpenPosition } from "../test/helpers/resolve-e2e-open-position.ts"; import { resolveE2eAccountForOwner } from "../test/helpers/resolve-e2e-reference-account.ts"; export type CheckStatus = "OK" | "FAIL" | "SKIP"; diff --git a/scripts/e2e-prepare.ts b/scripts/e2e-prepare.ts index 68ced44..c9278dc 100644 --- a/scripts/e2e-prepare.ts +++ b/scripts/e2e-prepare.ts @@ -29,11 +29,11 @@ import { persistE2eFixedPositionsLocal, shouldAutoPersistLocalFixedPositions, } from "../test/helpers/e2e-fixed-positions-persist.ts"; +import { ensureE2ePersistentPerpSlots } from "../test/helpers/e2e-persistent-perp-slots.ts"; import { e2eTtoMinFundedPerCoinUsdc, e2eTtoMinFundedPerCoinUsdsui, } from "../test/helpers/e2e-tto-split-thresholds.ts"; -import { ensureE2ePersistentPerpSlots } from "../test/helpers/e2e-persistent-perp-slots.ts"; import { E2E_WALLET_WLP_MIN_RAW, e2eWalletCollateralMinForMintSimulate, @@ -116,7 +116,9 @@ async function main() { ); for (let i = 0; i < need; i++) { if (dryRun) { - console.log(`[dry-run/${label}] would deposit one split ${asset} coin amount=${minPerCoin}`); + console.log( + `[dry-run/${label}] would deposit one split ${asset} coin amount=${minPerCoin}`, + ); continue; } const tx = await buildDepositCollateralFromWalletTx( @@ -173,9 +175,8 @@ async function main() { } if (ensureDelegate) { - const { ensureE2eDelegateOnChain, resolvePinnedE2eDelegateAddress } = await import( - "../test/helpers/ensure-e2e-delegate.ts", - ); + const { ensureE2eDelegateOnChain, resolvePinnedE2eDelegateAddress } = + await import("../test/helpers/ensure-e2e-delegate.ts"); if (!resolvePinnedE2eDelegateAddress()) { console.log( "[prepare] --ensure-delegate: skip (set trading-config `e2eDelegate.delegateAddress` or WATERX_E2E_DELEGATE_ADDRESS)", diff --git a/scripts/print-oracle-aggregates.ts b/scripts/print-oracle-aggregates.ts index 116f488..888ff3b 100644 --- a/scripts/print-oracle-aggregates.ts +++ b/scripts/print-oracle-aggregates.ts @@ -1,9 +1,9 @@ import { Transaction } from "@mysten/sui/transactions"; import { buildOracleFeed, - PythCache, PYTH_PRICE_FEED_IDS, PYTH_TESTNET_FEED_IDS, + PythCache, updatePythPrices, } from "@waterx/perp-sdk"; diff --git a/scripts/setup-e2e-delegate.ts b/scripts/setup-e2e-delegate.ts index 6355438..094bcb3 100644 --- a/scripts/setup-e2e-delegate.ts +++ b/scripts/setup-e2e-delegate.ts @@ -12,7 +12,10 @@ * pnpm e2e:setup-delegate -- --dry-run */ import { WaterXClient } from "../src/index.ts"; -import { ensureE2eDelegateOnChain, resolvePinnedE2eDelegateAddress } from "../test/helpers/ensure-e2e-delegate.ts"; +import { + ensureE2eDelegateOnChain, + resolvePinnedE2eDelegateAddress, +} from "../test/helpers/ensure-e2e-delegate.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../test/helpers/integration-reference-wallet.ts"; import { ensureUserAccountForIntegration } from "../test/integration/helpers/account-bootstrap.ts"; import { assertSuccess, execTx, loadIntegrationTraderKeypair } from "../test/integration/setup.ts"; diff --git a/test/helpers/ensure-e2e-delegate.ts b/test/helpers/ensure-e2e-delegate.ts index b3a6b2f..a566773 100644 --- a/test/helpers/ensure-e2e-delegate.ts +++ b/test/helpers/ensure-e2e-delegate.ts @@ -3,8 +3,8 @@ * Address: `test/fixtures/trading/trading-config.json` → `e2eDelegate.delegateAddress`, overridden by * `WATERX_E2E_DELEGATE_ADDRESS`. */ -import { Transaction } from "@mysten/sui/transactions"; import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"; +import { Transaction } from "@mysten/sui/transactions"; import type { WaterXClient } from "../../src/client.ts"; import { getAccountDelegates } from "../../src/fetch.ts"; diff --git a/test/helpers/ensure-tto-collateral-coins-for-simulate.ts b/test/helpers/ensure-tto-collateral-coins-for-simulate.ts index 5369863..135522c 100644 --- a/test/helpers/ensure-tto-collateral-coins-for-simulate.ts +++ b/test/helpers/ensure-tto-collateral-coins-for-simulate.ts @@ -50,15 +50,8 @@ export async function ensureAtLeastFundedTtoCollateralCoinsForSimulate(opts: { minBalancePerCoin: bigint; needCount: number; }): Promise { - const { - ctx, - client, - accountId, - collateralAsset, - collateralType, - minBalancePerCoin, - needCount, - } = opts; + const { ctx, client, accountId, collateralAsset, collateralType, minBalancePerCoin, needCount } = + opts; async function listFunded(): Promise { const coins = await getAccountCoins(client, accountId, collateralType); diff --git a/test/helpers/load-trading-fixtures.ts b/test/helpers/load-trading-fixtures.ts index bdcd204..f3b409a 100644 --- a/test/helpers/load-trading-fixtures.ts +++ b/test/helpers/load-trading-fixtures.ts @@ -158,7 +158,10 @@ for (const [k, v] of Object.entries(cfg.persistentPerp.markets)) { leverage: v.leverage, openCollateral: BigInt(v.openCollateral), openSize: BigInt(v.openSize), - collateralAsset: parseCollateralAsset(v.collateralAsset, "persistentPerp.markets.collateralAsset"), + collateralAsset: parseCollateralAsset( + v.collateralAsset, + "persistentPerp.markets.collateralAsset", + ), }; if (v.simulateLeverage !== undefined) row.simulateLeverage = v.simulateLeverage; parsedPersistent[k as BaseAsset] = row; @@ -179,8 +182,7 @@ export const E2E_PERSISTENT_ACCOUNT_BUFFER_USDC = BigInt(cfg.persistentWlp.accou /** Pinned delegate for preflight / `e2e:setup-delegate` (env `WATERX_E2E_DELEGATE_ADDRESS` overrides address). */ export const E2E_DELEGATE_CONFIG = { delegateAddress: (cfg.e2eDelegate?.delegateAddress ?? "").trim(), - permissions: - typeof cfg.e2eDelegate?.permissions === "number" ? cfg.e2eDelegate.permissions : 12, + permissions: typeof cfg.e2eDelegate?.permissions === "number" ? cfg.e2eDelegate.permissions : 12, } as const; /** Min raw WLP on the reference **wallet** so redeem/cancel simulate can pick a coin. */ diff --git a/test/integration/helpers/scratch-lifecycle.ts b/test/integration/helpers/scratch-lifecycle.ts index 2db029d..f77f3ab 100644 --- a/test/integration/helpers/scratch-lifecycle.ts +++ b/test/integration/helpers/scratch-lifecycle.ts @@ -126,7 +126,15 @@ export async function ensureScratchLifecycleMinUsdc( minBalance: bigint, execTx: IntegrationExecTx, ): Promise { - return ensureScratchLifecycleMinCollateral(client, trader, accountId, owner, minBalance, "USDC", execTx); + return ensureScratchLifecycleMinCollateral( + client, + trader, + accountId, + owner, + minBalance, + "USDC", + execTx, + ); } function integrationOracleSimMaxAttempts(): number { diff --git a/test/simulate/e2e-delegate-simulate.test.ts b/test/simulate/e2e-delegate-simulate.test.ts index 5baecc2..b7a9061 100644 --- a/test/simulate/e2e-delegate-simulate.test.ts +++ b/test/simulate/e2e-delegate-simulate.test.ts @@ -5,7 +5,10 @@ import { getAccountsByOwner } from "@waterx/perp-sdk"; import { describe, expect, it } from "vitest"; -import { checkE2eDelegateReady, resolvePinnedE2eDelegateAddress } from "../helpers/ensure-e2e-delegate.ts"; +import { + checkE2eDelegateReady, + resolvePinnedE2eDelegateAddress, +} from "../helpers/ensure-e2e-delegate.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { client } from "../helpers/testnet.ts"; diff --git a/test/simulate/trading-negative-simulate.test.ts b/test/simulate/trading-negative-simulate.test.ts index 5dec4bb..d4c156d 100644 --- a/test/simulate/trading-negative-simulate.test.ts +++ b/test/simulate/trading-negative-simulate.test.ts @@ -16,8 +16,8 @@ import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../helpers/lifecycle-test-markets.ts"; import { openInvalidSizeAbortPossible } from "../helpers/market-summary-assertions.ts"; -import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; +import { pickE2eAccountIdForOwner } from "../helpers/resolve-e2e-reference-account.ts"; import { assertSimulateMoveAbort, assertSimulateMoveAbortOneOf, @@ -148,58 +148,54 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { * linked position (`err_invalid_collateral_type` / 208). Needs an open position on the reference * account plus free balance of a *different* configured collateral (often USDSUI). */ - it( - "linked placeOrder with mismatched collateral vs position → err_invalid_collateral_type (208)", - async (ctx) => { - const accountId = await firstAccountId(ctx); - if (!accountId) return; + it("linked placeOrder with mismatched collateral vs position → err_invalid_collateral_type (208)", async (ctx) => { + const accountId = await firstAccountId(ctx); + if (!accountId) return; + + const orderCollateralRaw = 10_000_000n; - const orderCollateralRaw = 10_000_000n; - - for (const base of activeLifecycleTestBases()) { - const resolved = await resolveE2eOpenPosition(client, accountId, base); - if (!resolved) continue; - - const positionAsset = collateralAssetForPositionType(resolved.info.collateralType); - if (!positionAsset) continue; - - const wrongAsset = pickOtherCollateralAsset(positionAsset); - if (!wrongAsset) { - ctx.skip("Only one collateral in client config — cannot test cross-collateral mismatch."); - return; - } - - const wrongCoinType = client.config.collaterals[wrongAsset].type; - const bal = await getAccountBalance(client, accountId, wrongCoinType); - if (bal < orderCollateralRaw) continue; - - const row = lifecycleRow(base); - const tx = await buildPlaceOrderTx(client, { - accountId, - base, - collateral: wrongAsset, - isLong: !resolved.info.isLong, - reduceOnly: true, - collateralAmount: orderCollateralRaw, - size: row.e2ePtb.decreaseSize, - triggerPrice: row.approxPrice, - linkedPositionId: Number(resolved.positionId), - updatePythPrice: true, - }); - tx.setSender(OWNER); - const result = await client.simulate(tx); - if (skipSimulateIfOracleTransient(ctx, result)) return; - assertSimulateMoveAbort(result, { - abortCode: WATERX_PERP_ABORT.INVALID_COLLATERAL_TYPE, - locationIncludes: "err_invalid_collateral_type", - }); + for (const base of activeLifecycleTestBases()) { + const resolved = await resolveE2eOpenPosition(client, accountId, base); + if (!resolved) continue; + + const positionAsset = collateralAssetForPositionType(resolved.info.collateralType); + if (!positionAsset) continue; + + const wrongAsset = pickOtherCollateralAsset(positionAsset); + if (!wrongAsset) { + ctx.skip("Only one collateral in client config — cannot test cross-collateral mismatch."); return; } - ctx.skip( - "No open position found with enough non-position collateral on account for mismatch probe (fund alt collateral or bootstrap e2e positions).", - ); - }, - 120_000, - ); + const wrongCoinType = client.config.collaterals[wrongAsset].type; + const bal = await getAccountBalance(client, accountId, wrongCoinType); + if (bal < orderCollateralRaw) continue; + + const row = lifecycleRow(base); + const tx = await buildPlaceOrderTx(client, { + accountId, + base, + collateral: wrongAsset, + isLong: !resolved.info.isLong, + reduceOnly: true, + collateralAmount: orderCollateralRaw, + size: row.e2ePtb.decreaseSize, + triggerPrice: row.approxPrice, + linkedPositionId: Number(resolved.positionId), + updatePythPrice: true, + }); + tx.setSender(OWNER); + const result = await client.simulate(tx); + if (skipSimulateIfOracleTransient(ctx, result)) return; + assertSimulateMoveAbort(result, { + abortCode: WATERX_PERP_ABORT.INVALID_COLLATERAL_TYPE, + locationIncludes: "err_invalid_collateral_type", + }); + return; + } + + ctx.skip( + "No open position found with enough non-position collateral on account for mismatch probe (fund alt collateral or bootstrap e2e positions).", + ); + }, 120_000); }); diff --git a/test/unit/e2e-delegate-helpers.test.ts b/test/unit/e2e-delegate-helpers.test.ts index 6b8da16..a0dbb4d 100644 --- a/test/unit/e2e-delegate-helpers.test.ts +++ b/test/unit/e2e-delegate-helpers.test.ts @@ -1,10 +1,7 @@ import { describe, expect, it } from "vitest"; -import { - delegateHasPlaceOrder, - normalizeSuiAddress, -} from "../helpers/ensure-e2e-delegate.ts"; import { DELEGATE_PERM } from "../helpers/delegate-perms.ts"; +import { delegateHasPlaceOrder, normalizeSuiAddress } from "../helpers/ensure-e2e-delegate.ts"; describe("e2e delegate helpers", () => { it("normalizeSuiAddress strips 0x and lowercases", () => { @@ -16,6 +13,8 @@ describe("e2e delegate helpers", () => { expect(delegateHasPlaceOrder(0)).toBe(false); expect(delegateHasPlaceOrder(DELEGATE_PERM.PLACE_ORDER)).toBe(true); expect(delegateHasPlaceOrder(DELEGATE_PERM.CANCEL_ORDER)).toBe(false); - expect(delegateHasPlaceOrder(DELEGATE_PERM.PLACE_ORDER | DELEGATE_PERM.CANCEL_ORDER)).toBe(true); + expect(delegateHasPlaceOrder(DELEGATE_PERM.PLACE_ORDER | DELEGATE_PERM.CANCEL_ORDER)).toBe( + true, + ); }); }); From 5171ff56fdb4ec0d39f397f3e63dbd43e3048d96 Mon Sep 17 00:00:00 2001 From: do0x0ob Date: Sat, 18 Apr 2026 00:52:18 +0800 Subject: [PATCH 9/9] test: stabilize oracle USD probes and fix Vitest require mangling - Rename requireOracleUsdOrSkip to oracleUsdForBaseOrSkip so esbuild/Vitest does not treat the import as CommonJS require (fixes runtime is not a function). - Extend bundled oracle pricing + e2e preflight, fixtures, and scratch harness. Made-with: Cursor --- scripts/e2e-preflight.ts | 32 ++--- test/README.md | 13 +- test/fixtures/trading/trading-config.json | 1 + test/helpers/e2e-oracle-context.ts | 65 ++++++--- test/helpers/oracle-simulate-multi-asset.ts | 135 +++++++++++++----- .../run-scratch-trading-scenario-simulate.ts | 8 +- test/integration/helpers/scratch-lifecycle.ts | 14 +- test/simulate/prd-product-coverage.test.ts | 38 ++--- .../trading-negative-simulate.test.ts | 6 +- 9 files changed, 203 insertions(+), 109 deletions(-) diff --git a/scripts/e2e-preflight.ts b/scripts/e2e-preflight.ts index d4f3c15..4f80319 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -386,21 +386,7 @@ export async function runPreflight( } for (const base of activeLifecycleTestBases()) { - // xStock Pyth feeds publish only during US cash-equity market hours. Off-hours the - // Hermes price is stale and on-chain `pyth_rule` refuses it → `err_total_weight_not_enough`. - // That is a structural, time-of-day truth about the feed — not a preflight prerequisite — - // so we defer oracle liveness for xStocks to the e2e runtime (tests can skip by - // market-hour when/if they need it) rather than inflate preflight FAIL counts here. - if (isXStockBase(base)) { - rows.push({ - name: `${base} oracle readiness (simulate open)`, - status: "SKIP", - kind: "info", - detail: - "skipped: xStock — Pyth publishes during US market hours only; oracle liveness deferred to e2e runtime", - }); - continue; - } + const xStock = isXStockBase(base); const row = lifecycleRow(base); try { // `updatePythPrice: true` inlines a Pyth price-feed update (fetched from Hermes) into the @@ -428,7 +414,21 @@ export async function runPreflight( }); } else { const msg = simErr(result); - if (isOracleTransient(msg)) { + const transient = isOracleTransient(msg); + // xStock Pyth feeds publish only during US cash-equity market hours (incl. extended). + // Off-hours the Hermes price is stale and on-chain `pyth_rule` refuses it → + // `err_total_weight_not_enough`. That is a structural, time-of-day truth about the feed, + // not a preflight prerequisite, so we downgrade oracle_transient to SKIP for xStocks + // instead of inflating the FAIL count. During market hours xStocks still produce OK + // (catches real oracle/aggregator regressions); non-transient failures stay as FAIL. + if (xStock && transient) { + rows.push({ + name: `${base} oracle readiness (simulate open)`, + status: "SKIP", + kind: "info", + detail: "xStock oracle stale (likely US market closed / Hermes beta lag)", + }); + } else if (transient) { rows.push({ name: `${base} oracle readiness (simulate open)`, status: "FAIL", diff --git a/test/README.md b/test/README.md index f263261..ecad552 100644 --- a/test/README.md +++ b/test/README.md @@ -44,7 +44,7 @@ PRs to `main` run [`.github/workflows/ci.yml`](../.github/workflows/ci.yml): `Li | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- | | `pnpm e2e:preflight` | Check testnet objects / oracle / **wallet WLP + collaterals** for `wlp-simulate` (`scripts/e2e-preflight.ts`; CI adds `--allow-missing-wlp`, `--allow-missing-e2e-delegate`). **Requires a recent on-chain open position per `activeLifecycleTestBases()`**; use `e2e:bootstrap-positions` with `persistentPerp.markets` covering those bases. If `e2eDelegate.delegateAddress` or `WATERX_E2E_DELEGATE_ADDRESS` is set, verifies that address has **PLACE_ORDER** on the reference account (`pnpm e2e:setup-delegate`). | | `pnpm e2e:prepare` | TTO USDC split, cooldown wait, **wallet WLP + collateral top-up** from account when possible (`scripts/e2e-prepare.ts`). Optional `--ensure-delegate` runs `e2e:setup-delegate` logic when `e2eDelegate` / `WATERX_E2E_DELEGATE_ADDRESS` is set. | -| `pnpm e2e:setup-delegate` | Owner-signed **addDelegate** / **updateDelegatePermissions** for the pinned address in `trading-config` `e2eDelegate` (or env). | +| `pnpm e2e:setup-delegate` | Owner-signed **addDelegate** / **updateDelegatePermissions** for the pinned address in `trading-config` `e2eDelegate` (or env). See "E2e delegate address" below. | | `pnpm e2e:bootstrap-positions` | Bootstrap lifecycle positions for e2e | ## Integration (trader) @@ -61,7 +61,7 @@ Simulate tests resolve the reference **`UserAccount`** via **`resolveE2eAccountF 1. **`test/helpers/e2e-fixed-positions.ts`** — optional committed `E2E_FIXED_OPEN_POSITION_IDS` 2. Env **`E2E_FIXED_BTC_POSITION_ID`** (and `E2E_FIXED_ETH_POSITION_ID`, …) -3. **`.e2e-fixed-positions.local.json`** (committable) — same `accountId` only; auto-refreshed when you run **`pnpm e2e:preflight`** (runs **even if preflight exits 1**, so stale/missed BTC ids can be captured), **`pnpm e2e:prepare`**, **`pnpm e2e:bootstrap-positions`**, or **`pnpm diagnose:positions`** — skipped on **`GITHUB_ACTIONS`** or if **`E2E_NO_LOCAL_FIXED_POSITIONS=1`** +3. **`.e2e-fixed-positions.local.json`** (committable — **intentionally tracked, not gitignored**) — same `accountId` only; auto-refreshed when you run **`pnpm e2e:preflight`** (runs **even if preflight exits 1**, so stale/missed BTC ids can be captured), **`pnpm e2e:prepare`**, **`pnpm e2e:bootstrap-positions`**, or **`pnpm diagnose:positions`** — skipped on **`GITHUB_ACTIONS`** or if **`E2E_NO_LOCAL_FIXED_POSITIONS=1`**. Contains only public on-chain position ids (no secrets); committing it lets contributors reuse the shared integration account's slots without bootstrapping their own. **CI:** GitHub Actions never writes this file; **`pnpm test:ci:e2e`** uses **strict** preflight. Preflight expects an **on-chain open position for every enabled lifecycle base**; `persistentPerp.markets` should list each so `e2e:bootstrap-positions` can open them. Simulate tests can still skip other stateful cases when runtime state is missing. @@ -73,6 +73,15 @@ Use **`pnpm diagnose:positions`** to inspect BTC ids and refresh the local file. In code, **`listAllAccountPositions(client, accountId, maxScan)`** / **`listAccountPositionsInMarket`** / **`resolveE2eOpenPosition`** only need that **`accountId`** (UserAccount object id). +## E2e delegate address + +**`test/fixtures/trading/trading-config.json` → `e2eDelegate.delegateAddress`** is pinned to the shared testnet delegate used by this repo's CI/local preflight (a public address with no keys in-tree — it exists only as a permission target on the shared integration `UserAccount`). Two things to know: + +- **Fork / non-CI contributors:** the pinned address won't have `PLACE_ORDER` on *your* `UserAccount`, so `pnpm e2e:preflight` reports the "E2E pinned delegate" row as `[FAIL] e2e_delegate_missing`. To unblock locally, either: + - Override with your own delegate address: **`WATERX_E2E_DELEGATE_ADDRESS=0x…`** (takes precedence over the JSON), then run `pnpm e2e:setup-delegate` (owner signs `addDelegate`) so the row passes. + - Or run with **`pnpm e2e:preflight -- --allow-missing-e2e-delegate`** to downgrade the row to non-blocking while iterating. +- **Editing the committed value:** only change `e2eDelegate.delegateAddress` in the JSON after coordinating across the shared integration wallet, since every branch sharing this file expects the same delegate to be authorized on the shared `UserAccount`. + ## Related: oracle debug (not Vitest) | Command | Purpose | diff --git a/test/fixtures/trading/trading-config.json b/test/fixtures/trading/trading-config.json index 8194a11..0c68d47 100644 --- a/test/fixtures/trading/trading-config.json +++ b/test/fixtures/trading/trading-config.json @@ -286,6 +286,7 @@ "openSize": "10000000" }, "DEEP": { + "_note": "Kept in sync with lifecycleMarkets.DEEP but excluded from enabledE2eBases: Hermes-beta DEEP_USD feed is dead on testnet (publish_time ~1 year stale). Re-add \"DEEP\" to enabledE2eBases once the feed is republished or the market is removed.", "isLong": false, "leverage": 4, "openCollateral": "10000000", diff --git a/test/helpers/e2e-oracle-context.ts b/test/helpers/e2e-oracle-context.ts index 6711179..7016b8c 100644 --- a/test/helpers/e2e-oracle-context.ts +++ b/test/helpers/e2e-oracle-context.ts @@ -11,29 +11,30 @@ import type { BaseAsset } from "../../src/constants.ts"; import { activeLifecycleTestBases } from "./lifecycle-test-markets.ts"; import { fetchSimulatedUsdPricesForBases } from "./oracle-simulate-multi-asset.ts"; +export type LifecycleOraclePrices = Partial>; + /** - * Probes oracle USD prices for all lifecycle bases via a single simulate TX. - * - * Before probing, issues a Hermes update inside the simulate TX so that Pyth - * `PriceInfoObject`s carry fresh data — avoids `err_total_weight_not_enough (204)` - * when on-chain prices are stale. A shared `PythCache` is used so Hermes + - * on-chain reads are fetched once across all feeds. + * Probes oracle USD prices for every lifecycle base via one bundled simulate (with per-base + * fallback inside {@link fetchSimulatedUsdPricesForBases}). * - * If Hermes is unreachable or the simulate fails, the test is skipped. + * Semantics: + * - Returns a **partial** map. Each caller must check `prices[base] !== undefined` (or use + * {@link oracleUsdForBaseOrSkip}) before indexing for a specific base. + * - Only skips (and returns `null`) when **every** probed base is unavailable — a single dead + * feed (stale xStock out of US hours, transient Hermes) no longer cascade-skips healthy + * crypto bases (BTC/ETH/SUI/SOL/WAL). + * - Pre-warms Hermes so on-chain Pyth reads inside the oracle probe see fresh `publish_time` + * (avoids `err_total_weight_not_enough (204)`); shared `PythCache` dedupes RPCs. */ export async function lifecycleOracleUsdOrSkip( client: WaterXClient, ctx: { skip: (reason?: string) => void }, -): Promise | null> { +): Promise { const bases = activeLifecycleTestBases(); - if (bases.length === 0) return {} as Record; + if (bases.length === 0) return {}; const cache = new PythCache(); - // Pre-warm: execute a Hermes-fed simulate TX so on-chain Pyth reads inside - // `fetchSimulatedUsdPricesForBases` see fresh prices. If Hermes is down the - // simulate will still attempt using stale on-chain data; if that also fails - // the outer catch skips the test. try { const pythCfg = client.config.pythConfig; const feedIdTable = @@ -50,25 +51,47 @@ export async function lifecycleOracleUsdOrSkip( warmTx.setSender("0x1111111111111111111111111111111111111111111111111111111111111111"); warmTx.setGasBudget(1_200_000_000); await updatePythPrices(warmTx, client.grpcClient, pythCfg, [...feedSet], cache); - - // Simulate to verify Hermes data is valid (parse/verify + update calls succeed). await client.grpcClient.simulateTransaction({ transaction: warmTx, include: { effects: true }, }); } } catch (e) { - // Hermes flaky — fall through and let the oracle probe try with stale data. - // If that also fails the outer catch will skip the test. + // Hermes flaky — fall through; per-base probe may still succeed with stale on-chain data + // for feeds whose publish_time is still within tolerance. void e; } - try { - return await fetchSimulatedUsdPricesForBases(client, bases, { pythCache: cache }); - } catch (e) { + const prices = await fetchSimulatedUsdPricesForBases(client, bases, { pythCache: cache }); + if (Object.keys(prices).length === 0) { + ctx.skip( + "Oracle probe yielded zero prices (Hermes/Pyth + on-chain aggregator all unavailable for every lifecycle base).", + ); + return null; + } + return prices; +} + +/** + * Returns the simulated USD price for `base`, or calls `ctx.skip(...)` and returns `null` when + * that specific feed is missing from the partial probe result. Use after + * {@link lifecycleOracleUsdOrSkip} when the subtest actually needs a concrete `approxPrice`, so + * one dead feed only skips the subtests that depend on it (not the whole `describe` block). + * + * Named without a `require` prefix so Vitest/esbuild does not treat the binding as CommonJS + * `require` during bundling (runtime `… is not a function` on the import). + */ +export function oracleUsdForBaseOrSkip( + prices: LifecycleOraclePrices, + base: BaseAsset, + ctx: { skip: (reason?: string) => void }, +): number | null { + const usd = prices[base]; + if (usd === undefined) { ctx.skip( - `Oracle bundle simulate failed (Hermes/Pyth): ${e instanceof Error ? e.message : String(e)}`, + `Oracle USD for ${base} unavailable (feed stale / off-hours); other bases are unaffected.`, ); return null; } + return usd; } diff --git a/test/helpers/oracle-simulate-multi-asset.ts b/test/helpers/oracle-simulate-multi-asset.ts index 697c933..7b9de86 100644 --- a/test/helpers/oracle-simulate-multi-asset.ts +++ b/test/helpers/oracle-simulate-multi-asset.ts @@ -98,28 +98,24 @@ function pythFeedIdTable(client: WaterXClient): Record { return client.config.network === "TESTNET" ? PYTH_TESTNET_FEED_IDS : PYTH_PRICE_FEED_IDS; } +const DEFAULT_SIMULATE_SENDER = + "0x1111111111111111111111111111111111111111111111111111111111111111"; +const DEFAULT_GAS_BUDGET = 1_200_000_000; + /** - * USD (not Float scaled) per **1.0** base token, consistent with `buildOpenPositionTx` `approxPrice` - * when `collateralAmount` is raw 6dp USDC (see `computeLeverageDerivedSize`). + * Build a fresh simulate TX for a subset of bases: Hermes Pyth update + one + * `buildOracleFeed` per base. Shared across bundle + per-base fallback paths. */ -export async function fetchSimulatedUsdPricesForBases( +async function buildOracleBundleTx( client: WaterXClient, bases: readonly BaseAsset[], - opts?: { - sender?: string; - gasBudget?: number; - pythCache?: PythCache; - }, -): Promise> { - if (bases.length === 0) return {} as Record; - + cache: PythCache, + opts: { sender: string; gasBudget: number }, +): Promise { const tx = new Transaction(); - tx.setSender( - opts?.sender ?? "0x1111111111111111111111111111111111111111111111111111111111111111", - ); - tx.setGasBudget(opts?.gasBudget ?? 1_200_000_000); + tx.setSender(opts.sender); + tx.setGasBudget(opts.gasBudget); - const cache = opts?.pythCache ?? new PythCache(); const pythCfg = client.config.pythConfig; const ids = pythFeedIdTable(client); const feedSet = new Set(); @@ -140,17 +136,11 @@ export async function fetchSimulatedUsdPricesForBases( const m = client.getMarketEntry(base); buildOracleFeed(client, tx, m.baseType, m.aggregatorId, m.priceInfoId); } + return tx; +} - const res = await client.grpcClient.simulateTransaction({ - transaction: tx, - include: { commandResults: true, effects: true, events: true }, - }); - if (res && typeof res === "object" && (res as { $kind?: string }).$kind === "FailedTransaction") { - throw new Error( - extractSimulateFailureMessage(res) || "simulateTransaction failed (oracle bundle)", - ); - } - +/** Parse `PriceAggregated::result` events into a typeTag→USD map. */ +function collectAggregatedUsdByType(res: unknown): Map { const byType = new Map(); for (const ev of eventsFromSimulateResult(res)) { const t = eventRecordType(ev); @@ -170,23 +160,90 @@ export async function fetchSimulatedUsdPricesForBases( if (!Number.isFinite(usd) || usd <= 0) continue; byType.set(normTypeTag(typeArg), usd); } + return byType; +} - const out = {} as Record; - const missing: BaseAsset[] = []; - for (const base of bases) { - const m = client.getMarketEntry(base); - const usd = byType.get(normTypeTag(m.baseType)); - if (usd === undefined) { - missing.push(base); - continue; +/** + * USD (not Float scaled) per **1.0** base token, consistent with `buildOpenPositionTx` `approxPrice` + * when `collateralAmount` is raw 6dp USDC (see `computeLeverageDerivedSize`). + * + * Tries a single bundled simulate first (1 RPC). On bundle failure or any base missing from the + * bundle event set, falls back to per-base simulates sharing the same `PythCache` — so a single + * stale feed (e.g. transient Hermes lag on one xStock) no longer wipes out every other base's + * price and cascade-skips all dependent tests. + * + * Returned map is **partial**: callers must check `result[base] !== undefined` before using. + * Only throws when the PTB itself cannot be built (fatal SDK / config error) — a dead feed simply + * omits that base from the result. Use {@link lifecycleOracleUsdOrSkip} for the "skip only when + * every probed base is dead" semantic. + */ +export async function fetchSimulatedUsdPricesForBases( + client: WaterXClient, + bases: readonly BaseAsset[], + opts?: { + sender?: string; + gasBudget?: number; + pythCache?: PythCache; + }, +): Promise>> { + if (bases.length === 0) return {}; + + const sender = opts?.sender ?? DEFAULT_SIMULATE_SENDER; + const gasBudget = opts?.gasBudget ?? DEFAULT_GAS_BUDGET; + const cache = opts?.pythCache ?? new PythCache(); + + const out: Partial> = {}; + const pending: BaseAsset[] = [...bases]; + + try { + const tx = await buildOracleBundleTx(client, bases, cache, { sender, gasBudget }); + const res = await client.grpcClient.simulateTransaction({ + transaction: tx, + include: { commandResults: true, effects: true, events: true }, + }); + if ( + !res || + typeof res !== "object" || + (res as { $kind?: string }).$kind !== "FailedTransaction" + ) { + const byType = collectAggregatedUsdByType(res); + for (let i = pending.length - 1; i >= 0; i--) { + const base = pending[i]!; + const m = client.getMarketEntry(base); + const usd = byType.get(normTypeTag(m.baseType)); + if (usd !== undefined) { + out[base] = usd; + pending.splice(i, 1); + } + } } - out[base] = usd; + } catch { + /* Fall through to per-base retry — shared PythCache still warms RPC reads. */ } - if (missing.length) { - throw new Error( - `Missing PriceAggregated result for: ${missing.join(", ")} (got ${byType.size} type key(s))`, - ); + + for (const base of pending) { + try { + const tx = await buildOracleBundleTx(client, [base], cache, { sender, gasBudget }); + const res = await client.grpcClient.simulateTransaction({ + transaction: tx, + include: { commandResults: true, effects: true, events: true }, + }); + if ( + res && + typeof res === "object" && + (res as { $kind?: string }).$kind === "FailedTransaction" + ) { + continue; + } + const byType = collectAggregatedUsdByType(res); + const m = client.getMarketEntry(base); + const usd = byType.get(normTypeTag(m.baseType)); + if (usd !== undefined) out[base] = usd; + } catch { + /* individual base failed — leave absent in `out`; caller decides how to skip. */ + } } + return out; } diff --git a/test/helpers/run-scratch-trading-scenario-simulate.ts b/test/helpers/run-scratch-trading-scenario-simulate.ts index 09a3f53..437bb95 100644 --- a/test/helpers/run-scratch-trading-scenario-simulate.ts +++ b/test/helpers/run-scratch-trading-scenario-simulate.ts @@ -15,7 +15,7 @@ import { import { assertSimulateOpenFeeMatchesFormula } from "./assert-simulate-open-fee.ts"; import { expectLeverageOpenSizingVsMarket } from "./e2e-open-sizing-expect.ts"; -import { lifecycleOracleUsdOrSkip } from "./e2e-oracle-context.ts"; +import { lifecycleOracleUsdOrSkip, oracleUsdForBaseOrSkip } from "./e2e-oracle-context.ts"; import { fetchSimulatedCollateralUsdPrice } from "./oracle-simulate-multi-asset.ts"; import { SCRATCH_EXPECT } from "./scratch-scenario-steps.ts"; import type { ScratchTradingScenario } from "./scratch-trading-scenarios.ts"; @@ -48,13 +48,15 @@ export async function scratchSimulateOpenApproxOracle( ): Promise { const prices = await lifecycleOracleUsdOrSkip(client, ctx); if (!prices) return; + const approxPrice = oracleUsdForBaseOrSkip(prices, scenario.base, ctx); + if (approxPrice === null) return; await expectLeverageOpenSizingVsMarket( client, scenario.base, scenario.simulateOpen.collateral, scenario.simulateOpen.leverage, - prices[scenario.base], + approxPrice, ); const tx = await buildOpenPositionTx(client, { @@ -64,7 +66,7 @@ export async function scratchSimulateOpenApproxOracle( leverage: scenario.simulateOpen.leverage, collateralAmount: scenario.simulateOpen.collateral, collateral: scenario.collateralAsset, - approxPrice: prices[scenario.base], + approxPrice, updatePythPrice: true, }); setSender(tx); diff --git a/test/integration/helpers/scratch-lifecycle.ts b/test/integration/helpers/scratch-lifecycle.ts index f77f3ab..c860376 100644 --- a/test/integration/helpers/scratch-lifecycle.ts +++ b/test/integration/helpers/scratch-lifecycle.ts @@ -141,7 +141,12 @@ function integrationOracleSimMaxAttempts(): number { const raw = process.env.WATERX_INTEGRATION_ORACLE_SIM_ATTEMPTS?.trim(); if (!raw) return 3; const n = Number(raw); - if (!Number.isFinite(n)) return 3; + if (!Number.isFinite(n)) { + console.warn( + `[scratch-lifecycle] WATERX_INTEGRATION_ORACLE_SIM_ATTEMPTS="${raw}" is not a finite number; falling back to default 3.`, + ); + return 3; + } return Math.min(10, Math.max(1, Math.trunc(n))); } @@ -149,7 +154,12 @@ function integrationOracleSimRetryDelayMs(): number { const raw = process.env.WATERX_INTEGRATION_ORACLE_SIM_RETRY_MS?.trim(); if (!raw) return 800; const n = Number(raw); - if (!Number.isFinite(n) || n < 0) return 800; + if (!Number.isFinite(n) || n < 0) { + console.warn( + `[scratch-lifecycle] WATERX_INTEGRATION_ORACLE_SIM_RETRY_MS="${raw}" is not a non-negative number; falling back to default 800ms.`, + ); + return 800; + } return Math.trunc(n); } diff --git a/test/simulate/prd-product-coverage.test.ts b/test/simulate/prd-product-coverage.test.ts index 64a36d9..d33fdbb 100644 --- a/test/simulate/prd-product-coverage.test.ts +++ b/test/simulate/prd-product-coverage.test.ts @@ -27,7 +27,7 @@ import { describe, expect, it } from "vitest"; import { MARKET_DEFINITIONS } from "../../scripts/market-params.ts"; import type { BaseAsset } from "../../src/constants.ts"; import { expectLeverageOpenSizingVsMarket } from "../helpers/e2e-open-sizing-expect.ts"; -import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; +import { lifecycleOracleUsdOrSkip, oracleUsdForBaseOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../helpers/lifecycle-test-markets.ts"; import { fetchSimulatedUsdPricesForBases } from "../helpers/oracle-simulate-multi-asset.ts"; @@ -174,15 +174,11 @@ describe("PRD §2.3 — TC-TRADE-001: BTC market long ~10x (simulate)", () => { const prices = await lifecycleOracleUsdOrSkip(client, ctx); if (!prices) return; + const btcUsd = oracleUsdForBaseOrSkip(prices, "BTC", ctx); + if (btcUsd === null) return; const row = lifecycleRow("BTC"); - await expectLeverageOpenSizingVsMarket( - client, - "BTC", - row.simulateOpenCollateral, - 10, - prices.BTC, - ); + await expectLeverageOpenSizingVsMarket(client, "BTC", row.simulateOpenCollateral, 10, btcUsd); const tx = await buildOpenPositionTx(client, { accountId, base: "BTC", @@ -190,7 +186,7 @@ describe("PRD §2.3 — TC-TRADE-001: BTC market long ~10x (simulate)", () => { leverage: 10, collateralAmount: row.simulateOpenCollateral, collateral: row.collateralAsset, - approxPrice: prices.BTC, + approxPrice: btcUsd, updatePythPrice: true, }); await trySimulate(ctx, tx, 9); @@ -204,15 +200,11 @@ describe("PRD §2.3 — TC-TRADE-002: ETH market short (simulate)", () => { const prices = await lifecycleOracleUsdOrSkip(client, ctx); if (!prices) return; + const ethUsd = oracleUsdForBaseOrSkip(prices, "ETH", ctx); + if (ethUsd === null) return; const row = lifecycleRow("ETH"); - await expectLeverageOpenSizingVsMarket( - client, - "ETH", - row.simulateOpenCollateral, - 10, - prices.ETH, - ); + await expectLeverageOpenSizingVsMarket(client, "ETH", row.simulateOpenCollateral, 10, ethUsd); const tx = await buildOpenPositionTx(client, { accountId, base: "ETH", @@ -220,7 +212,7 @@ describe("PRD §2.3 — TC-TRADE-002: ETH market short (simulate)", () => { leverage: 10, collateralAmount: row.simulateOpenCollateral, collateral: row.collateralAsset, - approxPrice: prices.ETH, + approxPrice: ethUsd, updatePythPrice: true, }); await trySimulate(ctx, tx, 9); @@ -244,6 +236,7 @@ describe("PRD §2.3 — TC-TRADE-003: max leverage vs above-max (per MARKET_DEFI const prices = await lifecycleOracleUsdOrSkip(client, ctx); if (!prices) return; + if (oracleUsdForBaseOrSkip(prices, base, ctx) === null) return; const row = lifecycleRow(base); const entry = client.getMarketEntry(base); @@ -254,13 +247,10 @@ describe("PRD §2.3 — TC-TRADE-003: max leverage vs above-max (per MARKET_DEFI ).toBe(BigInt(MARKET_DEFINITIONS[base].maxLeverageBps)); const maxLev = Number(summary.maxLeverageBps) / 10_000; - let freshUsd: number; - try { - freshUsd = (await fetchSimulatedUsdPricesForBases(client, [base]))[base]; - } catch (e) { - ctx.skip( - `Oracle re-fetch for ${base} failed: ${e instanceof Error ? e.message : String(e)}`, - ); + const reFetched = await fetchSimulatedUsdPricesForBases(client, [base]); + const freshUsd = reFetched[base]; + if (freshUsd === undefined) { + ctx.skip(`Oracle re-fetch for ${base} returned no price (feed stale).`); return; } const sizingUsd = freshUsd * MAX_LEV_SIZING_HEADROOM; diff --git a/test/simulate/trading-negative-simulate.test.ts b/test/simulate/trading-negative-simulate.test.ts index d4c156d..6b1da91 100644 --- a/test/simulate/trading-negative-simulate.test.ts +++ b/test/simulate/trading-negative-simulate.test.ts @@ -12,7 +12,7 @@ import { import { describe, it } from "vitest"; import type { CollateralAsset } from "../../src/constants.ts"; -import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; +import { lifecycleOracleUsdOrSkip, oracleUsdForBaseOrSkip } from "../helpers/e2e-oracle-context.ts"; import { INTEGRATION_REFERENCE_WALLET_ADDRESS } from "../helpers/integration-reference-wallet.ts"; import { activeLifecycleTestBases, lifecycleRow } from "../helpers/lifecycle-test-markets.ts"; import { openInvalidSizeAbortPossible } from "../helpers/market-summary-assertions.ts"; @@ -122,6 +122,8 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { const prices = await lifecycleOracleUsdOrSkip(client, ctx); if (!prices) return; + const approxPrice = oracleUsdForBaseOrSkip(prices, base, ctx); + if (approxPrice === null) return; const tx = await buildOpenPositionTx(client, { accountId, @@ -129,7 +131,7 @@ describe("Simulate: trading expected failures (MoveAbort)", () => { isLong: row.isLong, collateralAmount: TINY_COLLATERAL_RAW, collateral: row.collateralAsset, - approxPrice: prices[base], + approxPrice, leverage: 2, updatePythPrice: true, });