@waterx/sdk 2.4.1 → 3.0.0

package/dist/src/{prediction/generated → generated}/waterx_prediction/waterx_prediction.d.ts

@@ -3,9 +3,75 @@
  **************************************************************/
 import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-export declare const MarketRegistry: MoveStruct<any, any>;
+export declare const MarketRegistry: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** One shared settlement pool for all markets using coin type `T`. */
+    balance: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    /** Exact market lookup: external market id bytes -> linked-table key. */
+    market_id_map: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    unresolved_markets: MoveStruct<any, any>;
+    resolved_markets: MoveStruct<any, any>;
+    /** Set of market keys where new opens are blocked. Presence = paused. */
+    paused_markets: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    /** Pending open and close orders waiting for broker/keeper execution. */
+    orders: MoveStruct<any, any>;
+    /** Filled positions with active Polymarket exposure. */
+    positions: MoveStruct<any, any>;
+    /**
+     * Filled order id -> filled position id. Split positions are independent positions
+     * and are not indexed here.
+     */
+    position_id_by_order: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    /**
+     * Reverse index for cleaning `position_id_by_order` when the filled position is
+     * claimed or closed.
+     */
+    order_id_by_position: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    next_order_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    next_position_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    next_market_key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Minimum time after order placement before user self-cancel is allowed. */
+    order_cancel_cooldown_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Floor balance that `admin_withdraw` must respect. */
+    min_reserve: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/prediction::waterx_prediction::MarketRegistry<phantom T>">;
 export declare const Market: MoveStruct<any, any>;
