@waterx/sdk 4.3.2 → 5.0.0

package/SKILLS.md

@@ -0,0 +1,34 @@
+# Skills
+
+Agent Skills shipped with `@waterx/sdk`. A skill is a written procedure an AI coding agent
+loads on demand — the same flow a developer would follow, in a form an agent can execute
+without being re-taught it each session.
+
+[**`waterx-sdk-integration`**](./.claude/skills/waterx-sdk-integration/SKILL.md) is the one
+skill here: it covers integrating the SDK into an app, keeper, or bot. Its frontmatter
+`description` states exactly when it triggers.
+
+## Using it in this repo
+
+Nothing to do. Claude Code discovers `.claude/skills/` automatically; ask for the skill by
+name, or just describe an integration task and it loads.
+
+## Using it in your own repo
+
+The skill ships inside the published package, so copy it out of `node_modules`:
+
+```bash
+mkdir -p .claude/skills
+cp -r node_modules/@waterx/sdk/.claude/skills/waterx-sdk-integration .claude/skills/
+```
+
+Agents other than Claude Code can read the file directly — it is plain Markdown with a
+YAML header, and nothing in it is Claude-specific.
+
+Re-copy after upgrading the SDK; the skill tracks the API surface and changes with it.
+
+## For humans
+
+The skill is readable on its own and doubles as an integration checklist. If you are
+reading rather than delegating, [`README.md`](./README.md) covers the same ground with
+more prose — start with [First integration](./README.md#first-integration).

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

@@ -71,11 +71,9 @@ export interface WithdrawalQueuePackage {
     queue?: string;
 }
 /**
- * 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_CORE_INFRA[*].wormhole_state_id` in `oracle/pyth.ts`). Override
- * per-deployment via `WaterXConfig.wormhole` if a deployment ever points
- * elsewhere.
+ * Wormhole infra for the cross-chain credit bridge. `state_id` is the shared
+ * Sui Wormhole `State` object for the network. Override per-deployment via
+ * `WaterXConfig.wormhole` if a deployment ever points elsewhere.
  */
 export interface WormholeInfraConfig {
     /** Shared Sui Wormhole `State` object. */

package/dist/cjs/src/account/funding/wormhole.d.ts

@@ -1,8 +1,7 @@
 /**
  * Wormhole / Wormholescan integration for the cross-chain credit bridge.
  *
- * Single source of truth for VAA discovery + (de)serialization — mirrors
- * `oracle/pyth.ts`'s role for Pyth's Hermes endpoint. Two directions:
+ * Single source of truth for VAA discovery + (de)serialization. Two directions:
  *
  *   - Mint (EVM → Sui): fetch the signed VAA for an EVM `Deposit` by
  *     (emitter chain, emitter address, sequence); the raw bytes feed

package/dist/cjs/src/account/funding/wormhole.js

@@ -2,8 +2,7 @@
 /**
  * Wormhole / Wormholescan integration for the cross-chain credit bridge.
  *
- * Single source of truth for VAA discovery + (de)serialization — mirrors
- * `oracle/pyth.ts`'s role for Pyth's Hermes endpoint. Two directions:
+ * Single source of truth for VAA discovery + (de)serialization. Two directions:
  *
  *   - Mint (EVM → Sui): fetch the signed VAA for an EVM `Deposit` by
  *     (emitter chain, emitter address, sequence); the raw bytes feed

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

@@ -70,6 +70,11 @@ 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> & {
@@ -214,17 +219,82 @@ 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). 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.
+ * 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.
  *
  * Every gate is identical to `feed_batch_item_latest`; only the abort-vs-abstain
- * disposition of the two freshness gates differs, and the sink is the caller's
- * collector rather than a fresh single-rule one.
+ * disposition of the freshness + replay 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>;
@@ -421,6 +491,27 @@ 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?: [
@@ -717,6 +808,48 @@ 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 SourcePythLazerWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourcePythLazerWs(options?: SourcePythLazerWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface MethodDirectOptions {
     package?: string;
     arguments?: [

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

@@ -36,9 +36,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchLatestUpdated = exports.HistoricalPriceVerified = exports.SignedTsHwmKey = exports.Config = exports.VerifiedPrice = exports.FeedConfig = exports.BatchPricePayload = exports.BatchPriceItem = exports.PricePayload = exports.WaterxRule = exports.WATERX_RULE = void 0;
+exports.BatchLatestUpdated = exports.HistoricalPriceVerified = exports.SignedTsHwmKey = exports.Config = exports.VerifiedPrice = exports.FeedConfig = exports.MerkleRoot = exports.BatchPricePayload = exports.BatchPriceItem = exports.PricePayload = exports.WaterxRule = exports.WATERX_RULE = void 0;
 exports.feedBatchLatest = feedBatchLatest;
 exports.collectBatchLatest = collectBatchLatest;
+exports.feedSingleWithProof = feedSingleWithProof;
+exports.collectSingleWithProof = collectSingleWithProof;
 exports.quoteForTimestamp = quoteForTimestamp;
 exports.destroyVerifiedPrice = destroyVerifiedPrice;
 exports.collectVerifiedPrice = collectVerifiedPrice;
@@ -50,6 +52,8 @@ exports.newBatchItem = newBatchItem;
 exports.pushBatchItem = pushBatchItem;
 exports.feedConfig = feedConfig;
 exports.batchPriceIntent = batchPriceIntent;
+exports.merkleRootIntent = merkleRootIntent;
+exports.leafHashOf = leafHashOf;
 exports.maxBatchSize = maxBatchSize;
 exports.batchItems = batchItems;
 exports.batchItemSymbol = batchItemSymbol;
@@ -82,6 +86,13 @@ exports.sourceBinanceUsdmPerpWs = sourceBinanceUsdmPerpWs;
 exports.sourceBybitLinearPerpWs = sourceBybitLinearPerpWs;
 exports.sourceGateioUsdtPerpWs = sourceGateioUsdtPerpWs;
 exports.sourceGataUsdtPerpWs = sourceGataUsdtPerpWs;
+exports.sourceBybitSpotWs = sourceBybitSpotWs;
+exports.sourceXstockEquityRest = sourceXstockEquityRest;
+exports.sourceOkxSpotWs = sourceOkxSpotWs;
+exports.sourceHyperliquidPerpWs = sourceHyperliquidPerpWs;
+exports.sourceGateioSpotWs = sourceGateioSpotWs;
+exports.sourceKrakenSpotWs = sourceKrakenSpotWs;
+exports.sourcePythLazerWs = sourcePythLazerWs;
 exports.methodDirect = methodDirect;
 exports.methodMedian = methodMedian;
 exports.methodConfidence = methodConfidence;
@@ -132,6 +143,9 @@ exports.BatchPriceItem = new index_ts_1.MoveStruct({ name: `${$moduleName}::Batc
 exports.BatchPricePayload = new index_ts_1.MoveStruct({ name: `${$moduleName}::BatchPricePayload`, fields: {
         items: bcs_1.bcs.vector(exports.BatchPriceItem)
     } });
+exports.MerkleRoot = new index_ts_1.MoveStruct({ name: `${$moduleName}::MerkleRoot`, fields: {
+        root: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
 exports.FeedConfig = new index_ts_1.MoveStruct({ name: `${$moduleName}::FeedConfig`, fields: {
         ticker: bcs_1.bcs.string(),
         sources: bcs_1.bcs.vector(bcs_1.bcs.u64()),
@@ -217,15 +231,17 @@ 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). 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.
+ * 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.
  *
  * Every gate is identical to `feed_batch_item_latest`; only the abort-vs-abstain
- * disposition of the two freshness gates differs, and the sink is the caller's
- * collector rather than a fresh single-rule one.
+ * disposition of the freshness + replay gates differs, and the sink is the
+ * caller's collector rather than a fresh single-rule one.
  */
 function collectBatchLatest(options) {
     const packageAddress = options.package ?? '@waterx/rule';
@@ -247,6 +263,63 @@ function collectBatchLatest(options) {
         arguments: (0, index_ts_1.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`.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 /**
  * Verifies a historical quote without touching `waterx_oracle`.
  *
@@ -438,6 +511,32 @@ function batchPriceIntent(options = {}) {
         function: 'batch_price_intent',
     });
 }
+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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 function maxBatchSize(options = {}) {
     const packageAddress = options.package ?? '@waterx/rule';
     return (tx) => tx.moveCall({
@@ -824,6 +923,62 @@ function sourceGataUsdtPerpWs(options = {}) {
         function: 'source_gata_usdt_perp_ws',
     });
 }
+function sourceBybitSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_bybit_spot_ws',
+    });
+}
+function sourceXstockEquityRest(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_xstock_equity_rest',
+    });
+}
+function sourceOkxSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_okx_spot_ws',
+    });
+}
+function sourceHyperliquidPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_hyperliquid_perp_ws',
+    });
+}
+function sourceGateioSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_gateio_spot_ws',
+    });
+}
+function sourceKrakenSpotWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_kraken_spot_ws',
+    });
+}
+function sourcePythLazerWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_pyth_lazer_ws',
+    });
+}
 function methodDirect(options = {}) {
     const packageAddress = options.package ?? '@waterx/rule';
     return (tx) => tx.moveCall({