@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,965 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorUpdated = exports.EntryCancelled = exports.ExecutedNative = exports.BridgeFeeCharged = exports.ExecutedWormhole = exports.Enqueued = exports.ChainBridgeMinFeeUpdated = exports.BridgeMinFeeUpdated = exports.ChainBridgeFeeUpdated = exports.BridgeFeeUpdated = exports.BridgeMinFeeConfig = exports.BridgeMinFeeKey = exports.BridgeFeeConfig = exports.BridgeFeeKey = exports.Queue = exports.Entry = exports.NativeRoute = exports.WormholeRoute = exports.WithdrawQueue = void 0;
+exports.packageVersion = packageVersion;
+exports.routeWormhole = routeWormhole;
+exports.routeNative = routeNative;
+exports.createQueue = createQueue;
+exports.addExecutor = addExecutor;
+exports.removeExecutor = removeExecutor;
+exports.isExecutor = isExecutor;
+exports.addVersion = addVersion;
+exports.removeVersion = removeVersion;
+exports.setBridgeFee = setBridgeFee;
+exports.setChainBridgeFee = setChainBridgeFee;
+exports.unsetChainBridgeFee = unsetChainBridgeFee;
+exports.setBridgeMinFee = setBridgeMinFee;
+exports.setChainBridgeMinFee = setChainBridgeMinFee;
+exports.unsetChainBridgeMinFee = unsetChainBridgeMinFee;
+exports.cancelEntry = cancelEntry;
+exports.enqueue = enqueue;
+exports.executeWormhole = executeWormhole;
+exports.executeNative = executeNative;
+exports.length = length;
+exports.isEmpty = isEmpty;
+exports.front = front;
+exports.contains = contains;
+exports.entry = entry;
+exports.entryAmount = entryAmount;
+exports.entryAccountId = entryAccountId;
+exports.entryRecipient = entryRecipient;
+exports.entryExtraData = entryExtraData;
+exports.routeTag = routeTag;
+exports.bridgeFeeRate = bridgeFeeRate;
+exports.bridgeDefaultFeeRate = bridgeDefaultFeeRate;
+exports.hasChainBridgeFee = hasChainBridgeFee;
+exports.bridgeFeeAmount = bridgeFeeAmount;
+exports.wouldExecuteWormhole = wouldExecuteWormhole;
+exports.bridgeChainRates = bridgeChainRates;
+exports.bridgeMinFee = bridgeMinFee;
+exports.bridgeDefaultMinFee = bridgeDefaultMinFee;
+exports.hasChainBridgeMinFee = hasChainBridgeMinFee;
+exports.bridgeChainMinFees = bridgeChainMinFees;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const type_name = __importStar(require("./deps/std/type_name.js"));
+const balance = __importStar(require("./deps/sui/balance.js"));
+const linked_table = __importStar(require("./deps/bucket_v2_framework/linked_table.js"));
+const vec_set = __importStar(require("./deps/sui/vec_set.js"));
+const float = __importStar(require("./deps/bucket_v2_framework/float.js"));
+const vec_map = __importStar(require("./deps/sui/vec_map.js"));
+const $moduleName = '@waterx/withdrawal-queue::withdrawal_queue';
+exports.WithdrawQueue = new index_ts_1.MoveStruct({ name: `${$moduleName}::WithdrawQueue`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.WormholeRoute = new index_ts_1.MoveStruct({ name: `${$moduleName}::WormholeRoute`, fields: {
+        evm_destination_chain: bcs_1.bcs.u16(),
+        evm_recipient: bcs_1.bcs.vector(bcs_1.bcs.u8()),
+        evm_token: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
+exports.NativeRoute = new index_ts_1.MoveStruct({ name: `${$moduleName}::NativeRoute`, fields: {
+        asset_type: 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: bcs_1.bcs.u64()
+    } });
+exports.Entry = new index_ts_1.MoveStruct({ name: `${$moduleName}::Entry<phantom CREDIT>`, fields: {
+        balance: balance.Balance,
+        /**
+         * 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: bcs_1.bcs.Address,
+        /**
+         * Sui-side recipient from `WithdrawRequest`. Honored for Native payouts; ignored
+         * for Wormhole (EVM recipient lives in extra_data).
+         */
+        recipient: bcs_1.bcs.Address,
+        extra_data: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
+exports.Queue = new index_ts_1.MoveStruct({ name: `${$moduleName}::Queue<phantom CREDIT>`, fields: {
+        id: bcs_1.bcs.Address,
+        next_key: bcs_1.bcs.u64(),
+        entries: linked_table.LinkedTable(bcs_1.bcs.u64()),
+        /**
+         * 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: vec_set.VecSet(bcs_1.bcs.Address),
+        /**
+         * 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: vec_set.VecSet(bcs_1.bcs.u16())
+    } });
+exports.BridgeFeeKey = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeFeeKey`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.BridgeFeeConfig = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeFeeConfig`, fields: {
+        default_rate: float.Float,
+        chain_rates: vec_map.VecMap(bcs_1.bcs.u16(), float.Float)
+    } });
+exports.BridgeMinFeeKey = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeMinFeeKey`, fields: {
+        dummy_field: bcs_1.bcs.bool()
+    } });
+exports.BridgeMinFeeConfig = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeMinFeeConfig`, fields: {
+        default_min_fee: bcs_1.bcs.u64(),
+        chain_min_fees: vec_map.VecMap(bcs_1.bcs.u16(), bcs_1.bcs.u64())
+    } });
+exports.BridgeFeeUpdated = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeFeeUpdated<phantom CREDIT>`, fields: {
+        /** 1e9-scaled default fee rate now in effect. */
+        fee_rate: bcs_1.bcs.u128()
+    } });
+exports.ChainBridgeFeeUpdated = new index_ts_1.MoveStruct({ name: `${$moduleName}::ChainBridgeFeeUpdated<phantom CREDIT>`, fields: {
+        evm_destination_chain: bcs_1.bcs.u16(),
+        fee_rate: bcs_1.bcs.u128(),
+        removed: bcs_1.bcs.bool()
+    } });
+exports.BridgeMinFeeUpdated = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeMinFeeUpdated<phantom CREDIT>`, fields: {
+        min_fee: bcs_1.bcs.u64()
+    } });
+exports.ChainBridgeMinFeeUpdated = new index_ts_1.MoveStruct({ name: `${$moduleName}::ChainBridgeMinFeeUpdated<phantom CREDIT>`, fields: {
+        evm_destination_chain: bcs_1.bcs.u16(),
+        min_fee: bcs_1.bcs.u64(),
+        removed: bcs_1.bcs.bool()
+    } });
+exports.Enqueued = new index_ts_1.MoveStruct({ name: `${$moduleName}::Enqueued<phantom CREDIT>`, fields: {
+        key: bcs_1.bcs.u64(),
+        account_id: bcs_1.bcs.Address,
+        recipient: bcs_1.bcs.Address,
+        amount: bcs_1.bcs.u64(),
+        route_tag: bcs_1.bcs.u8()
+    } });
+exports.ExecutedWormhole = new index_ts_1.MoveStruct({ name: `${$moduleName}::ExecutedWormhole<phantom CREDIT>`, fields: {
+        key: bcs_1.bcs.u64(),
+        evm_destination_chain: bcs_1.bcs.u16(),
+        amount: bcs_1.bcs.u64()
+    } });
+exports.BridgeFeeCharged = new index_ts_1.MoveStruct({ name: `${$moduleName}::BridgeFeeCharged<phantom CREDIT>`, fields: {
+        key: bcs_1.bcs.u64(),
+        evm_destination_chain: bcs_1.bcs.u16(),
+        amount: bcs_1.bcs.u64(),
+        fee_amount: bcs_1.bcs.u64()
+    } });
+exports.ExecutedNative = new index_ts_1.MoveStruct({ name: `${$moduleName}::ExecutedNative<phantom CREDIT, phantom T>`, fields: {
+        key: bcs_1.bcs.u64(),
+        recipient: bcs_1.bcs.Address,
+        amount: bcs_1.bcs.u64()
+    } });
+exports.EntryCancelled = new index_ts_1.MoveStruct({ name: `${$moduleName}::EntryCancelled<phantom CREDIT>`, fields: {
+        key: bcs_1.bcs.u64(),
+        account_id: bcs_1.bcs.Address,
+        amount: bcs_1.bcs.u64(),
+        route_tag: bcs_1.bcs.u8()
+    } });
+exports.ExecutorUpdated = new index_ts_1.MoveStruct({ name: `${$moduleName}::ExecutorUpdated<phantom CREDIT>`, fields: {
+        executor: bcs_1.bcs.Address,
+        added: bcs_1.bcs.bool()
+    } });
+function packageVersion(options = {}) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'package_version',
+    });
+}
+/** User helper: encode a Wormhole-bound route as `extra_data` bytes. */
+function routeWormhole(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        'u16',
+        'vector<u8>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["evmDestinationChain", "evmRecipient", "evmToken"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'route_wormhole',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * 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.
+ */
+function routeNative(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        'u64'
+    ];
+    const parameterNames = ["minOutput"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'route_native',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Create + share a `Queue<CREDIT>`. Call once per credit type. */
+function createQueue(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'create_queue',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function addExecutor(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["queue", "_", "executor"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'add_executor',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function removeExecutor(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["queue", "_", "executor"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'remove_executor',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function isExecutor(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["queue", "executor"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'is_executor',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function addVersion(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'add_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function removeVersion(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'remove_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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`.
+ */
+function setBridgeFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u128'
+    ];
+    const parameterNames = ["queue", "_", "feeRate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'set_bridge_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function setChainBridgeFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16',
+        'u128'
+    ];
+    const parameterNames = ["queue", "_", "evmDestinationChain", "feeRate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'set_chain_bridge_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function unsetChainBridgeFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "_", "evmDestinationChain"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'unset_chain_bridge_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function setBridgeMinFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["queue", "_", "minFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'set_bridge_min_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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`.
+ */
+function setChainBridgeMinFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16',
+        'u64'
+    ];
+    const parameterNames = ["queue", "_", "evmDestinationChain", "minFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'set_chain_bridge_min_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function unsetChainBridgeMinFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "_", "evmDestinationChain"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'unset_chain_bridge_min_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function cancelEntry(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["queue", "accountRegistry", "request", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'cancel_entry',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function enqueue(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["queue", "registry", "req"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'enqueue',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function executeWormhole(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64',
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["queue", "key", "request", "bridge", "creditRegistry", "wormholeState", "wormholeFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'execute_wormhole',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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`.
+ */
+function executeNative(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64',
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["queue", "key", "request", "vault", "creditRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'execute_native',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function length(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'length',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function isEmpty(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'is_empty',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function front(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function contains(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["queue", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'contains',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function entry(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["queue", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function entryAmount(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function entryAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function entryRecipient(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_recipient',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function entryExtraData(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["entry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'entry_extra_data',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns the leading route tag byte; aborts if `extra_data` is empty or carries
+ * an unknown tag.
+ */
+function routeTag(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        'vector<u8>'
+    ];
+    const parameterNames = ["extraData"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'route_tag',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * 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.
+ */
+function bridgeFeeRate(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "evmDestinationChain"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_fee_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * The configured **default** rate (all-chains-without-override) as a 1e9-scaled
+ * `u128`; `0` when no fee config exists.
+ */
+function bridgeDefaultFeeRate(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_default_fee_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Whether `evm_destination_chain` has an explicit per-chain override (distinct
+ * from falling back to the default).
+ */
+function hasChainBridgeFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "evmDestinationChain"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'has_chain_bridge_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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).
+ */
+function bridgeFeeAmount(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u16',
+        'u64'
+    ];
+    const parameterNames = ["queue", "evmDestinationChain", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_fee_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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).
+ */
+function wouldExecuteWormhole(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u16',
+        'u64'
+    ];
+    const parameterNames = ["queue", "evmDestinationChain", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'would_execute_wormhole',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function bridgeChainRates(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_chain_rates',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function bridgeMinFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "evmDestinationChain"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_min_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * The configured **default** minimum-fee floor (all-chains-without-override) in
+ * CREDIT units; `0` when no fee config exists.
+ */
+function bridgeDefaultMinFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_default_min_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Whether `evm_destination_chain` has an explicit per-chain min-fee override
+ * (distinct from falling back to the default floor).
+ */
+function hasChainBridgeMinFee(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["queue", "evmDestinationChain"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'has_chain_bridge_min_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * 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.
+ */
+function bridgeChainMinFees(options) {
+    const packageAddress = options.package ?? '@waterx/withdrawal-queue';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["queue"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'withdrawal_queue',
+        function: 'bridge_chain_min_fees',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}