@waterx/sdk 4.0.1 → 4.1.0

package/dist/src/oracle/rules/waterx-rule.js

@@ -0,0 +1,266 @@
+/**
+ * `WaterxRule` — `PriceUpdateRule` for the first-party WaterX quote-center
+ * (Nautilus-TEE, ed25519), plus `feedWaterxRule`, the collector-feed leg
+ * `aggregateTicker` appends per waterx-routed ticker. Pulls one enclave-signed
+ * batch envelope covering every requested ticker from the quote-center
+ * (`GET /v1/quotes/update?symbols=…`, endpoint from `host.waterx` — the
+ * `waterxEndpoint`/`waterxFetch` create options — else `WATERX_DEFAULTS`), then —
+ * unlike Pyth Lazer, whose verify is a single shared PTB step — verifies AND
+ * feeds in ONE `waterx_rule::collect_batch_latest` call per collector (the Move
+ * API bundles the two). So `buildUpdateCalls` emits nothing and the signed
+ * envelope is handed straight to the per-ticker feed leg.
+ *
+ * `collect_batch_latest` is the dual-rule path: it feeds the item matching
+ * `collector.symbol()` WITHOUT aggregating, so a waterx-routed ticker composes
+ * onto the same collector as Pyth/Supra (compose-then-aggregate). On-chain a
+ * freshness miss / replayed timestamp ABSTAINS (the other weighted rules
+ * cover); a config/integrity mismatch or bad signature aborts.
+ */
+import { fromHex } from "@mysten/bcs";
+import { collectBatchLatest, newBatchItem, newBatchPayload, pushBatchItem, } from "../../generated/waterx_rule/waterx_rule.js";
+import { WATERX_DEFAULTS } from "../config.js";
+import { assertRuleUpdateData, } from "../price-update-rule.js";
+import { FetchPolicyError, fetchWithPolicy, joinEndpointPath, } from "../update-fetch.js";
+/** The single signing intent (`BATCH_PRICE_INTENT`) the quote-center emits. */
+const BATCH_PRICE_INTENT = 1;
+/**
+ * Shape check ONLY — the `kind` discriminant is checked separately by the
+ * caller before this runs (mirrors the other rules' guard split), so a
+ * same-shaped payload from a different rule can never silently pass.
+ */
+function isWaterxUpdatePayloadShape(payload) {
+    const env = payload?.envelope;
+    return (typeof env === "object" &&
+        env !== null &&
+        typeof env.signature === "string" &&
+        typeof env.timestamp_ms === "bigint" &&
+        Array.isArray(env.payload?.items));
+}
+/**
+ * Parse a quote-center `/v1/quotes/update` response body into a
+ * {@link WaterxSignedEnvelope} with the u64 fields decoded as `bigint`, exact.
+ *
+ * The signature is over `BCS(IntentMessage<BatchPricePayload>)`, so every u64
+ * the SDK rebuilds in-PTB must equal the enclave's byte-for-byte or
+ * `collect_batch_latest` aborts the whole trade PTB (bad signature — not an
+ * abstain). A plain `JSON.parse` yields IEEE-754 doubles that lose precision
+ * above 2^53, so instead we recover each integer's exact source literal via the
+ * ES2023 reviver `context.source` (Node 21+ / modern browsers) and `BigInt()`
+ * it. On an older runtime that passes no `context`, a value within 2^53 is
+ * still exact (`BigInt(number)`); a value ABOVE it throws loudly here rather
+ * than silently corrupting the payload into an on-chain abort. `num_sources`
+ * (u8) and `intent` are coerced back to `number` — both are tiny.
+ */
+export function parseSignedEnvelope(text) {
+    const raw = JSON.parse(text, (_key, value, context) => {
+        if (typeof value !== "number" || !Number.isInteger(value))
+            return value;
+        if (context?.source !== undefined)
+            return BigInt(context.source);
+        if (!Number.isSafeInteger(value)) {
+            throw new Error("waterx envelope carries an integer above 2^53 and this runtime lacks JSON " +
+                "source access — cannot preserve u64 precision for the signed payload");
+        }
+        return BigInt(value);
+    });
+    if (typeof raw.signature !== "string" || !Array.isArray(raw.payload?.items)) {
+        throw new Error("WaterX quote-center returned a malformed signed envelope");
+    }
+    return {
+        intent: Number(raw.intent),
+        timestamp_ms: (raw.timestamp_ms ?? 0n),
+        signature: raw.signature,
+        payload: {
+            items: raw.payload.items.map((i) => ({ ...i, num_sources: Number(i.num_sources) })),
+        },
+    };
+}
+/** The `waterx_rule` deployment entry; throws when the config carries none. */
+function requireWaterxPackage(host) {
+    const entry = host.config.packages.waterx_rule;
+    if (!entry) {
+        throw new Error("waterx_rule package is not deployed in this config");
+    }
+    return entry;
+}
+/**
+ * Resolve the quote-center infra for this host: the `waterxEndpoint` /
+ * `waterxFetch` create options when the client carries them, else the network
+ * default. The fetch policy falls back to the shared `pyth.fetch` policy so a
+ * consumer that already tuned timeouts/retries once keeps them here.
+ *
+ * This is the seam a browser consumer needs: the envelope is fetched FROM THE
+ * PAGE, so a front end whose origin the quote-center does not allow (CORS)
+ * points `endpoint` at a same-origin proxy, or supplies its own `fetchImpl`.
+ */
+function resolveWaterxInfra(host) {
+    const infra = host.waterx ?? WATERX_DEFAULTS[host.network];
+    return { endpoint: infra.endpoint, fetch: infra.fetch ?? host.pyth.fetch };
+}
+/**
+ * Pull one enclave-signed batch envelope covering `symbols` from the
+ * quote-center. Goes through the shared `fetchWithPolicy` (`../update-fetch.ts`)
+ * — same retry/timeout policy as the Pyth/Lazer fetches. No auth: the
+ * quote-center read surface is public.
+ *
+ * The URL is built with `joinEndpointPath`, not `new URL(path, endpoint)`: a
+ * leading-slash path is ABSOLUTE and silently drops the endpoint's own base
+ * path, which is exactly what a `waterxEndpoint` proxy route is (a
+ * `https://app.example/api/quote-center` override would have been rewritten to
+ * `https://app.example/v1/quotes/update`, bypassing the proxy). Same footgun
+ * that 404'd every Pyth Pro feed by dropping its `/hermes` prefix.
+ */
+async function fetchWaterxSignedUpdate(endpoint, symbols, fetchOpts) {
+    const url = joinEndpointPath(endpoint, "v1/quotes/update");
+    url.searchParams.set("symbols", symbols.join(","));
+    let res;
+    try {
+        res = await fetchWithPolicy(url.toString(), { method: "GET" }, { ...fetchOpts });
+    }
+    catch (err) {
+        if (err instanceof FetchPolicyError && err.status !== undefined) {
+            const body = err.bodySnippet ? ` ${err.bodySnippet}` : "";
+            throw new Error(`WaterX quote-center fetch failed: ${err.status}${body} (retries exhausted after ${err.attempts} attempts)`, { cause: err });
+        }
+        throw err;
+    }
+    if (!res.ok) {
+        throw new Error(`WaterX quote-center fetch failed: ${res.status} ${await res.text()}`);
+    }
+    // Parse from raw text (not res.json()) so the u64 fields are decoded exact as
+    // bigint — see parseSignedEnvelope. Malformed-shape check lives there.
+    const envelope = parseSignedEnvelope(await res.text());
+    if (envelope.intent !== BATCH_PRICE_INTENT) {
+        throw new Error(`WaterX quote-center returned intent ${envelope.intent}, expected BATCH_PRICE_INTENT ${BATCH_PRICE_INTENT}`);
+    }
+    return envelope;
+}
+/** Narrow a `RuleUpdateData` to its `WaterxSignedEnvelope`, or `null`. */
+export function waterxEnvelopeOf(data) {
+    const payload = assertRuleUpdateData(data, "waterx_rule", isWaterxUpdatePayloadShape, "{ envelope: { intent, timestamp_ms, payload: { items }, signature } }");
+    return payload?.envelope ?? null;
+}
+/** Strip an optional `0x` prefix, then decode hex → bytes. */
+function decodeSig(hex) {
+    return fromHex(hex.startsWith("0x") ? hex.slice(2) : hex);
+}
+/**
+ * `waterx_rule::collect_batch_latest(collector, config, clock, enclave_config,
+ * enclave, timestamp_ms, payload, sig)` — rebuild the enclave-signed batch
+ * payload in-PTB (`new_batch_payload` + one `new_batch_item`/`push_batch_item`
+ * per item, the exact shape the enclave signed) and contribute the price for
+ * `collector.symbol()` to the collector. One collect call re-verifies the batch
+ * signature and picks this collector's symbol out of the batch; on-chain it
+ * abstains (records `none`) instead of aborting when the symbol is stale,
+ * absent from the batch, or its timestamp was already accepted (replay).
+ */
+export function feedWaterxRule(tx, host, collector, envelope) {
+    const wr = requireWaterxPackage(host);
+    const pkg = wr.published_at;
+    const payload = newBatchPayload({ package: pkg })(tx);
+    for (const item of envelope.payload.items) {
+        // u64 fields are already exact bigints (see parseSignedEnvelope) — passed
+        // through verbatim so the rebuilt BCS matches the enclave's signed bytes.
+        const itemArg = newBatchItem({
+            package: pkg,
+            arguments: {
+                symbol: item.symbol,
+                ticker: item.ticker,
+                sources: item.sources,
+                method: item.method,
+                priceTimestampMs: item.price_timestamp_ms,
+                priceN: item.price_n,
+                priceScale: item.price_scale,
+                confidenceN: item.confidence_n,
+                confidenceScale: item.confidence_scale,
+                maxSourceDeviationBps: item.max_source_deviation_bps,
+                numSources: item.num_sources,
+            },
+        })(tx);
+        pushBatchItem({ package: pkg, arguments: { payload, item: itemArg } })(tx);
+    }
+    collectBatchLatest({
+        package: pkg,
+        arguments: {
+            collector,
+            config: tx.object(wr.config),
+            enclaveConfig: tx.object(wr.enclave_config),
+            enclave: tx.object(wr.enclave),
+            timestampMs: envelope.timestamp_ms,
+            payload,
+            sig: Array.from(decodeSig(envelope.signature)),
+        },
+    })(tx);
+}
+export const WaterxRule = {
+    kind: "waterx_rule",
+    // Verification is an in-Move ed25519 check with no Coin argument — no
+    // update fee — see `PriceUpdateRule.requiresFeeSource`.
+    requiresFeeSource: false,
+    /** Tickers with a `waterx_rule.feeds` entry (keyed by oracle ticker). */
+    supportedTickers(host) {
+        return Object.keys(host.config.packages.waterx_rule?.feeds ?? {});
+    },
+    /**
+     * Pulls one enclave-signed batch envelope covering `tickers` from the
+     * quote-center, and only returns it when it actually covers ALL of them.
+     *
+     * A 200 whose `items` omit a requested symbol is a valid, well-signed
+     * envelope — nothing downstream would reject it, and the build would emit a
+     * `collect_batch_latest` that abstains for the missing symbol, surfacing as
+     * an on-chain `EMissingPriceSource` (or a silently thinner weighted set) much
+     * later. Same coverage rule the cached path enforces in
+     * {@link WaterxRule.narrowUpdateData}; the difference is disposition — a
+     * cache miss falls back to this live fetch, whereas the live source itself
+     * coming up short has no fallback left, so it throws deterministically here.
+     */
+    async fetchUpdateData(host, tickers) {
+        if (tickers.length === 0)
+            return null;
+        // Package-level check first: a config without the deployment must say so,
+        // not fail per ticker as if only that feed were missing.
+        const { feeds } = requireWaterxPackage(host);
+        for (const ticker of tickers) {
+            if (feeds[ticker] === undefined) {
+                throw new Error(`No waterx_rule feed listed for ticker: ${ticker}`);
+            }
+        }
+        const { endpoint, fetch: fetchOpts } = resolveWaterxInfra(host);
+        const envelope = await fetchWaterxSignedUpdate(endpoint, tickers, fetchOpts);
+        const covered = new Set(envelope.payload.items.map((i) => i.symbol));
+        const missing = tickers.filter((t) => !covered.has(t));
+        if (missing.length > 0) {
+            throw new Error(`WaterX quote-center envelope does not cover ticker(s): ${missing.join(", ")} ` +
+                `(requested ${tickers.join(", ")}; served ${[...covered].join(", ") || "none"})`);
+        }
+        return { kind: "waterx_rule", payload: { envelope } };
+    },
+    /**
+     * One signed batch envelope carries a single ed25519 signature over its whole
+     * `payload` — it is indivisible: it can only be served whole (re-verified from
+     * the full item set). Returns the whole payload iff every requested ticker's
+     * item is present in THIS envelope; any coverage gap → `null` (miss), never a
+     * silent partial.
+     */
+    narrowUpdateData(_host, data, tickers) {
+        const envelope = waterxEnvelopeOf(data);
+        if (!envelope || tickers.length === 0)
+            return null;
+        const covered = new Set(envelope.payload.items.map((i) => i.symbol));
+        for (const ticker of tickers) {
+            if (!covered.has(ticker))
+                return null;
+        }
+        return { kind: "waterx_rule", payload: { envelope } };
+    },
+    /**
+     * No shared verify step: `waterx_rule::collect_batch_latest` bundles verify
+     * AND feed into one per-collector call, appended by {@link feedWaterxRule} in
+     * the per-ticker aggregate leg. So this emits nothing and returns `void` — the
+     * signed envelope reaches the feed leg via `aggregate.ts`'s per-ticker map
+     * (built from the group's fetched data), not a `RuleUpdateHandle`.
+     */
+    buildUpdateCalls(_tx, _host, _data, _opts) {
+        return;
+    },
+};

