@waterx/sdk 4.0.1 → 4.1.0

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

@@ -0,0 +1,991 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Nautilus-backed oracle rule for Binance, Bybit, and Gate.io prices. */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as float from "./deps/bucket_v2_framework/float.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+const $moduleName = '@waterx/rule::waterx_rule';
+export const WATERX_RULE = new MoveStruct({ name: `${$moduleName}::WATERX_RULE`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const WaterxRule = new MoveStruct({ name: `${$moduleName}::WaterxRule`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const PricePayload = new MoveStruct({ name: `${$moduleName}::PricePayload`, fields: {
+        ticker: bcs.string(),
+        sources: bcs.vector(bcs.u64()),
+        method: bcs.string(),
+        price_timestamp_ms: bcs.u64(),
+        price_n: bcs.u64(),
+        price_scale: bcs.u64(),
+        confidence_n: bcs.u64(),
+        confidence_scale: bcs.u64(),
+        max_source_deviation_bps: bcs.u64(),
+        num_sources: bcs.u8()
+    } });
+export const BatchPriceItem = new MoveStruct({ name: `${$moduleName}::BatchPriceItem`, fields: {
+        symbol: bcs.string(),
+        ticker: bcs.string(),
+        sources: bcs.vector(bcs.u64()),
+        method: bcs.string(),
+        price_timestamp_ms: bcs.u64(),
+        price_n: bcs.u64(),
+        price_scale: bcs.u64(),
+        confidence_n: bcs.u64(),
+        confidence_scale: bcs.u64(),
+        max_source_deviation_bps: bcs.u64(),
+        num_sources: bcs.u8()
+    } });
+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()),
+        method: bcs.string(),
+        max_age_ms: bcs.u64(),
+        max_confidence_bps: bcs.u64(),
+        max_source_deviation_bps: bcs.u64(),
+        min_sources: bcs.u8()
+    } });
+export const VerifiedPrice = new MoveStruct({ name: `${$moduleName}::VerifiedPrice`, fields: {
+        symbol: bcs.string(),
+        ticker: bcs.string(),
+        sources: bcs.vector(bcs.u64()),
+        method: bcs.string(),
+        price_timestamp_ms: bcs.u64(),
+        price: float.Float,
+        price_n: bcs.u64(),
+        price_scale: bcs.u64(),
+        confidence_n: bcs.u64(),
+        confidence_scale: bcs.u64(),
+        max_source_deviation_bps: bcs.u64(),
+        num_sources: bcs.u8(),
+        signed_timestamp_ms: bcs.u64()
+    } });
+export const Config = new MoveStruct({ name: `${$moduleName}::Config`, fields: {
+        id: bcs.Address,
+        feed_map: vec_map.VecMap(bcs.string(), FeedConfig)
+    } });
+export const SignedTsHwmKey = new MoveStruct({ name: `${$moduleName}::SignedTsHwmKey`, fields: {
+        symbol: bcs.string()
+    } });
+export const HistoricalPriceVerified = new MoveStruct({ name: `${$moduleName}::HistoricalPriceVerified`, fields: {
+        symbol: bcs.string(),
+        ticker: bcs.string(),
+        sources: bcs.vector(bcs.u64()),
+        method: bcs.string(),
+        price_timestamp_ms: bcs.u64(),
+        price: bcs.u128(),
+        confidence: bcs.u128(),
+        max_source_deviation_bps: bcs.u64(),
+        num_sources: bcs.u8(),
+        signed_timestamp_ms: bcs.u64()
+    } });
+export const BatchLatestUpdated = new MoveStruct({ name: `${$moduleName}::BatchLatestUpdated`, fields: {
+        count: bcs.u64(),
+        timestamp_ms: 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.
+ */
+export 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: 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.
+ */
+export 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: 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`.
+ *
+ * `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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Consumes a verified historical price proof when no downstream consumer needs to
+ * keep using it in the PTB.
+ */
+export 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: 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`.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Admin Funs */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Getter Funs */
+export function newBatchPayload(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'new_batch_payload',
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function batchPriceIntent(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        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({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'max_batch_size',
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function sourceBinanceSpot(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_binance_spot',
+    });
+}
+export function sourceBinanceUsdmPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_binance_usdm_perp_ws',
+    });
+}
+export function sourceBybitLinearPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_bybit_linear_perp_ws',
+    });
+}
+export function sourceGateioUsdtPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'source_gateio_usdt_perp_ws',
+    });
+}
+export function sourceGataUsdtPerpWs(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        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: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_direct',
+    });
+}
+export function methodMedian(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_median',
+    });
+}
+export function methodConfidence(options = {}) {
+    const packageAddress = options.package ?? '@waterx/rule';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_rule',
+        function: 'method_confidence',
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}