@waterx/sdk 2.1.0 → 2.3.1-dev.0

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

@@ -8,6 +8,10 @@ import * as balance from "./deps/sui/balance.js";
 import * as linked_table from "./deps/bucket_v2_framework/linked_table.js";
 import * as vec_set from "./deps/sui/vec_set.js";
 import * as vec_set_1 from "./deps/sui/vec_set.js";
+import * as float from "./deps/bucket_v2_framework/float.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as float_1 from "./deps/bucket_v2_framework/float.js";
+import * as vec_map_1 from "./deps/sui/vec_map.js";
 const $moduleName = '@waterx/withdrawal-queue::withdrawal_queue';
 export const WithdrawQueue = new MoveStruct({ name: `${$moduleName}::WithdrawQueue`, fields: {
         dummy_field: bcs.bool()
@@ -18,7 +22,14 @@ export const WormholeRoute = new MoveStruct({ name: `${$moduleName}::WormholeRou
         evm_token: bcs.vector(bcs.u8())
     } });
 export const NativeRoute = new MoveStruct({ name: `${$moduleName}::NativeRoute`, fields: {
-        asset_type: type_name.TypeName
+        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.u64()
     } });
 export const Entry = new MoveStruct({ name: `${$moduleName}::Entry<phantom CREDIT>`, fields: {
         balance: balance.Balance,
@@ -54,6 +65,37 @@ export const Queue = new MoveStruct({ name: `${$moduleName}::Queue<phantom CREDI
          */
         allowed_versions: vec_set_1.VecSet(bcs.u16())
     } });
+export const BridgeFeeKey = new MoveStruct({ name: `${$moduleName}::BridgeFeeKey`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const BridgeFeeConfig = new MoveStruct({ name: `${$moduleName}::BridgeFeeConfig`, fields: {
+        default_rate: float.Float,
+        chain_rates: vec_map.VecMap(bcs.u16(), float_1.Float)
+    } });
+export const BridgeMinFeeKey = new MoveStruct({ name: `${$moduleName}::BridgeMinFeeKey`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const BridgeMinFeeConfig = new MoveStruct({ name: `${$moduleName}::BridgeMinFeeConfig`, fields: {
+        default_min_fee: bcs.u64(),
+        chain_min_fees: vec_map_1.VecMap(bcs.u16(), bcs.u64())
+    } });
+export const BridgeFeeUpdated = new MoveStruct({ name: `${$moduleName}::BridgeFeeUpdated<phantom CREDIT>`, fields: {
+        /** 1e9-scaled default fee rate now in effect. */
+        fee_rate: bcs.u128()
+    } });
+export const ChainBridgeFeeUpdated = new MoveStruct({ name: `${$moduleName}::ChainBridgeFeeUpdated<phantom CREDIT>`, fields: {
+        evm_destination_chain: bcs.u16(),
+        fee_rate: bcs.u128(),
+        removed: bcs.bool()
+    } });
+export const BridgeMinFeeUpdated = new MoveStruct({ name: `${$moduleName}::BridgeMinFeeUpdated<phantom CREDIT>`, fields: {
+        min_fee: bcs.u64()
+    } });
+export const ChainBridgeMinFeeUpdated = new MoveStruct({ name: `${$moduleName}::ChainBridgeMinFeeUpdated<phantom CREDIT>`, fields: {
+        evm_destination_chain: bcs.u16(),
+        min_fee: bcs.u64(),
+        removed: bcs.bool()
+    } });
 export const Enqueued = new MoveStruct({ name: `${$moduleName}::Enqueued<phantom CREDIT>`, fields: {
         key: bcs.u64(),
         account_id: bcs.Address,
@@ -66,6 +108,12 @@ export const ExecutedWormhole = new MoveStruct({ name: `${$moduleName}::Executed
         evm_destination_chain: bcs.u16(),
         amount: bcs.u64()
     } });
+export const BridgeFeeCharged = new MoveStruct({ name: `${$moduleName}::BridgeFeeCharged<phantom CREDIT>`, fields: {
+        key: bcs.u64(),
+        evm_destination_chain: bcs.u16(),
+        amount: bcs.u64(),
+        fee_amount: bcs.u64()
+    } });
 export const ExecutedNative = new MoveStruct({ name: `${$moduleName}::ExecutedNative<phantom CREDIT, phantom T>`, fields: {
         key: bcs.u64(),
         recipient: bcs.Address,
@@ -107,14 +155,22 @@ export function routeWormhole(options) {
 }
 /**
  * User helper: encode a Native-bound route as `extra_data` bytes. `T` is the
- * backing asset of the destination `SingleVault<T>`.
+ * 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 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
 }
@@ -222,6 +278,158 @@ export function removeVersion(options) {
         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`.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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`.
+ */
+export 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: 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.
+ */
+export 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: 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
@@ -310,8 +518,8 @@ export function executeWormhole(options) {
     });
 }
 /**
- * Execute a queued entry via `native_custody::custody_vault::burn<T>`. Verifies
- * that `extra_data` byte-equals `route_native<T>()` — if `T` was not the
+ * 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 function executeNative(options) {
@@ -478,3 +686,208 @@ export function routeTag(options) {
         arguments: 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.
+ */
+export 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: 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.
+ */
+export 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: 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).
+ */
+export 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: 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).
+ */
+export 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: 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).
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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).
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}