@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,923 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const WithdrawQueue: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::WithdrawQueue">;
+export declare const WormholeRoute: MoveStruct<{
+    evm_destination_chain: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    evm_recipient: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+    evm_token: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/withdrawal-queue::withdrawal_queue::WormholeRoute">;
+export declare const NativeRoute: MoveStruct<{
+    asset_type: MoveStruct<{
+        name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    }, "std::type_name::TypeName">;
+    /**
+     * User-supplied minimum acceptable `Coin<T>` output (after the burn fee).
+     * Snapshotted into `extra_data` at withdraw time and enforced in `execute_native`,
+     * so an admin burn-fee change between enqueue and execute cannot silently reprice
+     * an already-debited withdrawal (audit M15).
+     */
+    min_output: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::NativeRoute">;
+export declare const Entry: MoveStruct<{
+    balance: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    /**
+     * Originating wxa Account whose stored `Balance<CREDIT>` produced this entry.
+     * Threaded into `vault.burn` / `bridge.burn_for_withdrawal` so the burner identity
+     * on the credit registry's personal cap, the EVM-side withdrawal id, and the
+     * partner-fee lookup all bind to the source account — not whoever calls
+     * `execute_*` (audit finding #3).
+     */
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /**
+     * Sui-side recipient from `WithdrawRequest`. Honored for Native payouts; ignored
+     * for Wormhole (EVM recipient lives in extra_data).
+     */
+    recipient: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    extra_data: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/withdrawal-queue::withdrawal_queue::Entry<phantom CREDIT>">;
+export declare const Queue: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    next_key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    entries: MoveStruct<any, any>;
+    /**
+     * Admin-managed allowlist of addresses authorized to call `execute_wormhole` /
+     * `execute_native`. Without this gate any caller could route any user's queue
+     * entry through the burn path (audit finding #3).
+     */
+    executors: MoveStruct<any, any>;
+    /**
+     * Admin-managed package-version allowlist. Every mutating public entry asserts
+     * `PACKAGE_VERSION ∈ allowed_versions`; admin uses `add_version` /
+     * `remove_version` to kill-switch a deprecated package after a contract upgrade.
+     */
+    allowed_versions: MoveStruct<any, any>;
+}, "@waterx/withdrawal-queue::withdrawal_queue::Queue<phantom CREDIT>">;
+export declare const BridgeFeeKey: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeFeeKey">;
+export declare const BridgeFeeConfig: MoveStruct<{
+    default_rate: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    }, "bucket_v2_framework::float::Float">;
+    chain_rates: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: {
+                value: string;
+            };
+        }[], Iterable<{
+            key: number;
+            value: {
+                value: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u16, bucket_v2_framework::float::Float>">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeFeeConfig">;
+export declare const BridgeMinFeeKey: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeMinFeeKey">;
+export declare const BridgeMinFeeConfig: MoveStruct<{
+    default_min_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    chain_min_fees: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: string;
+        }[], Iterable<{
+            key: number;
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u16, u64>">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeMinFeeConfig">;
+export declare const BridgeFeeUpdated: MoveStruct<{
+    /** 1e9-scaled default fee rate now in effect. */
+    fee_rate: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeFeeUpdated<phantom CREDIT>">;
+export declare const ChainBridgeFeeUpdated: MoveStruct<{
+    evm_destination_chain: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    fee_rate: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    removed: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::ChainBridgeFeeUpdated<phantom CREDIT>">;
+export declare const BridgeMinFeeUpdated: MoveStruct<{
+    min_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeMinFeeUpdated<phantom CREDIT>">;
+export declare const ChainBridgeMinFeeUpdated: MoveStruct<{
+    evm_destination_chain: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    min_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    removed: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::ChainBridgeMinFeeUpdated<phantom CREDIT>">;
+export declare const Enqueued: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    recipient: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    route_tag: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::Enqueued<phantom CREDIT>">;
+export declare const ExecutedWormhole: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    evm_destination_chain: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::ExecutedWormhole<phantom CREDIT>">;
+export declare const BridgeFeeCharged: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    evm_destination_chain: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    fee_amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::BridgeFeeCharged<phantom CREDIT>">;
+export declare const ExecutedNative: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    recipient: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::ExecutedNative<phantom CREDIT, phantom T>">;
+export declare const EntryCancelled: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    account_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    amount: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    route_tag: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::EntryCancelled<phantom CREDIT>">;
+export declare const ExecutorUpdated: MoveStruct<{
+    executor: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    added: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/withdrawal-queue::withdrawal_queue::ExecutorUpdated<phantom CREDIT>">;
+export interface PackageVersionOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function packageVersion(options?: PackageVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RouteWormholeArguments {
+    evmDestinationChain: RawTransactionArgument<number>;
+    evmRecipient: RawTransactionArgument<Array<number>>;
+    evmToken: RawTransactionArgument<Array<number>>;
+}
+export interface RouteWormholeOptions {
+    package?: string;
+    arguments: RouteWormholeArguments | [
+        evmDestinationChain: RawTransactionArgument<number>,
+        evmRecipient: RawTransactionArgument<Array<number>>,
+        evmToken: RawTransactionArgument<Array<number>>
+    ];
+}
+/** User helper: encode a Wormhole-bound route as `extra_data` bytes. */
+export declare function routeWormhole(options: RouteWormholeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RouteNativeArguments {
+    minOutput: RawTransactionArgument<number | bigint>;
+}
+export interface RouteNativeOptions {
+    package?: string;
+    arguments: RouteNativeArguments | [
+        minOutput: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * User helper: encode a Native-bound route as `extra_data` bytes. `T` is the
+ * backing asset of the destination `SingleVault<T>`. `min_output` is the minimum
+ * `Coin<T>` the user will accept after the native burn fee; `execute_native`
+ * aborts `EOutputBelowMin` if a later fee change would deliver less (audit M15).
+ * Pass 0 to opt out.
+ */
+export declare function routeNative(options: RouteNativeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateQueueArguments {
+    _: RawTransactionArgument<string>;
+}
+export interface CreateQueueOptions {
+    package?: string;
+    arguments: CreateQueueArguments | [
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Create + share a `Queue<CREDIT>`. Call once per credit type. */
+export declare function createQueue(options: CreateQueueOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddExecutorArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    executor: RawTransactionArgument<string>;
+}
+export interface AddExecutorOptions {
+    package?: string;
+    arguments: AddExecutorArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        executor: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function addExecutor(options: AddExecutorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveExecutorArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    executor: RawTransactionArgument<string>;
+}
+export interface RemoveExecutorOptions {
+    package?: string;
+    arguments: RemoveExecutorArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        executor: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function removeExecutor(options: RemoveExecutorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsExecutorArguments {
+    queue: RawTransactionArgument<string>;
+    executor: RawTransactionArgument<string>;
+}
+export interface IsExecutorOptions {
+    package?: string;
+    arguments: IsExecutorArguments | [
+        queue: RawTransactionArgument<string>,
+        executor: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isExecutor(options: IsExecutorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddVersionArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    version: RawTransactionArgument<number>;
+}
+export interface AddVersionOptions {
+    package?: string;
+    arguments: AddVersionArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        version: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: whitelist a package version. New deployments add their own version here
+ * before the upgrade so in-flight calls don't abort during the rollover window.
+ * Skips the version check itself so admin can recover from a stuck state.
+ */
+export declare function addVersion(options: AddVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveVersionArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    version: RawTransactionArgument<number>;
+}
+export interface RemoveVersionOptions {
+    package?: string;
+    arguments: RemoveVersionArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        version: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: remove a package version from the allowlist. Kill-switches the prior
+ * version after an upgrade. Skips the version check itself so admin can recover
+ * from a stuck state.
+ */
+export declare function removeVersion(options: RemoveVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetBridgeFeeArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    feeRate: RawTransactionArgument<number | bigint>;
+}
+export interface SetBridgeFeeOptions {
+    package?: string;
+    arguments: SetBridgeFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        feeRate: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: set the **default** bridge-withdrawal fee charged on the
+ * `execute_wormhole` exit for every destination chain that has no explicit
+ * per-chain override. `fee_rate` is the 1e9-scaled `Float` value (`0` disables;
+ * capped at 10% = `MAX_BRIDGE_FEE_RATE_SCALED`, rejected with `EFeeRateAboveCap`
+ * above that — audit L4). Stored in a dynamic field on `Queue.id` so it could be
+ * introduced as a package upgrade without touching the published `Queue<CREDIT>`
+ * layout. Idempotent. Mirrors the `Float`-as-`u128` public-ABI convention used by
+ * `native_custody::custody_vault::set_fee_config`.
+ */
+export declare function setBridgeFee(options: SetBridgeFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetChainBridgeFeeArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+    feeRate: RawTransactionArgument<number | bigint>;
+}
+export interface SetChainBridgeFeeOptions {
+    package?: string;
+    arguments: SetChainBridgeFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>,
+        feeRate: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: set (or overwrite) a per-chain bridge-fee override for
+ * `evm_destination_chain`. Takes precedence over `default_rate` for wormhole exits
+ * to that chain. Same `Float`-as-`u128` rate convention and 10% `EFeeRateAboveCap`
+ * ceiling as `set_bridge_fee`. To make a chain fee-free while the default is
+ * non-zero, set its override to `0` (an override of `0` is distinct from "no
+ * override" — the latter falls back to the default). Use `unset_chain_bridge_fee`
+ * to drop back to default.
+ */
+export declare function setChainBridgeFee(options: SetChainBridgeFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsetChainBridgeFeeArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+}
+export interface UnsetChainBridgeFeeOptions {
+    package?: string;
+    arguments: UnsetChainBridgeFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: drop a per-chain override so `evm_destination_chain` falls back to
+ * `default_rate`. Always emits `ChainBridgeFeeUpdated` (audit L3) with `removed`
+ * reflecting whether an override was actually present and `fee_rate` set to the
+ * resulting **effective** rate for the chain (audit L2) — i.e. the default after a
+ * real removal, so indexers don't have to cross-reference
+ * `bridge_default_fee_rate`. Functionally a no-op when no override existed.
+ */
+export declare function unsetChainBridgeFee(options: UnsetChainBridgeFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetBridgeMinFeeArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    minFee: RawTransactionArgument<number | bigint>;
+}
+export interface SetBridgeMinFeeOptions {
+    package?: string;
+    arguments: SetBridgeMinFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        minFee: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: set the **default** minimum-fee floor (absolute CREDIT units) charged on
+ * the `execute_wormhole` exit for every destination chain that has no explicit
+ * per-chain min-fee override. The charged fee is
+ * `max(ceil(rate * amount), min_fee)`, so a non-zero floor with a zero rate is a
+ * flat per-exit fee. `0` disables the floor. **No cap** (unlike the rate's 10%
+ * `MAX_BRIDGE_FEE_RATE_SCALED`): the floor is an absolute amount, so on small
+ * withdrawals it can exceed 10% of the amount by design — and if it meets/exceeds
+ * the entry amount, `execute_wormhole`'s net-zero guard aborts
+ * `EFeeConsumesEntireAmount` (recoverable via `cancel_entry`). Idempotent.
+ */
+export declare function setBridgeMinFee(options: SetBridgeMinFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetChainBridgeMinFeeArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+    minFee: RawTransactionArgument<number | bigint>;
+}
+export interface SetChainBridgeMinFeeOptions {
+    package?: string;
+    arguments: SetChainBridgeMinFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>,
+        minFee: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: set (or overwrite) a per-chain minimum-fee-floor override for
+ * `evm_destination_chain`. Takes precedence over `default_min_fee` for wormhole
+ * exits to that chain — on an axis independent of the rate override. Set its
+ * override to `0` to exempt a chain from the floor while `default_min_fee` still
+ * floors others (distinct from "no override", which falls back to the default).
+ * Use `unset_chain_bridge_min_fee` to drop back to the default. Same no-cap
+ * semantics as `set_bridge_min_fee`.
+ */
+export declare function setChainBridgeMinFee(options: SetChainBridgeMinFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsetChainBridgeMinFeeArguments {
+    queue: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+}
+export interface UnsetChainBridgeMinFeeOptions {
+    package?: string;
+    arguments: UnsetChainBridgeMinFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: drop a per-chain min-fee override so `evm_destination_chain` falls back
+ * to `default_min_fee`. Always emits `ChainBridgeMinFeeUpdated` with `removed`
+ * reflecting whether an override was actually present and `min_fee` set to the
+ * resulting **effective** floor for the chain (the default after a real removal).
+ * Functionally a no-op when no override existed.
+ */
+export declare function unsetChainBridgeMinFee(options: UnsetChainBridgeMinFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CancelEntryArguments {
+    queue: RawTransactionArgument<string>;
+    accountRegistry: RawTransactionArgument<string>;
+    request: TransactionArgument;
+    key: RawTransactionArgument<number | bigint>;
+}
+export interface CancelEntryOptions {
+    package?: string;
+    arguments: CancelEntryArguments | [
+        queue: RawTransactionArgument<string>,
+        accountRegistry: RawTransactionArgument<string>,
+        request: TransactionArgument,
+        key: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Refund a parked entry's `Balance<CREDIT>` back to the **originating wxa
+ * account** when the entry can no longer be executed — e.g. the `extra_data` body
+ * is malformed (handcrafted by the caller instead of via `route_*`), or admin has
+ * since `remove_trusted_emitter`'d the destination chain or
+ * `set_asset_deprecated`'d the native asset. Without this, such entries
+ * permanently lock both the balance and the queue slot (audit finding #5).
+ *
+ * Auth: either a registered queue keeper (`request.address() ∈  queue.executors`)
+ * OR an address authorized on the originating wxa account
+ * (`account_registry.is_account_authorized(entry.account_id,  caller, now)` —
+ * owner or non-expired delegate). The user can self-cancel without waiting for the
+ * keeper, and the keeper can clean up stale entries proactively.
+ *
+ * The refund goes to `Entry.account_id` (the originating wxa account), not
+ * `Entry.recipient` (the external destination the user picked) —
+ * `request_withdraw<CREDIT>` debited the user's account on enqueue, so the
+ * symmetric cancel re-credits that same account. The user can re-issue
+ * `request_withdraw` from the restored stored balance once the route is fixed.
+ */
+export declare function cancelEntry(options: CancelEntryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EnqueueArguments {
+    queue: RawTransactionArgument<string>;
+    registry: RawTransactionArgument<string>;
+    req: TransactionArgument;
+}
+export interface EnqueueOptions {
+    package?: string;
+    arguments: EnqueueArguments | [
+        queue: RawTransactionArgument<string>,
+        registry: RawTransactionArgument<string>,
+        req: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Consume a `WithdrawRequest<CREDIT>` registered to `WithdrawQueue` and park its
+ * balance + extra_data. Returns the assigned key. Aborts with `EUnknownRoute` if
+ * `extra_data`'s leading tag byte is not a known route.
+ */
+export declare function enqueue(options: EnqueueOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteWormholeArguments {
+    queue: RawTransactionArgument<string>;
+    key: RawTransactionArgument<number | bigint>;
+    request: TransactionArgument;
+    bridge: RawTransactionArgument<string>;
+    creditRegistry: RawTransactionArgument<string>;
+    wormholeState: RawTransactionArgument<string>;
+    wormholeFee: RawTransactionArgument<string>;
+}
+export interface ExecuteWormholeOptions {
+    package?: string;
+    arguments: ExecuteWormholeArguments | [
+        queue: RawTransactionArgument<string>,
+        key: RawTransactionArgument<number | bigint>,
+        request: TransactionArgument,
+        bridge: RawTransactionArgument<string>,
+        creditRegistry: RawTransactionArgument<string>,
+        wormholeState: RawTransactionArgument<string>,
+        wormholeFee: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Execute a queued entry via `wormhole_bridge::burn_for_withdrawal`. Peels the
+ * Wormhole route fields out of `extra_data`. Aborts with `ERouteMismatch` if the
+ * entry was not Wormhole-routed. `request.address()` must be on the queue's
+ * executor allowlist (audit finding #3); the originating `Entry.account_id` is
+ * what the burn path uses for cap accounting / withdrawal id.
+ */
+export declare function executeWormhole(options: ExecuteWormholeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteNativeArguments {
+    queue: RawTransactionArgument<string>;
+    key: RawTransactionArgument<number | bigint>;
+    request: TransactionArgument;
+    vault: RawTransactionArgument<string>;
+    creditRegistry: RawTransactionArgument<string>;
+}
+export interface ExecuteNativeOptions {
+    package?: string;
+    arguments: ExecuteNativeArguments | [
+        queue: RawTransactionArgument<string>,
+        key: RawTransactionArgument<number | bigint>,
+        request: TransactionArgument,
+        vault: RawTransactionArgument<string>,
+        creditRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Execute a queued entry via `native_custody::custody_vault::burn<T>`. Decodes the
+ * native route, verifying its `asset_type` matches `T` — if `T` was not the
+ * asset_type the user specified, aborts with `ERouteMismatch`.
+ */
+export declare function executeNative(options: ExecuteNativeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LengthArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface LengthOptions {
+    package?: string;
+    arguments: LengthArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function length(options: LengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsEmptyArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface IsEmptyOptions {
+    package?: string;
+    arguments: IsEmptyArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isEmpty(options: IsEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FrontArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface FrontOptions {
+    package?: string;
+    arguments: FrontArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function front(options: FrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ContainsArguments {
+    queue: RawTransactionArgument<string>;
+    key: RawTransactionArgument<number | bigint>;
+}
+export interface ContainsOptions {
+    package?: string;
+    arguments: ContainsArguments | [
+        queue: RawTransactionArgument<string>,
+        key: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function contains(options: ContainsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EntryArguments {
+    queue: RawTransactionArgument<string>;
+    key: RawTransactionArgument<number | bigint>;
+}
+export interface EntryOptions {
+    package?: string;
+    arguments: EntryArguments | [
+        queue: RawTransactionArgument<string>,
+        key: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function entry(options: EntryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EntryAmountArguments {
+    entry: TransactionArgument;
+}
+export interface EntryAmountOptions {
+    package?: string;
+    arguments: EntryAmountArguments | [
+        entry: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function entryAmount(options: EntryAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EntryAccountIdArguments {
+    entry: TransactionArgument;
+}
+export interface EntryAccountIdOptions {
+    package?: string;
+    arguments: EntryAccountIdArguments | [
+        entry: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function entryAccountId(options: EntryAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EntryRecipientArguments {
+    entry: TransactionArgument;
+}
+export interface EntryRecipientOptions {
+    package?: string;
+    arguments: EntryRecipientArguments | [
+        entry: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function entryRecipient(options: EntryRecipientOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EntryExtraDataArguments {
+    entry: TransactionArgument;
+}
+export interface EntryExtraDataOptions {
+    package?: string;
+    arguments: EntryExtraDataArguments | [
+        entry: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function entryExtraData(options: EntryExtraDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RouteTagArguments {
+    extraData: RawTransactionArgument<Array<number>>;
+}
+export interface RouteTagOptions {
+    package?: string;
+    arguments: RouteTagArguments | [
+        extraData: RawTransactionArgument<Array<number>>
+    ];
+}
+/**
+ * Returns the leading route tag byte; aborts if `extra_data` is empty or carries
+ * an unknown tag.
+ */
+export declare function routeTag(options: RouteTagOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeFeeRateArguments {
+    queue: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+}
+export interface BridgeFeeRateOptions {
+    package?: string;
+    arguments: BridgeFeeRateArguments | [
+        queue: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * The **effective** bridge-fee rate for `evm_destination_chain` as a 1e9-scaled
+ * `u128`: the per-chain override if one is set, else the default rate, else `0`
+ * when no fee config exists. Mirrors the `Float`-as-`u128` ABI convention.
+ */
+export declare function bridgeFeeRate(options: BridgeFeeRateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeDefaultFeeRateArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface BridgeDefaultFeeRateOptions {
+    package?: string;
+    arguments: BridgeDefaultFeeRateArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * The configured **default** rate (all-chains-without-override) as a 1e9-scaled
+ * `u128`; `0` when no fee config exists.
+ */
+export declare function bridgeDefaultFeeRate(options: BridgeDefaultFeeRateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasChainBridgeFeeArguments {
+    queue: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+}
+export interface HasChainBridgeFeeOptions {
+    package?: string;
+    arguments: HasChainBridgeFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Whether `evm_destination_chain` has an explicit per-chain override (distinct
+ * from falling back to the default).
+ */
+export declare function hasChainBridgeFee(options: HasChainBridgeFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeFeeAmountArguments {
+    queue: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface BridgeFeeAmountOptions {
+    package?: string;
+    arguments: BridgeFeeAmountArguments | [
+        queue: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * The bridge fee that would be charged on a wormhole exit of `amount` CREDIT to
+ * `evm_destination_chain` —
+ * `max(ceil(effective_rate * amount),  effective_min_fee)`, or `0` when both the
+ * effective rate and floor are zero (and always `0` on `amount == 0`). NOTE: this
+ * is the _raw_ fee; it can equal or exceed `amount` (`ceil` rounding on a 1-unit
+ * dust entry, or a min-fee floor larger than the entry), in which case
+ * `execute_wormhole` would abort the net-zero guard. SDKs surfacing an "estimated
+ * fee" should gate on `would_execute_wormhole` (audit L1).
+ */
+export declare function bridgeFeeAmount(options: BridgeFeeAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WouldExecuteWormholeArguments {
+    queue: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface WouldExecuteWormholeOptions {
+    package?: string;
+    arguments: WouldExecuteWormholeArguments | [
+        queue: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Whether `execute_wormhole` would clear the net-zero guard for an exit of
+ * `amount` to `evm_destination_chain` — i.e. a strictly positive amount remains
+ * after the fee. `false` ⇒ `execute_wormhole` would abort
+ * `EFeeConsumesEntireAmount` (and `amount == 0` is also `false`). SDKs should gate
+ * "estimated fee" UI on this rather than `bridge_fee_amount` alone (audit L1).
+ */
+export declare function wouldExecuteWormhole(options: WouldExecuteWormholeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeChainRatesArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface BridgeChainRatesOptions {
+    package?: string;
+    arguments: BridgeChainRatesArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Enumerate the per-chain overrides as parallel vectors of
+ * `(evm_destination_chain, 1e9-scaled rate)`, in insertion order. Empty when no
+ * overrides are set (or no fee config exists). The default rate is separate — see
+ * `bridge_default_fee_rate` (audit N1). Lets off-chain config tooling discover
+ * which chains carry overrides without probing every chain id.
+ */
+export declare function bridgeChainRates(options: BridgeChainRatesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeMinFeeArguments {
+    queue: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+}
+export interface BridgeMinFeeOptions {
+    package?: string;
+    arguments: BridgeMinFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * The **effective** minimum-fee floor (absolute CREDIT units) for
+ * `evm_destination_chain`: the per-chain override if one is set, else the default
+ * floor, else `0` when no fee config exists.
+ */
+export declare function bridgeMinFee(options: BridgeMinFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeDefaultMinFeeArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface BridgeDefaultMinFeeOptions {
+    package?: string;
+    arguments: BridgeDefaultMinFeeArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * The configured **default** minimum-fee floor (all-chains-without-override) in
+ * CREDIT units; `0` when no fee config exists.
+ */
+export declare function bridgeDefaultMinFee(options: BridgeDefaultMinFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasChainBridgeMinFeeArguments {
+    queue: RawTransactionArgument<string>;
+    evmDestinationChain: RawTransactionArgument<number>;
+}
+export interface HasChainBridgeMinFeeOptions {
+    package?: string;
+    arguments: HasChainBridgeMinFeeArguments | [
+        queue: RawTransactionArgument<string>,
+        evmDestinationChain: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Whether `evm_destination_chain` has an explicit per-chain min-fee override
+ * (distinct from falling back to the default floor).
+ */
+export declare function hasChainBridgeMinFee(options: HasChainBridgeMinFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BridgeChainMinFeesArguments {
+    queue: RawTransactionArgument<string>;
+}
+export interface BridgeChainMinFeesOptions {
+    package?: string;
+    arguments: BridgeChainMinFeesArguments | [
+        queue: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Enumerate the per-chain min-fee overrides as parallel vectors of
+ * `(evm_destination_chain, min_fee)`, in insertion order. Empty when none are set
+ * (or no fee config exists). The default floor is separate — see
+ * `bridge_default_min_fee`. Lets off-chain config tooling discover which chains
+ * carry min-fee overrides without probing every chain id.
+ */
+export declare function bridgeChainMinFees(options: BridgeChainMinFeesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;