@waterx/sdk 2.1.0 → 2.3.1-dev.0

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

@@ -19,6 +19,13 @@ 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<{
@@ -58,6 +65,63 @@ export declare const Queue: MoveStruct<{
      */
     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]">;
@@ -70,6 +134,12 @@ export declare const ExecutedWormhole: MoveStruct<{
     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]">;
@@ -106,9 +176,13 @@ export interface RouteWormholeOptions {
 }
 /** 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?: [
+    arguments: RouteNativeArguments | [
+        minOutput: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [
         string
@@ -116,7 +190,10 @@ export interface RouteNativeOptions {
 }
 /**
  * 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 declare function routeNative(options: RouteNativeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface CreateQueueArguments {
@@ -226,6 +303,166 @@ export interface RemoveVersionOptions {
  * 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>;
@@ -341,8 +578,8 @@ export interface ExecuteNativeOptions {
     ];
 }
 /**
- * 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 declare function executeNative(options: ExecuteNativeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
@@ -481,3 +718,206 @@ export interface RouteTagOptions {
  * 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;