@waterx/sdk 4.0.0 → 4.1.0

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

@@ -0,0 +1,940 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Nautilus-backed oracle rule for Binance, Bybit, and Gate.io prices. */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const WATERX_RULE: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/rule::waterx_rule::WATERX_RULE">;
+export declare const WaterxRule: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/rule::waterx_rule::WaterxRule">;
+export declare const PricePayload: MoveStruct<{
+    ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    sources: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    method: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    price_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price_n: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    confidence_n: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    confidence_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_source_deviation_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    num_sources: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/rule::waterx_rule::PricePayload">;
+export declare const BatchPriceItem: MoveStruct<{
+    symbol: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    sources: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    method: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    price_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price_n: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    confidence_n: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    confidence_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_source_deviation_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    num_sources: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/rule::waterx_rule::BatchPriceItem">;
+export declare const BatchPricePayload: MoveStruct<{
+    items: import("@mysten/sui/bcs").BcsType<{
+        symbol: string;
+        ticker: string;
+        sources: string[];
+        method: string;
+        price_timestamp_ms: string;
+        price_n: string;
+        price_scale: string;
+        confidence_n: string;
+        confidence_scale: string;
+        max_source_deviation_bps: string;
+        num_sources: number;
+    }[], Iterable<{
+        symbol: string;
+        ticker: string;
+        sources: Iterable<string | number | bigint> & {
+            length: number;
+        };
+        method: string;
+        price_timestamp_ms: string | number | bigint;
+        price_n: string | number | bigint;
+        price_scale: string | number | bigint;
+        confidence_n: string | number | bigint;
+        confidence_scale: string | number | bigint;
+        max_source_deviation_bps: string | number | bigint;
+        num_sources: number;
+    }> & {
+        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> & {
+        length: number;
+    }, string>;
+    method: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    max_age_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_confidence_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_source_deviation_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    min_sources: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/rule::waterx_rule::FeedConfig">;
+export declare const VerifiedPrice: MoveStruct<{
+    symbol: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    sources: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    method: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    price_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    }, "bucket_v2_framework::float::Float">;
+    price_n: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    confidence_n: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    confidence_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_source_deviation_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    num_sources: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    signed_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/rule::waterx_rule::VerifiedPrice">;
+export declare const Config: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    feed_map: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: {
+                ticker: string;
+                sources: string[];
+                method: string;
+                max_age_ms: string;
+                max_confidence_bps: string;
+                max_source_deviation_bps: string;
+                min_sources: number;
+            };
+        }[], Iterable<{
+            key: string;
+            value: {
+                ticker: string;
+                sources: Iterable<string | number | bigint> & {
+                    length: number;
+                };
+                method: string;
+                max_age_ms: string | number | bigint;
+                max_confidence_bps: string | number | bigint;
+                max_source_deviation_bps: string | number | bigint;
+                min_sources: number;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, @waterx/rule::waterx_rule::FeedConfig>">;
+}, "@waterx/rule::waterx_rule::Config">;
+export declare const SignedTsHwmKey: MoveStruct<{
+    symbol: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+}, "@waterx/rule::waterx_rule::SignedTsHwmKey">;
+export declare const HistoricalPriceVerified: MoveStruct<{
+    symbol: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    sources: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+        length: number;
+    }, string>;
+    method: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    price_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    price: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    confidence: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    max_source_deviation_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    num_sources: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    signed_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/rule::waterx_rule::HistoricalPriceVerified">;
+export declare const BatchLatestUpdated: MoveStruct<{
+    count: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/rule::waterx_rule::BatchLatestUpdated">;
+export interface FeedBatchLatestArguments {
+    oracleObj: RawTransactionArgument<string>;
+    config: RawTransactionArgument<string>;
+    enclaveConfig: RawTransactionArgument<string>;
+    enclave: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+    payload: TransactionArgument;
+    sig: RawTransactionArgument<Array<number>>;
+}
+export interface FeedBatchLatestOptions {
+    package?: string;
+    arguments: FeedBatchLatestArguments | [
+        oracleObj: RawTransactionArgument<string>,
+        config: RawTransactionArgument<string>,
+        enclaveConfig: RawTransactionArgument<string>,
+        enclave: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint>,
+        payload: TransactionArgument,
+        sig: RawTransactionArgument<Array<number>>
+    ];
+}
+/**
+ * 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 declare function feedBatchLatest(options: FeedBatchLatestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CollectBatchLatestArguments {
+    collector: TransactionArgument;
+    config: RawTransactionArgument<string>;
+    enclaveConfig: RawTransactionArgument<string>;
+    enclave: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+    payload: TransactionArgument;
+    sig: RawTransactionArgument<Array<number>>;
+}
+export interface CollectBatchLatestOptions {
+    package?: string;
+    arguments: CollectBatchLatestArguments | [
+        collector: TransactionArgument,
+        config: RawTransactionArgument<string>,
+        enclaveConfig: RawTransactionArgument<string>,
+        enclave: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint>,
+        payload: TransactionArgument,
+        sig: RawTransactionArgument<Array<number>>
+    ];
+}
+/**
+ * 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 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>;
+    enclave: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    signedTimestampMs: RawTransactionArgument<number | bigint>;
+    requestedPriceTimestampMs: RawTransactionArgument<number | bigint>;
+    payload: TransactionArgument;
+    sig: RawTransactionArgument<Array<number>>;
+}
+export interface QuoteForTimestampOptions {
+    package?: string;
+    arguments: QuoteForTimestampArguments | [
+        config: RawTransactionArgument<string>,
+        enclaveConfig: RawTransactionArgument<string>,
+        enclave: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        signedTimestampMs: RawTransactionArgument<number | bigint>,
+        requestedPriceTimestampMs: RawTransactionArgument<number | bigint>,
+        payload: TransactionArgument,
+        sig: RawTransactionArgument<Array<number>>
+    ];
+}
+/**
+ * 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 declare function quoteForTimestamp(options: QuoteForTimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyVerifiedPriceArguments {
+    price: TransactionArgument;
+}
+export interface DestroyVerifiedPriceOptions {
+    package?: string;
+    arguments: DestroyVerifiedPriceArguments | [
+        price: TransactionArgument
+    ];
+}
+/**
+ * Consumes a verified historical price proof when no downstream consumer needs to
+ * keep using it in the PTB.
+ */
+export declare function destroyVerifiedPrice(options: DestroyVerifiedPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CollectVerifiedPriceArguments {
+    collector: TransactionArgument;
+    price: TransactionArgument;
+}
+export interface CollectVerifiedPriceOptions {
+    package?: string;
+    arguments: CollectVerifiedPriceArguments | [
+        collector: TransactionArgument,
+        price: TransactionArgument
+    ];
+}
+/**
+ * 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 declare function collectVerifiedPrice(options: CollectVerifiedPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetFeedArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    sources: RawTransactionArgument<Array<number | bigint>>;
+    method: RawTransactionArgument<string>;
+    maxAgeMs: RawTransactionArgument<number | bigint>;
+}
+export interface SetFeedOptions {
+    package?: string;
+    arguments: SetFeedArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        sources: RawTransactionArgument<Array<number | bigint>>,
+        method: RawTransactionArgument<string>,
+        maxAgeMs: RawTransactionArgument<number | bigint>
+    ];
+}
+/** Admin Funs */
+export declare function setFeed(options: SetFeedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetPerpFeedArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    sources: RawTransactionArgument<Array<number | bigint>>;
+    method: RawTransactionArgument<string>;
+    maxAgeMs: RawTransactionArgument<number | bigint>;
+    maxConfidenceBps: RawTransactionArgument<number | bigint>;
+    maxSourceDeviationBps: RawTransactionArgument<number | bigint>;
+    minSources: RawTransactionArgument<number>;
+}
+export interface SetPerpFeedOptions {
+    package?: string;
+    arguments: SetPerpFeedArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        sources: RawTransactionArgument<Array<number | bigint>>,
+        method: RawTransactionArgument<string>,
+        maxAgeMs: RawTransactionArgument<number | bigint>,
+        maxConfidenceBps: RawTransactionArgument<number | bigint>,
+        maxSourceDeviationBps: RawTransactionArgument<number | bigint>,
+        minSources: RawTransactionArgument<number>
+    ];
+}
+export declare function setPerpFeed(options: SetPerpFeedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveFeedArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+}
+export interface RemoveFeedOptions {
+    package?: string;
+    arguments: RemoveFeedArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>
+    ];
+}
+export declare function removeFeed(options: RemoveFeedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewBatchPayloadOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Getter Funs */
+export declare function newBatchPayload(options?: NewBatchPayloadOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewBatchItemArguments {
+    symbol: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    sources: RawTransactionArgument<Array<number | bigint>>;
+    method: RawTransactionArgument<string>;
+    priceTimestampMs: RawTransactionArgument<number | bigint>;
+    priceN: RawTransactionArgument<number | bigint>;
+    priceScale: RawTransactionArgument<number | bigint>;
+    confidenceN: RawTransactionArgument<number | bigint>;
+    confidenceScale: RawTransactionArgument<number | bigint>;
+    maxSourceDeviationBps: RawTransactionArgument<number | bigint>;
+    numSources: RawTransactionArgument<number>;
+}
+export interface NewBatchItemOptions {
+    package?: string;
+    arguments: NewBatchItemArguments | [
+        symbol: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        sources: RawTransactionArgument<Array<number | bigint>>,
+        method: RawTransactionArgument<string>,
+        priceTimestampMs: RawTransactionArgument<number | bigint>,
+        priceN: RawTransactionArgument<number | bigint>,
+        priceScale: RawTransactionArgument<number | bigint>,
+        confidenceN: RawTransactionArgument<number | bigint>,
+        confidenceScale: RawTransactionArgument<number | bigint>,
+        maxSourceDeviationBps: RawTransactionArgument<number | bigint>,
+        numSources: RawTransactionArgument<number>
+    ];
+}
+export declare function newBatchItem(options: NewBatchItemOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PushBatchItemArguments {
+    payload: TransactionArgument;
+    item: TransactionArgument;
+}
+export interface PushBatchItemOptions {
+    package?: string;
+    arguments: PushBatchItemArguments | [
+        payload: TransactionArgument,
+        item: TransactionArgument
+    ];
+}
+export declare function pushBatchItem(options: PushBatchItemOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FeedConfigArguments {
+    config: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+}
+export interface FeedConfigOptions {
+    package?: string;
+    arguments: FeedConfigArguments | [
+        config: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>
+    ];
+}
+export declare function feedConfig(options: FeedConfigOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchPriceIntentOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+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?: [
+    ];
+}
+export declare function maxBatchSize(options?: MaxBatchSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemsArguments {
+    payload: TransactionArgument;
+}
+export interface BatchItemsOptions {
+    package?: string;
+    arguments: BatchItemsArguments | [
+        payload: TransactionArgument
+    ];
+}
+export declare function batchItems(options: BatchItemsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemSymbolArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemSymbolOptions {
+    package?: string;
+    arguments: BatchItemSymbolArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemSymbol(options: BatchItemSymbolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemTickerArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemTickerOptions {
+    package?: string;
+    arguments: BatchItemTickerArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemTicker(options: BatchItemTickerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemSourcesArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemSourcesOptions {
+    package?: string;
+    arguments: BatchItemSourcesArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemSources(options: BatchItemSourcesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemMethodArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemMethodOptions {
+    package?: string;
+    arguments: BatchItemMethodArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemMethod(options: BatchItemMethodOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemPriceTimestampMsArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemPriceTimestampMsOptions {
+    package?: string;
+    arguments: BatchItemPriceTimestampMsArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemPriceTimestampMs(options: BatchItemPriceTimestampMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemPriceNArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemPriceNOptions {
+    package?: string;
+    arguments: BatchItemPriceNArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemPriceN(options: BatchItemPriceNOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemPriceScaleArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemPriceScaleOptions {
+    package?: string;
+    arguments: BatchItemPriceScaleArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemPriceScale(options: BatchItemPriceScaleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemConfidenceNArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemConfidenceNOptions {
+    package?: string;
+    arguments: BatchItemConfidenceNArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemConfidenceN(options: BatchItemConfidenceNOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemConfidenceScaleArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemConfidenceScaleOptions {
+    package?: string;
+    arguments: BatchItemConfidenceScaleArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemConfidenceScale(options: BatchItemConfidenceScaleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemMaxSourceDeviationBpsArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemMaxSourceDeviationBpsOptions {
+    package?: string;
+    arguments: BatchItemMaxSourceDeviationBpsArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemMaxSourceDeviationBps(options: BatchItemMaxSourceDeviationBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchItemNumSourcesArguments {
+    item: TransactionArgument;
+}
+export interface BatchItemNumSourcesOptions {
+    package?: string;
+    arguments: BatchItemNumSourcesArguments | [
+        item: TransactionArgument
+    ];
+}
+export declare function batchItemNumSources(options: BatchItemNumSourcesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedSymbolArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedSymbolOptions {
+    package?: string;
+    arguments: VerifiedSymbolArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedSymbol(options: VerifiedSymbolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedTickerArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedTickerOptions {
+    package?: string;
+    arguments: VerifiedTickerArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedTicker(options: VerifiedTickerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedSourcesArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedSourcesOptions {
+    package?: string;
+    arguments: VerifiedSourcesArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedSources(options: VerifiedSourcesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedMethodArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedMethodOptions {
+    package?: string;
+    arguments: VerifiedMethodArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedMethod(options: VerifiedMethodOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedPriceTimestampMsArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedPriceTimestampMsOptions {
+    package?: string;
+    arguments: VerifiedPriceTimestampMsArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedPriceTimestampMs(options: VerifiedPriceTimestampMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedPriceArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedPriceOptions {
+    package?: string;
+    arguments: VerifiedPriceArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedPrice(options: VerifiedPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedPriceScaledArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedPriceScaledOptions {
+    package?: string;
+    arguments: VerifiedPriceScaledArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedPriceScaled(options: VerifiedPriceScaledOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedPriceNArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedPriceNOptions {
+    package?: string;
+    arguments: VerifiedPriceNArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedPriceN(options: VerifiedPriceNOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedPriceScaleArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedPriceScaleOptions {
+    package?: string;
+    arguments: VerifiedPriceScaleArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedPriceScale(options: VerifiedPriceScaleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedConfidenceNArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedConfidenceNOptions {
+    package?: string;
+    arguments: VerifiedConfidenceNArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedConfidenceN(options: VerifiedConfidenceNOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedConfidenceScaleArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedConfidenceScaleOptions {
+    package?: string;
+    arguments: VerifiedConfidenceScaleArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedConfidenceScale(options: VerifiedConfidenceScaleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedMaxSourceDeviationBpsArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedMaxSourceDeviationBpsOptions {
+    package?: string;
+    arguments: VerifiedMaxSourceDeviationBpsArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedMaxSourceDeviationBps(options: VerifiedMaxSourceDeviationBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedNumSourcesArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedNumSourcesOptions {
+    package?: string;
+    arguments: VerifiedNumSourcesArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedNumSources(options: VerifiedNumSourcesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface VerifiedSignedTimestampMsArguments {
+    price: TransactionArgument;
+}
+export interface VerifiedSignedTimestampMsOptions {
+    package?: string;
+    arguments: VerifiedSignedTimestampMsArguments | [
+        price: TransactionArgument
+    ];
+}
+export declare function verifiedSignedTimestampMs(options: VerifiedSignedTimestampMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceBinanceSpotOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceBinanceSpot(options?: SourceBinanceSpotOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceBinanceUsdmPerpWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceBinanceUsdmPerpWs(options?: SourceBinanceUsdmPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceBybitLinearPerpWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceBybitLinearPerpWs(options?: SourceBybitLinearPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceGateioUsdtPerpWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceGateioUsdtPerpWs(options?: SourceGateioUsdtPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceGataUsdtPerpWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceGataUsdtPerpWs(options?: SourceGataUsdtPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceBybitSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceBybitSpotWs(options?: SourceBybitSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceXstockEquityRestOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceXstockEquityRest(options?: SourceXstockEquityRestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceOkxSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceOkxSpotWs(options?: SourceOkxSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceHyperliquidPerpWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceHyperliquidPerpWs(options?: SourceHyperliquidPerpWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceGateioSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceGateioSpotWs(options?: SourceGateioSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceKrakenSpotWsOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function sourceKrakenSpotWs(options?: SourceKrakenSpotWsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MethodDirectOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function methodDirect(options?: MethodDirectOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MethodMedianOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function methodMedian(options?: MethodMedianOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MethodConfidenceOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function methodConfidence(options?: MethodConfidenceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsSupportedSourceArguments {
+    source: RawTransactionArgument<number | bigint>;
+}
+export interface IsSupportedSourceOptions {
+    package?: string;
+    arguments: IsSupportedSourceArguments | [
+        source: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function isSupportedSource(options: IsSupportedSourceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsPerpSourceArguments {
+    source: RawTransactionArgument<number | bigint>;
+}
+export interface IsPerpSourceOptions {
+    package?: string;
+    arguments: IsPerpSourceArguments | [
+        source: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function isPerpSource(options: IsPerpSourceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsSupportedMethodArguments {
+    method: RawTransactionArgument<string>;
+}
+export interface IsSupportedMethodOptions {
+    package?: string;
+    arguments: IsSupportedMethodArguments | [
+        method: RawTransactionArgument<string>
+    ];
+}
+export declare function isSupportedMethod(options: IsSupportedMethodOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsPerpMethodArguments {
+    method: RawTransactionArgument<string>;
+}
+export interface IsPerpMethodOptions {
+    package?: string;
+    arguments: IsPerpMethodArguments | [
+        method: RawTransactionArgument<string>
+    ];
+}
+export declare function isPerpMethod(options: IsPerpMethodOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SourceFromNameArguments {
+    name: RawTransactionArgument<string>;
+}
+export interface SourceFromNameOptions {
+    package?: string;
+    arguments: SourceFromNameArguments | [
+        name: RawTransactionArgument<string>
+    ];
+}
+export declare function sourceFromName(options: SourceFromNameOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MethodFromNameArguments {
+    name: RawTransactionArgument<string>;
+}
+export interface MethodFromNameOptions {
+    package?: string;
+    arguments: MethodFromNameArguments | [
+        name: RawTransactionArgument<string>
+    ];
+}
+export declare function methodFromName(options: MethodFromNameOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SignedTsHwmArguments {
+    config: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+}
+export interface SignedTsHwmOptions {
+    package?: string;
+    arguments: SignedTsHwmArguments | [
+        config: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>
+    ];
+}
+/**
+ * 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 declare function signedTsHwm(options: SignedTsHwmOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;