diff --git a/.e2e-fixed-positions.local.json b/.e2e-fixed-positions.local.json index 6c35c94..8f7ae87 100644 --- a/.e2e-fixed-positions.local.json +++ b/.e2e-fixed-positions.local.json @@ -1,13 +1,19 @@ { "version": 1, - "accountId": "0x7d5f459101cc8076215707ef49c09789514f31a4407c4836b874c8700e6ecaf6", + "accountId": "0xab4795318525c9a6113fcba320a785345f3a8b66c523ec1a517ac040d2cd945b", "positions": { - "BTC": 33, - "DEEP": 8, - "ETH": 11, - "SOL": 12, - "SUI": 7, - "WAL": 5 + "AAPLX": 2, + "BTC": 6, + "ETH": 20, + "GOOGLX": 2, + "METAX": 2, + "NVDAX": 2, + "QQQX": 2, + "SOL": 2, + "SPYX": 2, + "SUI": 13, + "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/.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 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 1aa8763..b44b7ec 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) | -| Clear legacy Supra weights | — | `clear-supra-weights.sh` | +| 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 | — | (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` | -`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. --- @@ -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/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 74d8f4c..30a16b7 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -1,57 +1,82 @@ -# 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. ## 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` | +| `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` | +| `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 / **required on-chain position per lifecycle base** + cooldown + oracle simulate, before `test:e2e`. | +| `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. | -## 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`. | + +## 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/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/clear-supra-weights.sh b/scripts/clear-supra-weights.sh deleted file mode 100755 index 28ceeb2..0000000 --- a/scripts/clear-supra-weights.sh +++ /dev/null @@ -1,52 +0,0 @@ -#!/usr/bin/env bash -set -euo pipefail - -# 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/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..4f80319 100644 --- a/scripts/e2e-preflight.ts +++ b/scripts/e2e-preflight.ts @@ -6,18 +6,27 @@ * 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 * (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 * (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`. + * + * 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"; @@ -25,6 +34,7 @@ import { getAccountBalance, getAccountCoins, getMarketCooldownMs, + isXStockBase, WaterXClient, } from "../src/index.ts"; import { buildOpenPositionTx } from "../src/tx-builders.ts"; @@ -32,21 +42,31 @@ 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 { + 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"; +export type CheckStatus = "OK" | "FAIL" | "SKIP"; export type CheckKind = | "user_account_missing" | "tto_coin_split" + | "tto_usdsui_coin_split" | "recent_position_missing" | "cooldown_not_elapsed" | "oracle_transient" | "oracle_other" | "wlp_readiness" + | "e2e_delegate_missing" | "info"; export type CheckRow = { @@ -65,6 +85,7 @@ export type PreflightResult = { rows: CheckRow[]; okCount: number; failCount: number; + skipCount: number; blockingFailCount: number; nonBlockingFailCount: number; }; @@ -97,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}`); } @@ -127,6 +148,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)", ); @@ -148,14 +172,20 @@ function isNonBlockingFail( allowMissingWlp: boolean; allowMissingTtoSplit: boolean; allowCooldownNotElapsed: boolean; + allowMissingE2eDelegate: boolean; }, ): boolean { if (r.status !== "FAIL") return false; 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; } @@ -167,6 +197,7 @@ export async function runPreflight( allowMissingWlp?: boolean; allowMissingTtoSplit?: boolean; allowCooldownNotElapsed?: boolean; + allowMissingE2eDelegate?: boolean; }, ): Promise { const allowOracleTransient = options?.allowOracleTransient ?? false; @@ -174,6 +205,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[] = []; @@ -199,6 +231,7 @@ export async function runPreflight( rows, okCount: 0, failCount: 1, + skipCount: 0, blockingFailCount: 1, nonBlockingFailCount: 0, }; @@ -214,10 +247,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({ @@ -236,6 +266,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) { @@ -263,16 +319,43 @@ 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) { 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; } @@ -303,14 +386,22 @@ export async function runPreflight( } for (const base of activeLifecycleTestBases()) { + const xStock = isXStockBase(base); 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, isLong: row.isLong, collateralAmount: row.e2ePtb.openCollateral, + collateral: row.collateralAsset, size: row.e2ePtb.openSize, + updatePythPrice: true, }); tx.setSender(owner); const result: any = await client.simulate(tx); @@ -323,14 +414,28 @@ 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", 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({ @@ -356,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, @@ -363,6 +469,7 @@ export async function runPreflight( allowMissingWlp, allowMissingTtoSplit, allowCooldownNotElapsed, + allowMissingE2eDelegate, }), ).length; const blockingFailCount = failRows.length - nonBlockingFailCount; @@ -370,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, }; @@ -385,6 +493,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}`); @@ -394,16 +503,19 @@ async function main() { allowMissingWlp, allowMissingTtoSplit, allowCooldownNotElapsed, + 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 || 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)"), ); @@ -435,7 +547,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 1b0cbf3..c9278dc 100644 --- a/scripts/e2e-prepare.ts +++ b/scripts/e2e-prepare.ts @@ -1,8 +1,9 @@ /** * 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 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`). @@ -12,9 +13,11 @@ * 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"; +import type { CollateralAsset } from "../src/constants.ts"; import { getAccountBalance, getAccountCoins, @@ -27,16 +30,20 @@ import { 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 { E2E_WALLET_WLP_MIN_RAW, e2eWalletCollateralMinForMintSimulate, 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 { - buildDepositUsdcFromWalletTx, + buildDepositCollateralFromWalletTx, ensureUserAccountForIntegration, } from "../test/integration/helpers/account-bootstrap.ts"; import { @@ -65,6 +72,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(); @@ -79,36 +87,59 @@ 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); - 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}`); + console.log( + `[prepare/${label}] deposited ${asset} split coin ${i + 1}/${need} digest=${r.digest}`, + ); } - } else { - console.log(`[prepare] funded TTO USDC coin readiness OK (${funded} >= 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`). @@ -121,6 +152,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( @@ -130,6 +174,33 @@ 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; @@ -241,7 +312,15 @@ async function main() { ); } - // 4) Wait for cooldown windows to elapse for existing lifecycle positions. + // 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()) { const openHit = await resolveE2eOpenPosition(client, accountId, base); @@ -269,7 +348,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/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/print-oracle-aggregates.ts b/scripts/print-oracle-aggregates.ts index 7841bbc..888ff3b 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, + PYTH_PRICE_FEED_IDS, + PYTH_TESTNET_FEED_IDS, + PythCache, + 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/scripts/setup-e2e-delegate.ts b/scripts/setup-e2e-delegate.ts new file mode 100644 index 0000000..094bcb3 --- /dev/null +++ b/scripts/setup-e2e-delegate.ts @@ -0,0 +1,80 @@ +/** + * 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/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 new file mode 100644 index 0000000..b054704 --- /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 價格， + // 並 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/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/README.md b/test/README.md index 6857059..ecad552 100644 --- a/test/README.md +++ b/test/README.md @@ -7,7 +7,7 @@ PRs to `main` run [`.github/workflows/ci.yml`](../.github/workflows/ci.yml): `Li | Project | Glob | Notes | | ---------------------- | -------------------------------------------- | -------------------------------------------------------- | | **unit** | `src/**/*.test.ts`, `test/unit/**/*.test.ts` | Fast, no chain | -| **e2e** | `test/simulate/**/*.test.ts` | Testnet `simulateTransaction`; single fork (rate limits). Scratch perp flows are **data-driven** from `test/helpers/scratch-trading-scenarios.ts` (`scratchTradingScenarios()` = every enabled `LIFECYCLE_TEST_MARKETS` base): oracle `approxPrice`, explicit size + fee check, on-chain resize, optional table `approxPrice` (BTC), and per-base stateful PTBs when a live position exists. | +| **e2e** | `test/simulate/**/*.test.ts` | Testnet `simulateTransaction`; single fork (rate limits). Scratch perp flows are **data-driven** from `test/helpers/scratch-trading-scenarios.ts` (`scratchTradingScenarios()` = every `activeLifecycleTestBases()` base from `test/fixtures/trading/trading-config.json`): oracle `approxPrice`, explicit size + fee check, on-chain resize, optional table `approxPrice` (BTC), and per-base stateful PTBs when a live position exists. | | **integration-trader** | `test/integration/user/**/*.test.ts` | Real `signAndExecute`; needs trader key (see below) | **E2e skipped vs PRD gaps:** Vitest **skipped** counts **runtime** `ctx.skip` (missing account, low balance, transient oracle, no WLP, etc.). PRD rows that are **out of scope** for this suite are **block comments** in `test/simulate/prd-product-coverage.test.ts`, not `it.skip`, so the skip total reflects environment/state rather than placeholder tests. @@ -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`) | -| `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). See "E2e delegate address" below. | | `pnpm e2e:bootstrap-positions` | Bootstrap lifecycle positions for e2e | ## Integration (trader) @@ -52,7 +53,7 @@ PRs to `main` run [`.github/workflows/ci.yml`](../.github/workflows/ci.yml): `Li - Config loads **`.env`** then **`.env.local`** (local only fills keys not already set in the shell). - **`execTx`** serializes `signAndExecute` for the shared trader wallet so parallel workers avoid nonce races. - Optional **`WATERX_INTEGRATION_APPROX_PRICE_CHAIN=1`**: enables an extra opt-in `it` in `trader-position-lifecycle.test.ts` that **signs** `buildOpenPositionTx` with **`approxPrice`** (small `simulateOpenCollateral` on the first `WATERX_INTEGRATION_BASES` base, then close). Default scratch lifecycle uses on-chain `resize` only. This does **not** run under **`pnpm test:e2e`** (no private key); e2e **simulates** table-`approxPrice` for **BTC** via the same scenario table. -- **Data-driven scratch trading**: `scratchTradingScenarios()` drives both **`trader-position-lifecycle.test.ts`** (full on-chain chain via `runScratchTradingScenarioIntegration`) and **`tx-builders-simulate.test.ts`** opens + stateful blocks (via `run-scratch-trading-scenario-simulate.ts`). Add/remove markets in `lifecycle-test-markets.ts`; expectations/constants live in `scratch-trading-scenarios.ts` (`SCRATCH_EXPECT`). +- **Data-driven scratch trading**: `scratchTradingScenarios()` drives both **`trader-position-lifecycle.test.ts`** (full on-chain chain via `runScratchTradingScenarioIntegration`) and **`tx-builders-simulate.test.ts`** opens + stateful blocks (via `run-scratch-trading-scenario-simulate.ts`). Add/remove markets and enable flags in **`test/fixtures/trading/trading-config.json`** (`lifecycleMarkets`, `enabledE2eBases`, `persistentPerp`); expectations live in `scratch-scenario-steps.ts` (`SCRATCH_EXPECT`); scenario rows in `scratch-trading-scenarios.ts`. ## E2e: pinned perp `position_id` (optional) @@ -60,9 +61,9 @@ 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. 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 @@ -72,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/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/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/fixtures/trading/trading-config.json b/test/fixtures/trading/trading-config.json new file mode 100644 index 0000000..0c68d47 --- /dev/null +++ b/test/fixtures/trading/trading-config.json @@ -0,0 +1,344 @@ +{ + "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. 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", + "SUI", + "SOL", + "WAL", + "DEEP", + "AAPLX", + "GOOGLX", + "METAX", + "NVDAX", + "QQQX", + "SPYX", + "TSLAX" + ], + "enabledE2eBases": [ + "BTC", + "ETH", + "SUI", + "SOL", + "WAL", + "AAPLX", + "GOOGLX", + "METAX", + "NVDAX", + "QQQX", + "SPYX", + "TSLAX" + ], + "scratchIntegration": { + "increaseCollateralUsdc": "12000000", + "depositCollateralUsdc": "2000000", + "withdrawCollateralUsdc": "1000000", + "minAccountUsdc": "130000000", + "approxPriceChainSmokeMinUsdc": "40000000" + }, + "persistentWlp": { + "minBalanceRaw": "1000000", + "mintPullUsdc": "25000000", + "accountBufferUsdc": "20000000" + }, + "e2eWallet": { + "wlpMinRaw": "1000", + "defaultCollateralMintSimulateMin": "1000000", + "collateralMintSimulateMinByAsset": { + "USDC": "1000000", + "USDSUI": "1000000" + } + }, + "lifecycleMarkets": { + "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, + "collateralAsset": "USDSUI", + "openCollateral": "42000000", + "isLong": false, + "sizeLot": "1000", + "simulateOpenCollateral": "10000000", + "e2ePtb": { + "openCollateral": "10000000", + "increaseCollateral": "5000000", + "openSize": "2000", + "increaseSize": "1000", + "decreaseSize": "1000" + } + }, + "SUI": { + "approxPrice": 1, + "leverage": 5, + "collateralAsset": "USDSUI", + "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" + } + } + }, + "persistentPerp": { + "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, + "leverage": 2, + "openCollateral": "10000000", + "openSize": "2000" + }, + "ETH": { + "isLong": false, + "leverage": 4, + "collateralAsset": "USDSUI", + "openCollateral": "10000000", + "openSize": "2000" + }, + "SUI": { + "isLong": true, + "leverage": 5, + "collateralAsset": "USDSUI", + "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": { + "_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", + "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" + } + } + }, + "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": "0xa221d213ba6c08fa885cab1103a89aab5cd1fba910d2ecf77ae99df62dfb9659", + "permissions": 12 + } +} diff --git a/test/helpers/compute-leverage-size.ts b/test/helpers/compute-leverage-size.ts index 488828a..36609bd 100644 --- a/test/helpers/compute-leverage-size.ts +++ b/test/helpers/compute-leverage-size.ts @@ -1,16 +1,12 @@ /** * Test-only mirror of `tx-builders` leverage sizing when `size` is omitted. - * Pair with `fetchSimulatedUsdPricesForBases` / `getLifecycleOracleUsdPrices` for `approxPrice` - * (see `oracle-simulate-multi-asset.ts`, `e2e-open-sizing-expect.ts`). + * Pair with `fetchSimulatedUsdPricesForBases` for `approxPrice` (see `oracle-simulate-multi-asset.ts`, + * `e2e-open-sizing-expect.ts`). */ export interface ComputeLeverageSizeOptions { collateralAmount: bigint | number; leverage: number; approxPrice: number; - /** Ignored — SDK rounds to 1000 internally. Kept for backward compat. */ - lotSize?: number; - /** Ignored — contract validates min_size on-chain. Kept for backward compat. */ - minSize?: number; } export function computeLeverageDerivedSize(opts: ComputeLeverageSizeOptions): bigint { @@ -18,3 +14,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..839cce8 --- /dev/null +++ b/test/helpers/e2e-active-bases.ts @@ -0,0 +1,20 @@ +/** + * Bases exercised by e2e / preflight / prepare / scratch iteration. + * + * 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: {@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"; + +/** Alias of {@link ENABLED_E2E_BASES} (same as `enabledE2eBases` in trading-config.json). */ +export const ACTIVE_E2E_BASES = ENABLED_E2E_BASES; + +export { ENABLED_E2E_BASES }; + +export function isActiveE2eBase(base: BaseAsset): boolean { + return (ENABLED_E2E_BASES as readonly string[]).includes(base); +} 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/e2e-persistent-perp-slots.ts b/test/helpers/e2e-persistent-perp-slots.ts index 1625369..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(); @@ -78,7 +92,9 @@ export async function ensureE2ePersistentPerpSlots(opts: { isLong: row.isLong, leverage: lev, collateralAmount: row.openCollateral, + collateral: row.collateralAsset, size: row.openSize, + updatePythPrice: true, }; if (dryRun) { @@ -92,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/e2e-persistent-state.ts b/test/helpers/e2e-persistent-state.ts index f41828d..3327c11 100644 --- a/test/helpers/e2e-persistent-state.ts +++ b/test/helpers/e2e-persistent-state.ts @@ -3,97 +3,71 @@ * `trader-e2e-persistent-state.test.ts` tops up when missing. Other integration tests should use * 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). + * 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. */ import type { BaseAsset } from "../../src/constants.ts"; +import { ENABLED_E2E_BASES, isActiveE2eBase } from "./e2e-active-bases.ts"; +import { + E2E_PERSISTENT_ACCOUNT_BUFFER_USDC, + E2E_PERSISTENT_PERP_MARKETS, + E2E_PERSISTENT_WLP, + type E2ePersistentPerpRow, +} from "./load-trading-fixtures.ts"; -export type E2ePersistentPerpRow = { - isLong: boolean; - /** `buildOpenPositionTx` leverage; `simulateLeverage` overrides for open if set. */ - leverage: number; - simulateLeverage?: number; - /** USDC, 6 decimals. */ - openCollateral: bigint; - /** Raw position size units. */ - 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", -]; +export type { E2ePersistentPerpRow }; -/** 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, - }, -}; +/** 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 ENABLED_E2E_BASES}. + */ export function activeE2ePersistentPerpBases(): BaseAsset[] { - return E2E_PERSISTENT_PERP_ORDER.filter((b) => E2E_PERSISTENT_PERP_MARKETS[b] != null); + return (ENABLED_E2E_BASES as BaseAsset[]).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 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; +/** 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/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/ensure-e2e-delegate.ts b/test/helpers/ensure-e2e-delegate.ts new file mode 100644 index 0000000..a566773 --- /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 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"; +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/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..135522c 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,44 @@ 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/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-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 9740235..58f0ef1 100644 --- a/test/helpers/lifecycle-test-markets.ts +++ b/test/helpers/lifecycle-test-markets.ts @@ -1,12 +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. * - * - 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}. + * 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 type { BaseAsset, CollateralAsset } from "../../src/constants.ts"; +import { + ENABLED_E2E_BASES, + LIFECYCLE_TEST_BASE_ORDER, + LIFECYCLE_TEST_MARKETS_FROM_FIXTURE, +} from "./load-trading-fixtures.ts"; export type LifecycleTestMarketRow = { /** @@ -15,12 +19,12 @@ 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; /** - * 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; /** @@ -33,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). */ @@ -45,145 +51,41 @@ export type LifecycleTestMarketRow = { }; }; -/** - * Preferred scan / test order. Only bases with a row in {@link LIFECYCLE_TEST_MARKETS} run. - */ -export const LIFECYCLE_TEST_BASE_ORDER: readonly BaseAsset[] = [ - "BTC", - "ETH", - "SUI", - "SOL", - "WAL", - "DEEP", -]; +/** Re-export fixture iteration order. */ +export { LIFECYCLE_TEST_BASE_ORDER }; -/** 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, - }, - }, -}; +/** 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 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 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 new file mode 100644 index 0000000..f3b409a --- /dev/null +++ b/test/helpers/load-trading-fixtures.ts @@ -0,0 +1,199 @@ +/** + * 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 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; + leverage: number; + openCollateral: bigint; + isLong: boolean; + sizeLot: bigint; + simulateOpenCollateral: bigint; + simulateLeverage?: number; + /** Perp margin asset for opens driven by this row (default USDC). */ + collateralAsset: CollateralAsset; + e2ePtb: { + openCollateral: bigint; + increaseCollateral: bigint; + openSize: bigint; + increaseSize: bigint; + decreaseSize: bigint; + }; +}; + +export type E2ePersistentPerpRow = { + isLong: boolean; + leverage: number; + simulateLeverage?: number; + openCollateral: bigint; + openSize: bigint; + collateralAsset: CollateralAsset; +}; + +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; + collateralAsset?: string; + } + >; + }; + e2eDelegate?: { + description?: string; + delegateAddress?: string; + permissions?: number; + }; +}; + +const cfg = raw as TradingConfigJson; + +function lifecycleRowFromJson(j: Record): FixtureLifecycleRow { + 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, + collateralAsset: parseCollateralAsset(j.collateralAsset, "lifecycleMarkets.collateralAsset"), + e2ePtb: { + openCollateral: BigInt(e2e.openCollateral), + increaseCollateral: BigInt(e2e.increaseCollateral), + openSize: BigInt(e2e.openSize), + increaseSize: BigInt(e2e.increaseSize), + decreaseSize: BigInt(e2e.decreaseSize), + }, + }; +} + +const parsedLifecycle: Partial> = {}; +for (const [k, v] of Object.entries(cfg.lifecycleMarkets)) { + parsedLifecycle[k as BaseAsset] = lifecycleRowFromJson(v); +} + +/** 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), + collateralAsset: parseCollateralAsset( + v.collateralAsset, + "persistentPerp.markets.collateralAsset", + ), + }; + 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); + +/** 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); +} + +/** 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 new file mode 100644 index 0000000..50f9908 --- /dev/null +++ b/test/helpers/move-event-payload.ts @@ -0,0 +1,172 @@ +/** + * 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/oracle-simulate-multi-asset.ts b/test/helpers/oracle-simulate-multi-asset.ts index 43239be..7b9de86 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). */ @@ -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/place-cancel-probe.ts b/test/helpers/place-cancel-probe.ts new file mode 100644 index 0000000..271d097 --- /dev/null +++ b/test/helpers/place-cancel-probe.ts @@ -0,0 +1,141 @@ +/** + * 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/run-scratch-trading-scenario-integration.ts b/test/helpers/run-scratch-trading-scenario-integration.ts index 7c90321..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"; @@ -23,7 +23,11 @@ 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"; + +/** Hermes `updatePythPrices` + oracle feed + trading ops need headroom on testnet. */ +const SCRATCH_INTEGRATION_GAS = 1_200_000_000; export type IntegrationScratchRunnerDeps = { client: WaterXClient; @@ -38,7 +42,7 @@ export type IntegrationScratchRunnerDeps = { maxAttempts?: number; }, ) => Promise; - execIntegrationOrSkipSupra: ( + execIntegrationOrSkipOracle: ( ctx: { skip: (reason?: string) => void }, fn: () => Promise, ) => Promise; @@ -60,7 +64,7 @@ export async function runScratchTradingScenarioIntegration( client, trader, execBuiltTxWithCooldownRetries, - execIntegrationOrSkipSupra, + execIntegrationOrSkipOracle, extractEvent, assertSuccess, marketAtStart, @@ -70,15 +74,33 @@ export async function runScratchTradingScenarioIntegration( const cooldownMarketIds = [entry.marketId]; 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, - }); + 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); - const openResult = await execIntegrationOrSkipSupra(ctx, () => + const openResult = await execIntegrationOrSkipOracle(ctx, () => execBuiltTxWithCooldownRetries( () => buildOpenPositionTx(client, { @@ -87,9 +109,11 @@ export async function runScratchTradingScenarioIntegration( isLong: scenario.integrationOpen.isLong, leverage: scenario.integrationOpen.leverage, collateralAmount: scenario.integrationOpen.collateral, + collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ), ); if (openResult === undefined) return; @@ -102,10 +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, - }); + 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); @@ -119,9 +150,11 @@ export async function runScratchTradingScenarioIntegration( base, positionId, collateralAmount: scenario.depositCollateral, + collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(depCollResult); const afterDeposit = await getPosition(client, entry.marketId, positionId, entry.baseType); @@ -137,9 +170,11 @@ export async function runScratchTradingScenarioIntegration( base, positionId, amount: scenario.withdrawCollateral, + collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(withCollResult); const afterWithdraw = await getPosition(client, entry.marketId, positionId, entry.baseType); @@ -153,9 +188,11 @@ export async function runScratchTradingScenarioIntegration( positionId, collateralAmount: scenario.increase.collateral, leverage: scenario.increase.leverage, + collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(incResult); expect(extractEvent(incResult, "PositionModified")).toBeDefined(); @@ -171,9 +208,11 @@ export async function runScratchTradingScenarioIntegration( base, positionId, size: decSize, + collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(decResult); expect(extractEvent(decResult, "PositionModified")).toBeDefined(); @@ -186,9 +225,11 @@ export async function runScratchTradingScenarioIntegration( base, positionId, acceptablePrice: 0, + collateral: col, + ...feedOpts, }), trader, - { cooldownMarketIds }, + execOracleOpts, ); assertSuccess(closeResult); expect(extractEvent(closeResult, "PositionClosed")).toBeDefined(); diff --git a/test/helpers/run-scratch-trading-scenario-simulate.ts b/test/helpers/run-scratch-trading-scenario-simulate.ts index 49c1658..437bb95 100644 --- a/test/helpers/run-scratch-trading-scenario-simulate.ts +++ b/test/helpers/run-scratch-trading-scenario-simulate.ts @@ -15,9 +15,10 @@ 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, 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 }; @@ -47,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, { @@ -62,7 +65,8 @@ export async function scratchSimulateOpenApproxOracle( isLong: scenario.simulateOpen.isLong, leverage: scenario.simulateOpen.leverage, collateralAmount: scenario.simulateOpen.collateral, - approxPrice: prices[scenario.base], + collateral: scenario.collateralAsset, + approxPrice, updatePythPrice: true, }); setSender(tx); @@ -85,7 +89,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)}`); @@ -97,6 +101,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, }); @@ -137,6 +142,7 @@ export async function scratchSimulateOpenResize( isLong: scenario.simulateOpen.isLong, leverage: scenario.simulateOpen.leverage, collateralAmount: scenario.simulateOpen.collateral, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(tx); @@ -162,6 +168,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, }); @@ -195,6 +202,7 @@ export async function scratchSimulateStatefulOps( positionId: pid, collateralAmount: st.increaseCollateral, size: st.increaseSize, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(incTx); @@ -205,6 +213,7 @@ export async function scratchSimulateStatefulOps( base, positionId: pid, size: st.decreaseSize, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(decTx); @@ -215,6 +224,7 @@ export async function scratchSimulateStatefulOps( base, positionId: pid, collateralAmount: st.depositCollateral, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(depTx); @@ -225,6 +235,7 @@ export async function scratchSimulateStatefulOps( base, positionId: pid, amount: st.withdrawAmount, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(withTx); @@ -234,6 +245,7 @@ export async function scratchSimulateStatefulOps( accountId, base, positionId: pid, + collateral: scenario.collateralAsset, updatePythPrice: true, }); setSender(closeTx); 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..14ab7dd 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 { BaseAsset, CollateralAsset } 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`. */ @@ -39,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; @@ -68,21 +53,18 @@ 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 { id: `scratch-${base}`, base, row, + collateralAsset: row.collateralAsset, integrationOpen: { collateral: row.openCollateral, leverage: row.leverage, diff --git a/test/helpers/simulate-assertions.ts b/test/helpers/simulate-assertions.ts index 4214385..f100e8a 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") ); @@ -284,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/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/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..c860376 100644 --- a/test/integration/helpers/scratch-lifecycle.ts +++ b/test/integration/helpers/scratch-lifecycle.ts @@ -5,14 +5,16 @@ */ 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 } 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 { assertSimulateSuccess, + extractSimulateError, + isOracleTransientFailureMessage, skipSimulateIfOracleTransient, } from "../../helpers/simulate-assertions.ts"; import { @@ -20,8 +22,8 @@ import { parseResizeSizingProbeResult, type ResizeSizingProbeParams, } from "../../helpers/simulate-resize-size.ts"; -import { assertSuccess } from "../setup.ts"; -import { buildDepositUsdcFromWalletTx } from "./account-bootstrap.ts"; +import { assertSuccess, sleep } from "../setup.ts"; +import { buildDepositCollateralFromWalletTx } from "./account-bootstrap.ts"; export type IntegrationExecTx = ( tx: Transaction, @@ -90,49 +92,122 @@ 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, + ); +} + +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)) { + 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))); +} + +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) { + 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); +} + /** * 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/integration/setup.ts b/test/integration/setup.ts index 38382d8..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,33 +196,38 @@ 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"); + 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 (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 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/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..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"; @@ -35,7 +36,7 @@ import { assertSuccess, client, execBuiltTxWithCooldownRetries, - execIntegrationOrSkipSupra, + execIntegrationOrSkipOracle, execTx, isIntegrationTraderConfigured, loadIntegrationTraderKeypair, @@ -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); @@ -82,7 +90,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, { @@ -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 3ef6bc2..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"; @@ -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, @@ -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, ); @@ -122,7 +124,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, { @@ -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/scripts/regen-trading-fixtures.ts b/test/scripts/regen-trading-fixtures.ts new file mode 100644 index 0000000..41d9294 --- /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 `trading-config.json` by hand when market params change; run `pnpm typecheck`. + */ +console.log( + "[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 cb895a9..3ab56a9 100644 --- a/test/simulate/collateral-order-simulate.test.ts +++ b/test/simulate/collateral-order-simulate.test.ts @@ -13,12 +13,14 @@ 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"; 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; @@ -96,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, }); @@ -223,9 +225,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 +235,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 +243,63 @@ 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..4690d2a --- /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 — set `e2eDelegate.delegateAddress` + run `pnpm e2e:setup-delegate` (owner signs), or add delegate on-chain.", + ); + 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..7961cdb --- /dev/null +++ b/test/simulate/delegate-permission-matrix-simulate.test.ts @@ -0,0 +1,86 @@ +/** + * 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/e2e-delegate-simulate.test.ts b/test/simulate/e2e-delegate-simulate.test.ts new file mode 100644 index 0000000..b7a9061 --- /dev/null +++ b/test/simulate/e2e-delegate-simulate.test.ts @@ -0,0 +1,49 @@ +/** + * 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/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/prd-product-coverage.test.ts b/test/simulate/prd-product-coverage.test.ts index 9b2a69a..d33fdbb 100644 --- a/test/simulate/prd-product-coverage.test.ts +++ b/test/simulate/prd-product-coverage.test.ts @@ -27,14 +27,16 @@ 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"; +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 { assertSimulateMoveAbort, + assertSimulateMoveAbortOneOf, assertSimulateSuccess, parseSimulateFailure, skipSimulateIfOracleTransient, @@ -172,22 +174,19 @@ 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", isLong: true, leverage: 10, collateralAmount: row.simulateOpenCollateral, - approxPrice: prices.BTC, + collateral: row.collateralAsset, + approxPrice: btcUsd, updatePythPrice: true, }); await trySimulate(ctx, tx, 9); @@ -201,22 +200,19 @@ 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", isLong: false, leverage: 10, collateralAmount: row.simulateOpenCollateral, - approxPrice: prices.ETH, + collateral: row.collateralAsset, + approxPrice: ethUsd, updatePythPrice: true, }); await trySimulate(ctx, tx, 9); @@ -240,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); @@ -250,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; @@ -273,36 +267,44 @@ 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, }); 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], + collateral: row.collateralAsset, 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); } }); @@ -448,43 +450,45 @@ 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); }); @@ -583,11 +587,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 b75c21a..6b1da91 100644 --- a/test/simulate/trading-negative-simulate.test.ts +++ b/test/simulate/trading-negative-simulate.test.ts @@ -1,17 +1,26 @@ /** * 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 { + buildOpenPositionTx, + buildPlaceOrderTx, + getAccountBalance, + getAccountsByOwner, + getMarketSummary, +} from "@waterx/perp-sdk"; import { describe, it } from "vitest"; -import { lifecycleOracleUsdOrSkip } from "../helpers/e2e-oracle-context.ts"; +import type { CollateralAsset } from "../../src/constants.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"; +import { resolveE2eOpenPosition } from "../helpers/resolve-e2e-open-position.ts"; 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"; @@ -42,33 +51,60 @@ 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); - 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], + collateral: row.collateralAsset, 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) => { @@ -86,13 +122,16 @@ 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, base, isLong: row.isLong, collateralAmount: TINY_COLLATERAL_RAW, - approxPrice: prices[base], + collateral: row.collateralAsset, + approxPrice, leverage: 2, updatePythPrice: true, }); @@ -105,4 +144,60 @@ 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); }); diff --git a/test/simulate/tx-builders-simulate.test.ts b/test/simulate/tx-builders-simulate.test.ts index 5eee1f4..4984c22 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,45 @@ 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, - base: "BTC", - isLong: true, - collateralAmount: ORDER_COLLATERAL, - size: ORDER_SIZE, - triggerPrice: ORDER_TRIGGER_PRICE_USD, - updatePythPrice: true, - tx, - }); - await buildCancelOrderTx(client, { - accountId, + const outcome = await simulatePlaceCancelSinglePtbWithRetries(client, { 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) => { @@ -251,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); @@ -268,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 }, @@ -288,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, diff --git a/test/simulate/wlp-simulate.test.ts b/test/simulate/wlp-simulate.test.ts index 3f2d0d0..ae07e42 100644 --- a/test/simulate/wlp-simulate.test.ts +++ b/test/simulate/wlp-simulate.test.ts @@ -10,11 +10,13 @@ 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 +101,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 +123,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/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..a0dbb4d --- /dev/null +++ b/test/unit/e2e-delegate-helpers.test.ts @@ -0,0 +1,20 @@ +import { describe, expect, it } from "vitest"; + +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", () => { + 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/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); + }); +}); 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, {