@waterx/sdk 4.0.1 → 4.1.0

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

@@ -0,0 +1,1092 @@
+"use strict";
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+exports.setFeed = setFeed;
+exports.setPerpFeed = setPerpFeed;
+exports.removeFeed = removeFeed;
+exports.newBatchPayload = newBatchPayload;
+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;
+exports.batchItemTicker = batchItemTicker;
+exports.batchItemSources = batchItemSources;
+exports.batchItemMethod = batchItemMethod;
+exports.batchItemPriceTimestampMs = batchItemPriceTimestampMs;
+exports.batchItemPriceN = batchItemPriceN;
+exports.batchItemPriceScale = batchItemPriceScale;
+exports.batchItemConfidenceN = batchItemConfidenceN;
+exports.batchItemConfidenceScale = batchItemConfidenceScale;
+exports.batchItemMaxSourceDeviationBps = batchItemMaxSourceDeviationBps;
+exports.batchItemNumSources = batchItemNumSources;
+exports.verifiedSymbol = verifiedSymbol;
+exports.verifiedTicker = verifiedTicker;
+exports.verifiedSources = verifiedSources;
+exports.verifiedMethod = verifiedMethod;
+exports.verifiedPriceTimestampMs = verifiedPriceTimestampMs;
+exports.verifiedPrice = verifiedPrice;
+exports.verifiedPriceScaled = verifiedPriceScaled;
+exports.verifiedPriceN = verifiedPriceN;
+exports.verifiedPriceScale = verifiedPriceScale;
+exports.verifiedConfidenceN = verifiedConfidenceN;
+exports.verifiedConfidenceScale = verifiedConfidenceScale;
+exports.verifiedMaxSourceDeviationBps = verifiedMaxSourceDeviationBps;
+exports.verifiedNumSources = verifiedNumSources;
+exports.verifiedSignedTimestampMs = verifiedSignedTimestampMs;
+exports.sourceBinanceSpot = sourceBinanceSpot;
+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.methodDirect = methodDirect;
+exports.methodMedian = methodMedian;
+exports.methodConfidence = methodConfidence;
+exports.isSupportedSource = isSupportedSource;
+exports.isPerpSource = isPerpSource;
+exports.isSupportedMethod = isSupportedMethod;
+exports.isPerpMethod = isPerpMethod;
+exports.sourceFromName = sourceFromName;
+exports.methodFromName = methodFromName;
+exports.signedTsHwm = signedTsHwm;
+/** Nautilus-backed oracle rule for Binance, Bybit, and Gate.io prices. */
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const float = __importStar(require("./deps/bucket_v2_framework/float.js"));
+const vec_map = __importStar(require("./deps/sui/vec_map.js"));
+const $moduleName = '@waterx/rule::waterx_rule';
+exports.WATERX_RULE = new index_ts_1.MoveStruct({ name: `${$moduleName}::WATERX_RULE`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.WaterxRule = new index_ts_1.MoveStruct({ name: `${$moduleName}::WaterxRule`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.PricePayload = new index_ts_1.MoveStruct({ name: `${$moduleName}::PricePayload`, fields: {
+        ticker: bcs_1.bcs.string(),
+        sources: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        method: bcs_1.bcs.string(),
+        price_timestamp_ms: bcs_1.bcs.u64(),
+        price_n: bcs_1.bcs.u64(),
+        price_scale: bcs_1.bcs.u64(),
+        confidence_n: bcs_1.bcs.u64(),
+        confidence_scale: bcs_1.bcs.u64(),
+        max_source_deviation_bps: bcs_1.bcs.u64(),
+        num_sources: bcs_1.bcs.u8()
+    } });
+exports.BatchPriceItem = new index_ts_1.MoveStruct({ name: `${$moduleName}::BatchPriceItem`, fields: {
+        symbol: bcs_1.bcs.string(),
+        ticker: bcs_1.bcs.string(),
+        sources: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        method: bcs_1.bcs.string(),
+        price_timestamp_ms: bcs_1.bcs.u64(),
+        price_n: bcs_1.bcs.u64(),
+        price_scale: bcs_1.bcs.u64(),
+        confidence_n: bcs_1.bcs.u64(),
+        confidence_scale: bcs_1.bcs.u64(),
+        max_source_deviation_bps: bcs_1.bcs.u64(),
+        num_sources: bcs_1.bcs.u8()
+    } });
+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()),
+        method: bcs_1.bcs.string(),
+        max_age_ms: bcs_1.bcs.u64(),
+        max_confidence_bps: bcs_1.bcs.u64(),
+        max_source_deviation_bps: bcs_1.bcs.u64(),
+        min_sources: bcs_1.bcs.u8()
+    } });
+exports.VerifiedPrice = new index_ts_1.MoveStruct({ name: `${$moduleName}::VerifiedPrice`, fields: {
+        symbol: bcs_1.bcs.string(),
+        ticker: bcs_1.bcs.string(),
+        sources: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        method: bcs_1.bcs.string(),
+        price_timestamp_ms: bcs_1.bcs.u64(),
+        price: float.Float,
+        price_n: bcs_1.bcs.u64(),
+        price_scale: bcs_1.bcs.u64(),
+        confidence_n: bcs_1.bcs.u64(),
+        confidence_scale: bcs_1.bcs.u64(),
+        max_source_deviation_bps: bcs_1.bcs.u64(),
+        num_sources: bcs_1.bcs.u8(),
+        signed_timestamp_ms: bcs_1.bcs.u64()
+    } });
+exports.Config = new index_ts_1.MoveStruct({ name: `${$moduleName}::Config`, fields: {
+        id: bcs_1.bcs.Address,
+        feed_map: vec_map.VecMap(bcs_1.bcs.string(), exports.FeedConfig)
+    } });
+exports.SignedTsHwmKey = new index_ts_1.MoveStruct({ name: `${$moduleName}::SignedTsHwmKey`, fields: {
+        symbol: bcs_1.bcs.string()
+    } });
+exports.HistoricalPriceVerified = new index_ts_1.MoveStruct({ name: `${$moduleName}::HistoricalPriceVerified`, fields: {
+        symbol: bcs_1.bcs.string(),
+        ticker: bcs_1.bcs.string(),
+        sources: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        method: bcs_1.bcs.string(),
+        price_timestamp_ms: bcs_1.bcs.u64(),
+        price: bcs_1.bcs.u128(),
+        confidence: bcs_1.bcs.u128(),
+        max_source_deviation_bps: bcs_1.bcs.u64(),
+        num_sources: bcs_1.bcs.u8(),
+        signed_timestamp_ms: bcs_1.bcs.u64()
+    } });
+exports.BatchLatestUpdated = new index_ts_1.MoveStruct({ name: `${$moduleName}::BatchLatestUpdated`, fields: {
+        count: bcs_1.bcs.u64(),
+        timestamp_ms: bcs_1.bcs.u64()
+    } });
+/**
+ * Public Funs Verifies one Nautilus batch signature and updates one or more latest
+ * oracle prices. This function is only for current/latest data, never historical
+ * data. A single symbol is just a batch of one.
+ */
+function feedBatchLatest(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock',
+        null,
+        null,
+        'u64',
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["oracleObj", "config", "enclaveConfig", "enclave", "timestampMs", "payload", "sig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'feed_batch_latest',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Collect-only sibling of `feed_batch_latest` for the **dual-rule** latest path:
+ * verifies one Nautilus batch signature and feeds the single item whose symbol
+ * matches `collector.symbol()` into a caller-owned `PriceCollector`, WITHOUT
+ * calling `oracle::aggregate`. This lets one aggregator carry both a `WaterxRule`
+ * and (e.g.) a `PythRule` weight — the caller composes one collector across every
+ * weighted rule in the PTB (compose-then-aggregate, like `pyth_rule::feed`) and
+ * aggregates once.
+ *
+ * Abort vs abstain (WL-1963): unlike `feed_batch_latest`, which has no fallback
+ * 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.
+ *
+ * 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.
+ */
+function collectBatchLatest(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock',
+        null,
+        null,
+        'u64',
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["collector", "config", "enclaveConfig", "enclave", "timestampMs", "payload", "sig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'collect_batch_latest',
+        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`.
+ *
+ * `signed_timestamp_ms` is the fresh timestamp signed by Nautilus.
+ * `requested_price_timestamp_ms` is the historical price timestamp the caller
+ * requested from Nautilus. Consumers should still assert the returned proof's
+ * symbol and timestamp inside their own contract before using the price.
+ */
+function quoteForTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        '0x2::clock::Clock',
+        null,
+        null,
+        '0x1::string::String',
+        'u64',
+        'u64',
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["config", "enclaveConfig", "enclave", "symbol", "signedTimestampMs", "requestedPriceTimestampMs", "payload", "sig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'quote_for_timestamp',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Consumes a verified historical price proof when no downstream consumer needs to
+ * keep using it in the PTB.
+ */
+function destroyVerifiedPrice(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'destroy_verified_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Consumes a verified historical price and feeds it into a collector.
+ *
+ * Use this after `quote_for_timestamp` and before
+ * `waterx_oracle::oracle::register_price_at_timestamp`.
+ */
+function collectVerifiedPrice(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["collector", "price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'collect_verified_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Admin Funs */
+function setFeed(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        '0x1::string::String',
+        'vector<u64>',
+        '0x1::string::String',
+        'u64'
+    ];
+    const parameterNames = ["config", "Cap", "symbol", "ticker", "sources", "method", "maxAgeMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'set_feed',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function setPerpFeed(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        '0x1::string::String',
+        'vector<u64>',
+        '0x1::string::String',
+        'u64',
+        'u64',
+        'u64',
+        'u8'
+    ];
+    const parameterNames = ["config", "Cap", "symbol", "ticker", "sources", "method", "maxAgeMs", "maxConfidenceBps", "maxSourceDeviationBps", "minSources"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'set_perp_feed',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function removeFeed(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["config", "Cap", "symbol"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'remove_feed',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Getter Funs */
+function newBatchPayload(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'new_batch_payload',
+    });
+}
+function newBatchItem(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        '0x1::string::String',
+        '0x1::string::String',
+        'vector<u64>',
+        '0x1::string::String',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u8'
+    ];
+    const parameterNames = ["symbol", "ticker", "sources", "method", "priceTimestampMs", "priceN", "priceScale", "confidenceN", "confidenceScale", "maxSourceDeviationBps", "numSources"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'new_batch_item',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function pushBatchItem(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["payload", "item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'push_batch_item',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function feedConfig(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["config", "symbol"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'feed_config',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchPriceIntent(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        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({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'max_batch_size',
+    });
+}
+function batchItems(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["payload"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_items',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemSymbol(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_symbol',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemTicker(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_ticker',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemSources(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_sources',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemMethod(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_method',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemPriceTimestampMs(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_price_timestamp_ms',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemPriceN(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_price_n',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemPriceScale(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_price_scale',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemConfidenceN(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_confidence_n',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemConfidenceScale(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_confidence_scale',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemMaxSourceDeviationBps(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_max_source_deviation_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function batchItemNumSources(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["item"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'batch_item_num_sources',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedSymbol(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_symbol',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedTicker(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_ticker',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedSources(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_sources',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedMethod(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_method',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedPriceTimestampMs(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_price_timestamp_ms',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedPrice(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedPriceScaled(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_price_scaled',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedPriceN(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_price_n',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedPriceScale(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_price_scale',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedConfidenceN(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_confidence_n',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedConfidenceScale(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_confidence_scale',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedMaxSourceDeviationBps(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_max_source_deviation_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedNumSources(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_num_sources',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function verifiedSignedTimestampMs(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'verified_signed_timestamp_ms',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function sourceBinanceSpot(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_binance_spot',
+    });
+}
+function sourceBinanceUsdmPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_binance_usdm_perp_ws',
+    });
+}
+function sourceBybitLinearPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_bybit_linear_perp_ws',
+    });
+}
+function sourceGateioUsdtPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_gateio_usdt_perp_ws',
+    });
+}
+function sourceGataUsdtPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        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 methodDirect(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_direct',
+    });
+}
+function methodMedian(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_median',
+    });
+}
+function methodConfidence(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_confidence',
+    });
+}
+function isSupportedSource(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        'u64'
+    ];
+    const parameterNames = ["source"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'is_supported_source',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isPerpSource(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        'u64'
+    ];
+    const parameterNames = ["source"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'is_perp_source',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isSupportedMethod(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ];
+    const parameterNames = ["method"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'is_supported_method',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function isPerpMethod(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ];
+    const parameterNames = ["method"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'is_perp_method',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function sourceFromName(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ];
+    const parameterNames = ["name"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_from_name',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function methodFromName(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ];
+    const parameterNames = ["name"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_from_name',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Last accepted signed timestamp for `symbol` (0 if none yet). View helper for
+ * keepers/SDK so they can pick a `timestamp_ms` strictly greater than this.
+ */
+function signedTsHwm(options) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["config", "symbol"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'signed_ts_hwm',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}