@waterx/sdk 4.1.0 → 4.3.0

package/dist/cjs/src/unified-client.js

@@ -4,7 +4,7 @@
  *
  * Exposes three namespaces over the two product-line sub-clients:
  *
- *   const client = await WaterXClient.create({ network: "TESTNET" });
+ *   const client = await WaterXClient.create({ network: "TESTNET", oracleSource: "pyth_rule" });
  *   client.account.createAccount(tx, { alias });   // -> shared waterx_account + funding
  *   client.perp.placeOrderRequest(tx, params);     // -> perp builder
  *   client.predict.placeOrder(tx, params);         // -> prediction builder
@@ -186,7 +186,7 @@ class WaterXClient {
      * `waterx-config` JSON) and returns a ready client. Each line can target a
      * different network via `opts.perp.network` / `opts.predict.network`.
      */
-    static async create(opts = {}) {
+    static async create(opts) {
         const baseNetwork = opts.network ?? "TESTNET";
         const { network: perpNetwork, ...perpRest } = opts.perp ?? {};
         const { network: predictNetwork, ...predictRest } = opts.predict ?? {};

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

@@ -73,8 +73,9 @@ export interface WithdrawalQueuePackage {
 /**
  * Wormhole infra for the cross-chain credit bridge. `state_id` is the same
  * shared Sui Wormhole `State` object Pyth uses (kept in sync with
- * `PYTH_DEFAULTS[*].wormhole_state_id`). Override per-deployment via
- * `WaterXConfig.wormhole` if a deployment ever points elsewhere.
+ * `PYTH_CORE_INFRA[*].wormhole_state_id` in `oracle/pyth.ts`). Override
+ * per-deployment via `WaterXConfig.wormhole` if a deployment ever points
+ * elsewhere.
  */
 export interface WormholeInfraConfig {
     /** Shared Sui Wormhole `State` object. */

package/dist/src/generated/waterx_rule/waterx_rule.d.ts

@@ -70,11 +70,6 @@ export declare const BatchPricePayload: MoveStruct<{
         length: number;
     }, string>;
 }, "@waterx/rule::waterx_rule::BatchPricePayload">;
-export declare const MerkleRoot: MoveStruct<{
-    root: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
-        length: number;
-    }, string>;
-}, "@waterx/rule::waterx_rule::MerkleRoot">;
 export declare const FeedConfig: MoveStruct<{
     ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
     sources: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
@@ -219,82 +214,17 @@ export interface CollectBatchLatestOptions {
  * and so aborts on any stale item, this path runs alongside Pyth/Supra. To let
  * those cover a lagging TEE — the blast-radius bound in the GCP ADR — a
  * _freshness_ miss ABSTAINS (records `none`, which `aggregator::remove_outliers`
- * drops before the `weight_threshold` fail-closed check), and so does a _replayed_
- * signed timestamp (the chain already accepted that snapshot — the on-chain price
- * is at least as fresh, and two concurrent keeper PTBs sharing one envelope must
- * not kill each other). A _config/integrity_ mismatch (source / ticker / method /
- * confidence / deviation) still ABORTS: an enclave whose signed payload disagrees
- * with the on-chain feed config is a red flag, not a liveness blip. Bad signature,
- * malformed batch, and a future timestamp always abort.
+ * drops before the `weight_threshold` fail-closed check). A _config/integrity_
+ * mismatch (source / ticker / method / confidence / deviation) still ABORTS: an
+ * enclave whose signed payload disagrees with the on-chain feed config is a red
+ * flag, not a liveness blip. Bad signature, malformed batch, a future timestamp,
+ * and replay always abort.
  *
  * Every gate is identical to `feed_batch_item_latest`; only the abort-vs-abstain
- * disposition of the freshness + replay gates differs, and the sink is the
- * caller's collector rather than a fresh single-rule one.
+ * disposition of the two freshness gates differs, and the sink is the caller's
+ * collector rather than a fresh single-rule one.
  */
 export declare function collectBatchLatest(options: CollectBatchLatestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface FeedSingleWithProofArguments {
-    oracleObj: RawTransactionArgument<string>;
-    config: RawTransactionArgument<string>;
-    enclaveConfig: RawTransactionArgument<string>;
-    enclave: RawTransactionArgument<string>;
-    timestampMs: RawTransactionArgument<number | bigint>;
-    item: TransactionArgument;
-    proof: RawTransactionArgument<Array<Array<number>>>;
-    sig: RawTransactionArgument<Array<number>>;
-}
-export interface FeedSingleWithProofOptions {
-    package?: string;
-    arguments: FeedSingleWithProofArguments | [
-        oracleObj: RawTransactionArgument<string>,
-        config: RawTransactionArgument<string>,
-        enclaveConfig: RawTransactionArgument<string>,
-        enclave: RawTransactionArgument<string>,
-        timestampMs: RawTransactionArgument<number | bigint>,
-        item: TransactionArgument,
-        proof: RawTransactionArgument<Array<Array<number>>>,
-        sig: RawTransactionArgument<Array<number>>
-    ];
-}
-/**
- * Streaming per-symbol sibling of `feed_batch_latest`. Verifies ONE enclave
- * signature over a Merkle `root`, checks `item` is a leaf of that root via
- * `proof`, then runs the identical per-item gates + `oracle::aggregate`. Use for a
- * WaterxRule-only aggregator; for a Pyth-coexisting aggregator use
- * `collect_single_with_proof`.
- */
-export declare function feedSingleWithProof(options: FeedSingleWithProofOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface CollectSingleWithProofArguments {
-    collector: TransactionArgument;
-    config: RawTransactionArgument<string>;
-    enclaveConfig: RawTransactionArgument<string>;
-    enclave: RawTransactionArgument<string>;
-    timestampMs: RawTransactionArgument<number | bigint>;
-    item: TransactionArgument;
-    proof: RawTransactionArgument<Array<Array<number>>>;
-    sig: RawTransactionArgument<Array<number>>;
-}
-export interface CollectSingleWithProofOptions {
-    package?: string;
-    arguments: CollectSingleWithProofArguments | [
-        collector: TransactionArgument,
-        config: RawTransactionArgument<string>,
-        enclaveConfig: RawTransactionArgument<string>,
-        enclave: RawTransactionArgument<string>,
-        timestampMs: RawTransactionArgument<number | bigint>,
-        item: TransactionArgument,
-        proof: RawTransactionArgument<Array<Array<number>>>,
-        sig: RawTransactionArgument<Array<number>>
-    ];
-}
-/**
- * Collect-only sibling of `feed_single_with_proof` for the dual-rule latest path
- * (WaterX alongside Pyth on one aggregator), mirroring `collect_batch_latest`:
- * verifies root + proof, feeds the leaf into the caller's `PriceCollector` WITHOUT
- * calling `oracle::aggregate`. Abort vs abstain matches `collect_batch_latest`
- * exactly — a config/integrity mismatch aborts, a freshness miss abstains so Pyth
- * can cover a lagging TEE.
- */
-export declare function collectSingleWithProof(options: CollectSingleWithProofOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface QuoteForTimestampArguments {
     config: RawTransactionArgument<string>;
     enclaveConfig: RawTransactionArgument<string>;
@@ -491,27 +421,6 @@ export interface BatchPriceIntentOptions {
     ];
 }
 export declare function batchPriceIntent(options?: BatchPriceIntentOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface MerkleRootIntentOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function merkleRootIntent(options?: MerkleRootIntentOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface LeafHashOfArguments {
-    item: TransactionArgument;
-}
-export interface LeafHashOfOptions {
-    package?: string;
-    arguments: LeafHashOfArguments | [
-        item: TransactionArgument
-    ];
-}
-/**
- * The keccak256 leaf hash for `item` — `keccak256(0x00 || BCS(item))`. Exposed so
- * the off-chain builder / SDK can be pinned against the on-chain encoding in a
- * cross-implementation golden test.
- */
-export declare function leafHashOf(options: LeafHashOfOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface MaxBatchSizeOptions {
     package?: string;
     arguments?: [
@@ -808,42 +717,6 @@ export interface SourceGataUsdtPerpWsOptions {
     ];
 }
 export declare function sourceGataUsdtPerpWs(options?: SourceGataUsdtPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface SourceBybitSpotWsOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function sourceBybitSpotWs(options?: SourceBybitSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface SourceXstockEquityRestOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function sourceXstockEquityRest(options?: SourceXstockEquityRestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface SourceOkxSpotWsOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function sourceOkxSpotWs(options?: SourceOkxSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface SourceHyperliquidPerpWsOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function sourceHyperliquidPerpWs(options?: SourceHyperliquidPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface SourceGateioSpotWsOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function sourceGateioSpotWs(options?: SourceGateioSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface SourceKrakenSpotWsOptions {
-    package?: string;
-    arguments?: [
-    ];
-}
-export declare function sourceKrakenSpotWs(options?: SourceKrakenSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface MethodDirectOptions {
     package?: string;
     arguments?: [

package/dist/src/generated/waterx_rule/waterx_rule.js

@@ -41,9 +41,6 @@ export const BatchPriceItem = new MoveStruct({ name: `${$moduleName}::BatchPrice
 export const BatchPricePayload = new MoveStruct({ name: `${$moduleName}::BatchPricePayload`, fields: {
         items: bcs.vector(BatchPriceItem)
     } });
-export const MerkleRoot = new MoveStruct({ name: `${$moduleName}::MerkleRoot`, fields: {
-        root: bcs.vector(bcs.u8())
-    } });
 export const FeedConfig = new MoveStruct({ name: `${$moduleName}::FeedConfig`, fields: {
         ticker: bcs.string(),
         sources: bcs.vector(bcs.u64()),
@@ -129,17 +126,15 @@ export function feedBatchLatest(options) {
  * and so aborts on any stale item, this path runs alongside Pyth/Supra. To let
  * those cover a lagging TEE — the blast-radius bound in the GCP ADR — a
  * _freshness_ miss ABSTAINS (records `none`, which `aggregator::remove_outliers`
- * drops before the `weight_threshold` fail-closed check), and so does a _replayed_
- * signed timestamp (the chain already accepted that snapshot — the on-chain price
- * is at least as fresh, and two concurrent keeper PTBs sharing one envelope must
- * not kill each other). A _config/integrity_ mismatch (source / ticker / method /
- * confidence / deviation) still ABORTS: an enclave whose signed payload disagrees
- * with the on-chain feed config is a red flag, not a liveness blip. Bad signature,
- * malformed batch, and a future timestamp always abort.
+ * drops before the `weight_threshold` fail-closed check). A _config/integrity_
+ * mismatch (source / ticker / method / confidence / deviation) still ABORTS: an
+ * enclave whose signed payload disagrees with the on-chain feed config is a red
+ * flag, not a liveness blip. Bad signature, malformed batch, a future timestamp,
+ * and replay always abort.
  *
  * Every gate is identical to `feed_batch_item_latest`; only the abort-vs-abstain
- * disposition of the freshness + replay gates differs, and the sink is the
- * caller's collector rather than a fresh single-rule one.
+ * disposition of the two freshness gates differs, and the sink is the caller's
+ * collector rather than a fresh single-rule one.
  */
 export function collectBatchLatest(options) {
     const packageAddress = options.package ?? '@waterx/rule';
@@ -161,63 +156,6 @@ export function collectBatchLatest(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-/**
- * Streaming per-symbol sibling of `feed_batch_latest`. Verifies ONE enclave
- * signature over a Merkle `root`, checks `item` is a leaf of that root via
- * `proof`, then runs the identical per-item gates + `oracle::aggregate`. Use for a
- * WaterxRule-only aggregator; for a Pyth-coexisting aggregator use
- * `collect_single_with_proof`.
- */
-export function feedSingleWithProof(options) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x2::clock::Clock',
-        null,
-        null,
-        'u64',
-        null,
-        'vector<vector<u8>>',
-        'vector<u8>'
-    ];
-    const parameterNames = ["oracleObj", "config", "enclaveConfig", "enclave", "timestampMs", "item", "proof", "sig"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'feed_single_with_proof',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-/**
- * Collect-only sibling of `feed_single_with_proof` for the dual-rule latest path
- * (WaterX alongside Pyth on one aggregator), mirroring `collect_batch_latest`:
- * verifies root + proof, feeds the leaf into the caller's `PriceCollector` WITHOUT
- * calling `oracle::aggregate`. Abort vs abstain matches `collect_batch_latest`
- * exactly — a config/integrity mismatch aborts, a freshness miss abstains so Pyth
- * can cover a lagging TEE.
- */
-export function collectSingleWithProof(options) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x2::clock::Clock',
-        null,
-        null,
-        'u64',
-        null,
-        'vector<vector<u8>>',
-        'vector<u8>'
-    ];
-    const parameterNames = ["collector", "config", "enclaveConfig", "enclave", "timestampMs", "item", "proof", "sig"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'collect_single_with_proof',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
 /**
  * Verifies a historical quote without touching `waterx_oracle`.
  *
@@ -409,32 +347,6 @@ export function batchPriceIntent(options = {}) {
         function: 'batch_price_intent',
     });
 }
-export function merkleRootIntent(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'merkle_root_intent',
-    });
-}
-/**
- * The keccak256 leaf hash for `item` — `keccak256(0x00 || BCS(item))`. Exposed so
- * the off-chain builder / SDK can be pinned against the on-chain encoding in a
- * cross-implementation golden test.
- */
-export function leafHashOf(options) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    const argumentsTypes = [
-        null
-    ];
-    const parameterNames = ["item"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'leaf_hash_of',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
 export function maxBatchSize(options = {}) {
     const packageAddress = options.package ?? '@waterx/rule';
     return (tx) => tx.moveCall({
@@ -821,54 +733,6 @@ export function sourceGataUsdtPerpWs(options = {}) {
         function: 'source_gata_usdt_perp_ws',
     });
 }
-export function sourceBybitSpotWs(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'source_bybit_spot_ws',
-    });
-}
-export function sourceXstockEquityRest(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'source_xstock_equity_rest',
-    });
-}
-export function sourceOkxSpotWs(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'source_okx_spot_ws',
-    });
-}
-export function sourceHyperliquidPerpWs(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'source_hyperliquid_perp_ws',
-    });
-}
-export function sourceGateioSpotWs(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'source_gateio_spot_ws',
-    });
-}
-export function sourceKrakenSpotWs(options = {}) {
-    const packageAddress = options.package ?? '@waterx/rule';
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'waterx_rule',
-        function: 'source_kraken_spot_ws',
-    });
-}
 export function methodDirect(options = {}) {
     const packageAddress = options.package ?? '@waterx/rule';
     return (tx) => tx.moveCall({

package/dist/src/oracle/aggregate.d.ts

@@ -19,7 +19,8 @@
  *
  * `refreshOraclePrices` additionally routes the on-chain price *update* leg
  * (the fetch + verify/push step, before any of the above feeding) through the
- * `PriceUpdateRule` selected by `host.oracleSource` — see `rule-registry.ts`.
+ * `PriceUpdateRule` of EVERY source in the `host.oracleSources` fed set — see
+ * `rule-registry.ts`.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
 import type { OracleHost } from "./host.ts";
@@ -84,27 +85,26 @@ export declare function aggregateTickerWithConstant(tx: Transaction, host: Oracl
  * entry, Lazer if the lazer update leg served it — see below — Supra when
  * enabled, Constant when it's a constant ticker).
  *
- * Before that, the on-chain price *update* leg is routed by `host.oracleSource`
- * (see `rule-registry.ts`): the ONE selected source serves every ticker in its
- * `supportedTickers(host)`. There is **no cross-source fallback** — a requested
- * ticker the selected source does not serve, and that is not a constant-only
- * ticker (which needs no price-update leg), fails the build immediately with a
- * clear error naming the ticker and source. That is the deliberate "fail the
- * tx-build, don't silently reroute" contract: a wrong-but-present feed id is
- * NOT validated here (it surfaces on-chain at dry-run); a MISSING feed for the
- * selected source is caught here. When the selected source's feed exists but is
- * wrong, this function does nothing special — the on-chain aggregate aborts at
- * dry-run, which is correct.
+ * Before that, the on-chain price *update* leg is routed by the
+ * `host.oracleSources` fed set (see `rule-registry.ts`): EVERY listed source
+ * updates the tickers its own `supportedTickers(host)` serves, all in this one
+ * PTB. There is **no cross-source fallback** — a requested ticker NO listed
+ * source serves, and that is not a constant-only ticker (which needs no
+ * price-update leg), fails the build immediately with a clear error naming
+ * the ticker and the list. That is the deliberate "fail the tx-build, don't
+ * silently reroute" contract: a wrong-but-present feed id is NOT validated
+ * here (it surfaces on-chain at dry-run); a ticker MISSING from every listed
+ * source's feeds is caught here.
  *
- * The selected source's fetch + build runs against its own infra, guaranteeing
- * per-rule PTB atomicity. A fee-source pre-check runs first (the source's
- * `requiresFeeSource`) BEFORE any off-chain fetch or PTB mutation — so a
- * fee-charging source with no `opts.feeSource` throws
+ * Each source's fetch + build runs against its own infra, guaranteeing
+ * per-rule PTB atomicity. A fee-source pre-check runs first (any listed
+ * source's `requiresFeeSource`) BEFORE any off-chain fetch or PTB mutation —
+ * so a fee-charging source with no `opts.feeSource` throws
  * `OracleFeeSourceUnavailable` with zero wasted network calls and zero stray
- * moveCalls. Only once that check passes does the off-chain fetch run and
- * complete before any PTB mutation; on-chain reads inside `buildUpdateCalls`
- * can still fail mid-append for other reasons — callers discard the tx on any
- * throw.
+ * moveCalls. Only once that check passes do the off-chain fetches run — in
+ * parallel across sources — and ALL settle before the first PTB mutation;
+ * on-chain reads inside `buildUpdateCalls` can still fail mid-append for
+ * other reasons — callers discard the tx on any throw.
  *
  * **Collector-feed leg is rule-aware:** a lazer-served group's
  * `buildUpdateCalls` returns the verified `Update` PTB value
@@ -139,7 +139,7 @@ export declare function refreshOraclePrices(tx: Transaction, host: OracleHost, t
     /**
      * @internal Test-only: layer fake `PriceUpdateRule`s on top of the
      * production registry (see `rule-registry.ts`'s `resolveOracleRule`).
-     * Production callers never set this — routing is by `host.oracleSource`
+     * Production callers never set this — routing is by `host.oracleSources`
      * alone.
      */
     ruleOverrides?: Partial<Record<OracleSource, PriceUpdateRule>>;