package/dist/src/perp/client.d.ts

@@ -12,7 +12,8 @@
  */
 import { BaseLineClient } from "../base-client.ts";
 import type { OracleSource } from "../oracle/price-update-rule.ts";
-import { type LoadConfigOptions, type PythFetchPolicy, type PythInfraConfig, type WaterXConfig, type WormholeInfraConfig } from "./config.ts";
+import type { FetchPolicy } from "../oracle/update-fetch.ts";
+import { type LoadConfigOptions, type PythFetchPolicy, type PythInfraConfig, type WaterXConfig, type WaterxInfraConfig, type WormholeInfraConfig } from "./config.ts";
 import type { Network } from "./constants.ts";
 export interface CreateClientOptions extends LoadConfigOptions {
     grpcUrl?: string;
@@ -25,12 +26,20 @@ export interface CreateClientOptions extends LoadConfigOptions {
      * - `'pyth_lazer_rule'` — Pyth Lazer signed updates (ONE `leEcdsa` verify
      *   per PTB, no per-feed fees); needs `packages.pyth_lazer_rule` with feeds
      *   and a `pythApiKey` (Lazer is auth-first).
+     * - `'waterx_rule'` — the first-party WaterX quote-center (Nautilus-TEE,
+     *   ed25519-signed batches): ONE envelope covering the build's tickers,
+     *   verified AND fed by a single `collect_batch_latest` per collector. No
+     *   credential and no per-update fee; needs `packages.waterx_rule` with
+     *   feeds. Endpoint/transport via {@link CreateClientOptions.waterxEndpoint}
+     *   / {@link CreateClientOptions.waterxFetch} — the browser-CORS proxy hook,
+     *   since this is the one source fetched from the page.
      *
-     * A source-neutral name on purpose — a future source need not be Pyth.
-     * Selecting a source whose feed for a requested ticker is absent is NOT an
-     * error at client creation: it fails at tx-build time for exactly those
-     * tickers (see `refreshOraclePrices`). The Pyth Core infra is fixed per
-     * network by `PYTH_DEFAULTS` and is not deployment-overridable.
+     * The name is source-neutral on purpose — a source need not be Pyth (as
+     * `'waterx_rule'` shows). Selecting a source whose feed for a requested
+     * ticker is absent is NOT an error at client creation: it fails at tx-build
+     * time for exactly those tickers (see `refreshOraclePrices`). The Pyth Core
+     * infra is fixed per network by `PYTH_DEFAULTS` and is not
+     * deployment-overridable.
      */
     oracleSource?: OracleSource;
     /**
@@ -46,10 +55,39 @@ export interface CreateClientOptions extends LoadConfigOptions {
      * `fetchWithPolicy`). Optional — defaults to 15s timeout, 2 retries.
      */
     pythFetch?: PythFetchPolicy;
+    /**
+     * Quote-center base URL for `oracleSource: 'waterx_rule'` — overrides the
+     * per-network {@link WATERX_DEFAULTS} host.
+     *
+     * This is the one source a BROWSER fetches itself (the signed envelope is
+     * pulled from the page), so it is bound by the quote-center deployment's CORS
+     * allowlist. A front end whose origin is not allowed — or one that must route
+     * egress through its own backend — points this at a same-origin proxy that
+     * forwards `GET /v1/quotes/update`. Unused by the Pyth sources.
+     *
+     * An absolute URL. Any base PATH is preserved (`joinEndpointPath`), so
+     * `https://app.example/api/quote-center` fetches
+     * `https://app.example/api/quote-center/v1/quotes/update` — a proxy route
+     * survives instead of being rewritten to the origin root.
+     */
+    waterxEndpoint?: string;
+    /**
+     * Retry/timeout policy — and `fetchImpl` — for the quote-center fetch (see
+     * `fetchWithPolicy`). Optional: falls back to `pythFetch`, then to the
+     * built-in defaults. Supply `fetchImpl` to route the request through your own
+     * transport (a proxying `fetch` wrapper, a non-global `fetch`, a test double).
+     */
+    waterxFetch?: FetchPolicy;
 }
 export declare class PerpClient extends BaseLineClient<WaterXConfig> {
     /** Pyth Core infra (fixed per network) plus the caller-supplied credential/policy. */
     pyth: PythInfraConfig;
+    /**
+     * WaterX quote-center infra for `oracleSource: 'waterx_rule'` — the network
+     * default, overridden by the `waterxEndpoint` / `waterxFetch` create options
+     * (a same-origin proxy or a custom `fetchImpl` for browser consumers).
+     */
+    waterx: WaterxInfraConfig;
     /** Wormhole infra for the credit bridge (network defaults unless overridden). */
     wormhole: WormholeInfraConfig;
     /** Selected oracle price-update source (`oracleSource` create option; default `'pyth_rule'`). */

package/dist/src/perp/client.js

@@ -12,10 +12,16 @@
  */
 import { BaseLineClient } from "../base-client.js";
 import { PerpConfigView } from "./config-view.js";
-import { loadConfig, PYTH_DEFAULTS, WORMHOLE_DEFAULTS, } from "./config.js";
+import { loadConfig, PYTH_DEFAULTS, WATERX_DEFAULTS, WORMHOLE_DEFAULTS, } from "./config.js";
 export class PerpClient extends BaseLineClient {
     /** Pyth Core infra (fixed per network) plus the caller-supplied credential/policy. */
     pyth;
+    /**
+     * WaterX quote-center infra for `oracleSource: 'waterx_rule'` — the network
+     * default, overridden by the `waterxEndpoint` / `waterxFetch` create options
+     * (a same-origin proxy or a custom `fetchImpl` for browser consumers).
+     */
+    waterx;
     /** Wormhole infra for the credit bridge (network defaults unless overridden). */
     wormhole;
     /** Selected oracle price-update source (`oracleSource` create option; default `'pyth_rule'`). */
@@ -34,6 +40,14 @@ export class PerpClient extends BaseLineClient {
             ...(opts.pythFetch !== undefined ? { fetch: opts.pythFetch } : {}),
         };
         this.wormhole = config.wormhole ?? WORMHOLE_DEFAULTS[network];
+        // Quote-center infra: network default, each field independently overridable
+        // — a browser blocked by the quote-center's CORS allowlist swaps `endpoint`
+        // for a same-origin proxy without touching anything else.
+        this.waterx = {
+            ...WATERX_DEFAULTS[network],
+            ...(opts.waterxEndpoint !== undefined ? { endpoint: opts.waterxEndpoint } : {}),
+            ...(opts.waterxFetch !== undefined ? { fetch: opts.waterxFetch } : {}),
+        };
         this.oracleSource = opts.oracleSource ?? "pyth_rule";
         this.view = new PerpConfigView(() => this.config, () => this.wormhole);
     }

package/dist/src/perp/config.d.ts

@@ -12,8 +12,8 @@ import type { AccountPackages, BasePackageEntry, WormholeInfraConfig } from "../
 import type { OraclePackages } from "../oracle/config.ts";
 import type { Network } from "./constants.ts";
 export type { AccountConfig, AccountPackages, BasePackageEntry, NativeCustodyAsset, NativeCustodyPackage, WaterxCreditPackage, WaterxReferralPackage, WithdrawalQueuePackage, WormholeBridgePackage, WormholeInfraConfig, WxaAccountPackage, } from "../account/config.ts";
-export type { ConstantFeedEntry, OracleConfig, OraclePackages, PythFetchPolicy, PythInfraConfig, PythLazerRulePackage, PythRulePackage, PythSponsorRulePackage, SupraFeedEntry, SupraRulePackage, WaterxConstantRulePackage, WaterxOraclePackage, } from "../oracle/config.ts";
-export { PYTH_DEFAULTS } from "../oracle/config.ts";
+export type { ConstantFeedEntry, OracleConfig, OraclePackages, PythFetchPolicy, PythInfraConfig, PythLazerRulePackage, PythRulePackage, PythSponsorRulePackage, SupraFeedEntry, SupraRulePackage, WaterxConstantRulePackage, WaterxInfraConfig, WaterxOraclePackage, WaterxRulePackage, } from "../oracle/config.ts";
+export { PYTH_DEFAULTS, WATERX_DEFAULTS } from "../oracle/config.ts";
 export interface WaterxPerpMarketEntry {
     market: string;
     config: string;
@@ -71,7 +71,6 @@ export interface WaterXPackages extends AccountPackages, OraclePackages {
     mock_usdc?: MockCoinPackage;
     mock_usdsui?: MockCoinPackage;
     mock_sui?: MockCoinPackage;
-    waterx_rule?: BasePackageEntry;
     waterx_rule_nautilus_enclave?: BasePackageEntry;
 }
 export declare const WORMHOLE_DEFAULTS: Record<Network, WormholeInfraConfig>;

package/dist/src/perp/config.js

@@ -9,7 +9,7 @@
  * below, keyed by network.
  */
 import { fetchWithPolicy, rethrowExhaustedFetch } from "../oracle/update-fetch.js";
-export { PYTH_DEFAULTS } from "../oracle/config.js";
+export { PYTH_DEFAULTS, WATERX_DEFAULTS } from "../oracle/config.js";
 // ============================================================================
 // Wormhole / Hermes — external chain infra, defaults by network
 // ============================================================================

package/dist/src/perp/constants.d.ts

@@ -1,10 +1,4 @@
 export * from "../constants.ts";
-/** Default crypto market trading fee rate (3 bps). Per-market value lives in MarketConfig. */
-export declare const CRYPTO_FEE_RATE = 0.0003;
-/** Default stock / commodity market trading fee rate (5 bps). Per-market value lives in MarketConfig. */
-export declare const STOCK_FEE_RATE = 0.0005;
-/** Default maintenance margin rate (150 bps = 1.5%). Per-market value lives in MarketConfig. */
-export declare const MAINTENANCE_MARGIN_RATE = 0.015;
 export declare const PERM_OPEN_POSITION = 1;
 export declare const PERM_CLOSE_POSITION = 2;
 export declare const PERM_INCREASE_POSITION = 4;

package/dist/src/perp/constants.js

@@ -1,15 +1,17 @@
 // Perp-line domain constants (trading permissions / order tags / action codes /
-// fee rates / well-known addresses). Re-exports the shared primitives from
+// well-known addresses). Re-exports the shared primitives from
 // `../constants.ts` so perp code and the `./perp` barrel get the full set from
 // a single import.
+//
+// NOTE: there are deliberately NO fee-rate / maintenance-margin constants here.
+// `CRYPTO_FEE_RATE` / `STOCK_FEE_RATE` / `MAINTENANCE_MARGIN_RATE` were removed
+// — they were defaults masquerading as truth; per-market `MarketConfig` on
+// chain is the only source for fee and margin parameters (real MMRs span
+// 0.5%–5%; the flat 1.5% understated AAPLX-class risk >3x — mainnet incident
+// 2026-07-28: shorts displayed liq ~$364 but were liquidated at ~$343). When
+// the market rate is unavailable, treat the value as NOT estimable and fail
+// safe — never substitute a flat default.
 export * from "../constants.js";
-// ======== Fee rates & risk parameters ========
-/** Default crypto market trading fee rate (3 bps). Per-market value lives in MarketConfig. */
-export const CRYPTO_FEE_RATE = 0.0003;
-/** Default stock / commodity market trading fee rate (5 bps). Per-market value lives in MarketConfig. */
-export const STOCK_FEE_RATE = 0.0005;
-/** Default maintenance margin rate (150 bps = 1.5%). Per-market value lives in MarketConfig. */
-export const MAINTENANCE_MARGIN_RATE = 0.015;
 // ======== Permission Bitmasks (matches account_data.move) ========
 export const PERM_OPEN_POSITION = 1;
 export const PERM_CLOSE_POSITION = 2;

package/dist/src/perp/fetch/account.js

@@ -51,6 +51,9 @@ export async function getSpendableCreditBalance(client, accountId) {
         probeParkedBackingAssets(client, accountId),
         probeAddressCreditBalance(client, accountId),
     ]);
+    // COLLATERAL_DECIMALS here is the CREDIT/wxUSD *target* scale (collateral-typed;
+    // 6 on all current deployments — config carries no credit decimal). The
+    // per-asset backing decimals come from config via each row's `decimals`.
     const pendingBackingRaw = sumParkedBackingAsCreditRaw(parkedBacking, COLLATERAL_DECIMALS);
     const pendingCreditAtAddressRaw = addressCredit.fundsRaw + addressCredit.coinsRaw;
     const totalRaw = internalRaw + pendingBackingRaw + pendingCreditAtAddressRaw;

package/dist/src/perp/fetch/bridge.js

@@ -6,6 +6,7 @@ import { bcs } from "@mysten/sui/bcs";
 import { Transaction } from "@mysten/sui/transactions";
 import { bridgeFeeAmount as bridgeFeeAmountCall, bridgeFeeRate as bridgeFeeRateCall, bridgeMinFee as bridgeMinFeeCall, wouldExecuteWormhole as wouldExecuteWormholeCall, } from "../../generated/withdrawal_queue/withdrawal_queue.js";
 import { dailyBurned as dailyBurnedCall, dailyBurnLimit as dailyBurnLimitCall, dailyMinted as dailyMintedCall, dailyMintLimit as dailyMintLimitCall, maxBurnPerTx as maxBurnPerTxCall, maxMintPerTx as maxMintPerTxCall, mintedFor as mintedForCall, paused as pausedCall, personalBurnCapAmount as personalBurnCapAmountCall, personalBurned as personalBurnedCall, } from "../../generated/wormhole_bridge/wormhole_bridge.js";
+import { toU64 } from "../../utils/validate.js";
 import { extractAt, simulateRaw } from "./simulate.js";
 /**
  * Batched read of the bridge's rate-limit / cap state in a single simulate.
@@ -96,7 +97,7 @@ function requireWithdrawalQueue(client) {
  */
 export async function getBridgeFee(client, args) {
     const { pkg, queue } = requireWithdrawalQueue(client);
-    const amount = BigInt(args.amount);
+    const amount = toU64(args.amount, "amount");
     const common = {
         package: pkg,
         typeArguments: [args.creditType ?? client.creditType()],

package/dist/src/perp/fetch/market.js

@@ -5,6 +5,7 @@
 import { bcs } from "@mysten/sui/bcs";
 import { Transaction } from "@mysten/sui/transactions";
 import { AccountData, accountData as accountDataCall, GlobalConfigData, globalConfigData as globalConfigDataCall, MarketData, marketData as marketDataCall, PoolData, poolData as poolDataCall, TokenPoolData, tokenPoolData as tokenPoolDataCall, } from "../../generated/waterx_perp_view/view.js";
+import { toU64 } from "../../utils/validate.js";
 import { simulateAndExtract, withLp } from "./simulate.js";
 /**
  * Look up the registered AccountData for a given wxa account ID.
@@ -52,7 +53,7 @@ export async function getTokenPoolData(client, args) {
         package: client.config.packages.waterx_perp_view.published_at,
         arguments: {
             pool: tx.object(client.config.packages.wlp.wlp_pool),
-            tokenIndex: args.tokenIndex,
+            tokenIndex: toU64(args.tokenIndex, "tokenIndex"),
         },
         typeArguments: [withLp(client, args.lpType)],
     })(tx);

package/dist/src/perp/fetch/positions.d.ts

@@ -3,7 +3,9 @@
  * list (`waterx_perp_view`).
  */
 import { OrderData, PositionData, RedeemRequestData } from "../../generated/waterx_perp_view/view.ts";
+import { parseWholeDollarU64, type WholeDollarUsdPrice } from "../../utils/validate.ts";
 import type { PerpClient } from "../client.ts";
+export { parseWholeDollarU64, type WholeDollarUsdPrice };
 export type PositionDataView = ReturnType<typeof PositionData.parse>;
 export declare function positionExists(client: PerpClient, args: {
     ticker: string;
@@ -13,9 +15,8 @@ export declare function positionExists(client: PerpClient, args: {
 export declare function getPosition(client: PerpClient, args: {
     ticker: string;
     positionId: bigint | number;
-    /** Human-readable USD prices for Pnl / liq price calc; pass 0n if unsure. */
-    basePriceUsd: bigint | number;
-    collateralPriceUsd: bigint | number;
+    basePriceUsd: WholeDollarUsdPrice;
+    collateralPriceUsd: WholeDollarUsdPrice;
     lpType?: string;
 }): Promise<PositionDataView>;
 export type OrderDataView = ReturnType<typeof OrderData.parse>;
@@ -23,8 +24,9 @@ export declare function getOrder(client: PerpClient, args: {
     ticker: string;
     orderId: bigint | number;
     orderTypeTag: number;
+    /** Raw 1e9-scaled u128 order-book key — same scale as tx-build `rawPrice()`. */
     triggerPrice: bigint | number;
-    basePriceUsd: bigint | number;
+    basePriceUsd: WholeDollarUsdPrice;
     lpType?: string;
 }): Promise<OrderDataView>;
 export interface PageOpts {
@@ -33,7 +35,8 @@ export interface PageOpts {
 }
 export declare function getMarketOrders(client: PerpClient, args: {
     ticker: string;
-    basePriceUsd?: bigint | number;
+    /** Defaults to `0n`. */
+    basePriceUsd?: WholeDollarUsdPrice;
     lpType?: string;
 } & PageOpts): Promise<{
     orders: OrderDataView[];
@@ -41,8 +44,9 @@ export declare function getMarketOrders(client: PerpClient, args: {
 }>;
 export declare function getMarketPositions(client: PerpClient, args: {
     ticker: string;
-    basePriceUsd: bigint | number;
-    collateralPriceUsd?: bigint | number;
+    basePriceUsd: WholeDollarUsdPrice;
+    /** Defaults to `0n`. */
+    collateralPriceUsd?: WholeDollarUsdPrice;
     lpType?: string;
 } & PageOpts): Promise<{
     positions: PositionDataView[];
@@ -51,14 +55,16 @@ export declare function getMarketPositions(client: PerpClient, args: {
 export declare function getAccountPositions(client: PerpClient, args: {
     ticker: string;
     accountObjectAddress: string;
-    basePriceUsd: bigint | number;
-    collateralPriceUsd?: bigint | number;
+    basePriceUsd: WholeDollarUsdPrice;
+    /** Defaults to `0n`. */
+    collateralPriceUsd?: WholeDollarUsdPrice;
     lpType?: string;
 }): Promise<PositionDataView[]>;
 export declare function getAccountOrders(client: PerpClient, args: {
     ticker: string;
     accountObjectAddress: string;
-    basePriceUsd?: bigint | number;
+    /** Defaults to `0n`. */
+    basePriceUsd?: WholeDollarUsdPrice;
     lpType?: string;
 }): Promise<OrderDataView[]>;
 export type RedeemRequestDataView = ReturnType<typeof RedeemRequestData.parse>;