-export declare const MarketPointer: MoveStruct<any, any>;
+export declare const MarketPointer: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    resolved: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/prediction::waterx_prediction::MarketPointer">;
+export declare const PriceSettlement: MoveStruct<{
+    /** Oracle ticker to read, e.g. "BTCUSD". */
+    settle_ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    /**
+     * Exact snapshot timestamp to read (must already be registered on-chain via
+     * `oracle::register_price_at_timestamp`).
+     */
+    settle_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** 1e9-scaled `Float` raw value the price is compared against. */
+    threshold: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    /** One of CMP_GT / CMP_GTE / CMP_LT / CMP_LTE. */
+    comparison: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/prediction::waterx_prediction::PriceSettlement">;
+export declare const PriceSettlementKey: MoveStruct<{
+    market_id: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/prediction::waterx_prediction::PriceSettlementKey">;
 export interface CreateMarketRegistryArguments {
     _: RawTransactionArgument<string>;
 }
@@ -141,6 +207,41 @@ export interface RequestCloseOptions {
  * if the market has already resolved.
  */
 export declare function requestClose(options: RequestCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestPartialCloseArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    closeShares: RawTransactionArgument<number | bigint>;
+    minProceeds: RawTransactionArgument<number | bigint>;
+    expiryTs: RawTransactionArgument<number | bigint>;
+}
+export interface RequestPartialCloseOptions {
+    package?: string;
+    arguments: RequestPartialCloseArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        closeShares: RawTransactionArgument<number | bigint>,
+        minProceeds: RawTransactionArgument<number | bigint>,
+        expiryTs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed partial close. Splits `close_shares` off `position_id` into a new
+ * same-account position and runs the close flow on it; the remainder stays `Open`
+ * under `position_id`. Auth `PERM_REQUEST_CLOSE` — value stays in the account, so
+ * unlike `split_position` it is not transfer-equivalent. Emits a dedicated
+ * `PartialCloseRequested` plus `PositionSplit` (from == to) and `CloseRequested`
+ * for the new position. Returns the new PendingClose position id.
+ */
+export declare function requestPartialClose(options: RequestPartialCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface SelfCancelCloseArguments {
     globalConfig: RawTransactionArgument<string>;
     marketRegistry: RawTransactionArgument<string>;
@@ -514,6 +615,65 @@ export interface ResolveMarketOptions {
 }
 /** Keeper records the market outcome. Aborts if already resolved. */
 export declare function resolveMarket(options: ResolveMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetPriceSettlementArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+    settleTicker: RawTransactionArgument<string>;
+    settleTimestampMs: RawTransactionArgument<number | bigint>;
+    threshold: RawTransactionArgument<number | bigint>;
+    comparison: RawTransactionArgument<number>;
+}
+export interface SetPriceSettlementOptions {
+    package?: string;
+    arguments: SetPriceSettlementArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>,
+        settleTicker: RawTransactionArgument<string>,
+        settleTimestampMs: RawTransactionArgument<number | bigint>,
+        threshold: RawTransactionArgument<number | bigint>,
+        comparison: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin pre-commits the price-settlement config for a market. Stored as a dynamic
+ * field on the registry; re-calling overwrites (until resolved).
+ */
+export declare function setPriceSettlement(options: SetPriceSettlementOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolveWithOracleArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface ResolveWithOracleOptions {
+    package?: string;
+    arguments: ResolveWithOracleArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper resolves a price-settled market from an on-chain oracle snapshot. The
+ * price at `settle_timestamp_ms` must already be registered on the oracle (the
+ * keeper PTB submits `waterx_rule::quote_for_timestamp` →
+ * `oracle::register_price_at_timestamp` before calling this). The outcome is
+ * derived from the pre-committed threshold + comparison, so the keeper cannot
+ * influence the result beyond triggering it. Aborts if no settlement is set or the
+ * market is already resolved.
+ */
+export declare function resolveWithOracle(options: ResolveWithOracleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface PauseMarketArguments {
     _: RawTransactionArgument<string>;
     marketRegistry: RawTransactionArgument<string>;

package/dist/src/{prediction/generated → generated}/waterx_prediction/waterx_prediction.js

@@ -60,6 +60,22 @@ export const MarketPointer = new MoveStruct({ name: `${$moduleName}::MarketPoint
         key: bcs.u64(),
         resolved: bcs.bool()
     } });
+export const PriceSettlement = new MoveStruct({ name: `${$moduleName}::PriceSettlement`, fields: {
+        /** Oracle ticker to read, e.g. "BTCUSD". */
+        settle_ticker: bcs.string(),
+        /**
+         * Exact snapshot timestamp to read (must already be registered on-chain via
+         * `oracle::register_price_at_timestamp`).
+         */
+        settle_timestamp_ms: bcs.u64(),
+        /** 1e9-scaled `Float` raw value the price is compared against. */
+        threshold: bcs.u128(),
+        /** One of CMP_GT / CMP_GTE / CMP_LT / CMP_LTE. */
+        comparison: bcs.u8()
+    } });
+export const PriceSettlementKey = new MoveStruct({ name: `${$moduleName}::PriceSettlementKey`, fields: {
+        market_id: bcs.vector(bcs.u8())
+    } });
 /**
  * Admin-only: spin up the shared market registry object for coin type `T`. All
  * markets for this coin type should settle through this object.
@@ -179,6 +195,36 @@ export function requestClose(options) {
         typeArguments: options.typeArguments
     });
 }
+/**
+ * Account-backed partial close. Splits `close_shares` off `position_id` into a new
+ * same-account position and runs the close flow on it; the remainder stays `Open`
+ * under `position_id`. Auth `PERM_REQUEST_CLOSE` — value stays in the account, so
+ * unlike `split_position` it is not transfer-equivalent. Emits a dedicated
+ * `PartialCloseRequested` plus `PositionSplit` (from == to) and `CloseRequested`
+ * for the new position. Returns the new PendingClose position id.
+ */
+export function requestPartialClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId", "closeShares", "minProceeds", "expiryTs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'request_partial_close',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 /** Account-backed PendingClose rescue. Reverts the position to Open. */
 export function selfCancelClose(options) {
     const packageAddress = options.package ?? '@waterx/prediction';
@@ -516,6 +562,59 @@ export function resolveMarket(options) {
         typeArguments: options.typeArguments
     });
 }
+/**
+ * Admin pre-commits the price-settlement config for a market. Stored as a dynamic
+ * field on the registry; re-calling overwrites (until resolved).
+ */
+export function setPriceSettlement(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<u8>',
+        '0x1::string::String',
+        'u64',
+        'u128',
+        'u8',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["_", "marketRegistry", "marketId", "settleTicker", "settleTimestampMs", "threshold", "comparison"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'set_price_settlement',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper resolves a price-settled market from an on-chain oracle snapshot. The
+ * price at `settle_timestamp_ms` must already be registered on the oracle (the
+ * keeper PTB submits `waterx_rule::quote_for_timestamp` →
+ * `oracle::register_price_at_timestamp` before calling this). The outcome is
+ * derived from the pre-committed threshold + comparison, so the keeper cannot
+ * influence the result beyond triggering it. Aborts if no settlement is set or the
+ * market is already resolved.
+ */
+export function resolveWithOracle(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'vector<u8>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "oracle", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolve_with_oracle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
 /**
  * Admin pauses new opens for a specific market. Existing positions unaffected. If
  * the market does not exist yet, this creates market metadata and emits

package/dist/src/generated/waterx_pyth_rule/pyth_rule.d.ts

@@ -35,6 +35,25 @@ export declare const Config: MoveStruct<{
         }, string>;
     }, "0x2::vec_map::VecMap<string, u64>">;
 }, "@waterx/pyth-rule::pyth_rule::Config">;
+export declare const MaxConfBpsKey: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/pyth-rule::pyth_rule::MaxConfBpsKey">;
+export declare const MaxConfBpsConfig: MoveStruct<{
+    /** Default max confidence band (bps of price) for symbols without an override. */
+    default_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Per-symbol overrides. */
+    by_symbol: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: string;
+        }[], Iterable<{
+            key: string;
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, u64>">;
+}, "@waterx/pyth-rule::pyth_rule::MaxConfBpsConfig">;
 export interface FeedArguments {
     collector: TransactionArgument;
     config: RawTransactionArgument<string>;
@@ -88,3 +107,86 @@ export interface SetToleranceSecOptions {
     ];
 }
 export declare function setToleranceSec(options: SetToleranceSecOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetDefaultMaxConfidenceBpsArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    defaultBps: RawTransactionArgument<number | bigint>;
+}
+export interface SetDefaultMaxConfidenceBpsOptions {
+    package?: string;
+    arguments: SetDefaultMaxConfidenceBpsArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        defaultBps: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Sets the default confidence gate (bps of price) applied to symbols without an
+ * explicit override. `10_000` = 100%. Lazily creates the confidence-gate DF.
+ */
+export declare function setDefaultMaxConfidenceBps(options: SetDefaultMaxConfidenceBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetSymbolMaxConfidenceBpsArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    bps: RawTransactionArgument<number | bigint>;
+}
+export interface SetSymbolMaxConfidenceBpsOptions {
+    package?: string;
+    arguments: SetSymbolMaxConfidenceBpsArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        bps: RawTransactionArgument<number | bigint>
+    ];
+}
+/** Sets a per-symbol confidence gate (bps of price), overriding the default. */
+export declare function setSymbolMaxConfidenceBps(options: SetSymbolMaxConfidenceBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsetSymbolMaxConfidenceBpsArguments {
+    config: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+}
+export interface UnsetSymbolMaxConfidenceBpsOptions {
+    package?: string;
+    arguments: UnsetSymbolMaxConfidenceBpsArguments | [
+        config: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes a per-symbol confidence override (no-op if absent); the symbol then
+ * falls back to the default.
+ */
+export declare function unsetSymbolMaxConfidenceBps(options: UnsetSymbolMaxConfidenceBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MaxConfidenceBpsArguments {
+    config: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+}
+export interface MaxConfidenceBpsOptions {
+    package?: string;
+    arguments: MaxConfidenceBpsArguments | [
+        config: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The effective confidence gate (bps of price) `feed` applies for `symbol`:
+ * per-symbol override → default → `DEFAULT_MAX_CONFIDENCE_BPS`.
+ */
+export declare function maxConfidenceBps(options: MaxConfidenceBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DefaultMaxConfidenceBpsArguments {
+    config: RawTransactionArgument<string>;
+}
+export interface DefaultMaxConfidenceBpsOptions {
+    package?: string;
+    arguments: DefaultMaxConfidenceBpsArguments | [
+        config: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The configured default confidence gate, or `DEFAULT_MAX_CONFIDENCE_BPS` if
+ * unset.
+ */
+export declare function defaultMaxConfidenceBps(options: DefaultMaxConfidenceBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/src/generated/waterx_pyth_rule/pyth_rule.js

@@ -15,6 +15,15 @@ export const Config = new MoveStruct({ name: `${$moduleName}::Config`, fields: {
         /** Per-ticker timestamp tolerance in seconds. Falls back to DEFAULT_TOLERANCE_SEC. */
         tolerance_sec_map: vec_map.VecMap(bcs.string(), bcs.u64())
     } });
+export const MaxConfBpsKey = new MoveStruct({ name: `${$moduleName}::MaxConfBpsKey`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const MaxConfBpsConfig = new MoveStruct({ name: `${$moduleName}::MaxConfBpsConfig`, fields: {
+        /** Default max confidence band (bps of price) for symbols without an override. */
+        default_bps: bcs.u64(),
+        /** Per-symbol overrides. */
+        by_symbol: vec_map.VecMap(bcs.string(), bcs.u64())
+    } });
 /**
  * Reads a Pyth price for `collector.symbol()` and feeds it. Drops the value
  * (records `none`) if the on-chain timestamp diverges from the Pyth feed timestamp
@@ -69,3 +78,93 @@ export function setToleranceSec(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+/**
+ * Sets the default confidence gate (bps of price) applied to symbols without an
+ * explicit override. `10_000` = 100%. Lazily creates the confidence-gate DF.
+ */
+export function setDefaultMaxConfidenceBps(options) {
+    const packageAddress = options.package ?? '@waterx/pyth-rule';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["config", "Cap", "defaultBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'pyth_rule',
+        function: 'set_default_max_confidence_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Sets a per-symbol confidence gate (bps of price), overriding the default. */
+export function setSymbolMaxConfidenceBps(options) {
+    const packageAddress = options.package ?? '@waterx/pyth-rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        'u64'
+    ];
+    const parameterNames = ["config", "Cap", "symbol", "bps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'pyth_rule',
+        function: 'set_symbol_max_confidence_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Removes a per-symbol confidence override (no-op if absent); the symbol then
+ * falls back to the default.
+ */
+export function unsetSymbolMaxConfidenceBps(options) {
+    const packageAddress = options.package ?? '@waterx/pyth-rule';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["config", "Cap", "symbol"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'pyth_rule',
+        function: 'unset_symbol_max_confidence_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * The effective confidence gate (bps of price) `feed` applies for `symbol`:
+ * per-symbol override → default → `DEFAULT_MAX_CONFIDENCE_BPS`.
+ */
+export function maxConfidenceBps(options) {
+    const packageAddress = options.package ?? '@waterx/pyth-rule';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["config", "symbol"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'pyth_rule',
+        function: 'max_confidence_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * The configured default confidence gate, or `DEFAULT_MAX_CONFIDENCE_BPS` if
+ * unset.
+ */
+export function defaultMaxConfidenceBps(options) {
+    const packageAddress = options.package ?? '@waterx/pyth-rule';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'pyth_rule',
+        function: 'default_max_confidence_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/src/generated/waterx_supra_rule/supra_rule.d.ts

@@ -15,7 +15,7 @@
  * The canonical kill switch is `oracle::set_rule_weight<SupraRule>(.., 0)`.
  */
 import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
-import { type Transaction } from '@mysten/sui/transactions';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 export declare const SupraRule: MoveStruct<{
     dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
 }, "@waterx/supra-rule::supra_rule::SupraRule">;
@@ -56,16 +56,16 @@ export declare const SupraToleranceSet: MoveStruct<{
     tolerance_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@waterx/supra-rule::supra_rule::SupraToleranceSet">;
 export interface FeedArguments {
-    collector: RawTransactionArgument<string>;
+    collector: TransactionArgument;
     config: RawTransactionArgument<string>;
-    oracleHolder: RawTransactionArgument<string>;
+    oracleHolder: TransactionArgument;
 }
 export interface FeedOptions {
     package?: string;
     arguments: FeedArguments | [
-        collector: RawTransactionArgument<string>,
+        collector: TransactionArgument,
         config: RawTransactionArgument<string>,
-        oracleHolder: RawTransactionArgument<string>
+        oracleHolder: TransactionArgument
     ];
 }
 /**

package/dist/src/generated/waterx_supra_rule/supra_rule.js

@@ -17,7 +17,6 @@
 import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
 import { bcs } from '@mysten/sui/bcs';
 import * as vec_map from "./deps/sui/vec_map.js";
-import * as vec_map_1 from "./deps/sui/vec_map.js";
 const $moduleName = '@waterx/supra-rule::supra_rule';
 export const SupraRule = new MoveStruct({ name: `${$moduleName}::SupraRule`, fields: {
         dummy_field: bcs.bool()
@@ -27,7 +26,7 @@ export const Config = new MoveStruct({ name: `${$moduleName}::Config`, fields: {
         /** Oracle symbol (e.g. `b"BTC_USD".to_string()`) → Supra pair ID (`u32`). */
         pair_id_map: vec_map.VecMap(bcs.string(), bcs.u32()),
         /** Per-symbol freshness tolerance in ms. Falls back to `DEFAULT_TOLERANCE_MS`. */
-        tolerance_ms_map: vec_map_1.VecMap(bcs.string(), bcs.u64())
+        tolerance_ms_map: vec_map.VecMap(bcs.string(), bcs.u64())
     } });
 export const SupraPairIdSet = new MoveStruct({ name: `${$moduleName}::SupraPairIdSet`, fields: {
         symbol: bcs.string(),