@stablechain/sdk 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { erc3009Actions } from './erc3009.js';
 export { Authorization, AuthorizationUsage, CancelAuthorizationParameters, ERC3009_ABI, Erc3009DomainOverrides, GetAuthorizationStateParameters, GetAuthorizationUsageParameters, PreparedAuthorizationCall, ReceiveWithAuthorizationParameters, SignReceiveAuthorizationParameters, SignTransferAuthorizationParameters, SignedAuthorization, TransferWithAuthorizationParameters, VerifyAuthorizationParameters, VerifyAuthorizationResult, VerifyFailureReason, cancelAuthorization, getAuthorizationState, getAuthorizationUsage, prepareTransferWithAuthorization, receiveWithAuthorization, signReceiveAuthorization, signTransferAuthorization, transferWithAuthorization, verifyAuthorization } from './erc3009.js';
-import { Account, Transport, WalletClient, Address, BaseError } from 'viem';
+import { Account, Transport, WalletClient, Address, Hex, BaseError } from 'viem';
 
 interface EarnConfig {
     /** MetaMorpho V2 vault address */
@@ -11,6 +11,17 @@ interface StableConfig {
     network?: Network;
     /** Optional RPC override — defaults to the public RPC for the selected network */
     rpc?: string;
+    /**
+     * Per-chain RPC overrides for the cross-chain bridge routes, e.g.
+     * `{ [Chain.Ethereum]: "https://..." }`.
+     *
+     * {@link StableConfig.rpc} covers the Stable chain only — transfers, earn and
+     * authorizations. A bridge reads and broadcasts on whichever chain it starts
+     * from, and by default that is this SDK's built-in public endpoint for that
+     * chain. Override the chains you quote on to keep a backend off a shared
+     * rate limit; chains left out keep the public endpoint.
+     */
+    rpcOverrides?: Partial<Record<Chain, string>>;
     /** Server-side signing: pass a viem Account, e.g. privateKeyToAccount("0x...") */
     account?: Account;
     /** Browser-wallet signing: pass a viem Transport, e.g. custom(window.ethereum) */
@@ -103,20 +114,106 @@ declare enum Network {
     Testnet = "testnet"
 }
 interface BridgeQuote {
-    /** Estimated output amount on the destination chain */
+    /**
+     * Amount the recipient is expected to receive on the destination chain.
+     *
+     * On native OFT routes this is `oft.amountReceivedLD` — the input minus any
+     * OFT-level fee and minus dust removed by decimal conversion — and falls back
+     * to the input amount when `quoteOFT` could not be read.
+     */
     toAmount?: number;
-    /** LayerZero native messaging fee (wei) — only present for USDT0→USDT0 (OFT) routes */
+    /**
+     * LayerZero messaging fee (wei of the source chain's native token) — only
+     * present for native OFT routes. This is the whole `MessagingFee.nativeFee`
+     * that `send` must be called with: DVN fees, executor fee and any requested
+     * destination native drop, bundled. `quoteSend` returns no breakdown of it.
+     */
     nativeFee?: bigint;
-    /** LayerZero fee paid in LZ token (wei) — only present for USDT0→USDT0 (OFT) routes */
+    /**
+     * The messaging fee a send built from this quote will actually carry, in wei:
+     * {@link BridgeQuote.nativeFee} padded by `feeBufferBps`.
+     *
+     * `nativeFee` is the honest quote and the number to show a user. This is the
+     * number to check a native balance against, because it is what leaves the
+     * wallet — the endpoint keeps what the pathway costs at inclusion time and
+     * refunds the rest. Only present for native OFT routes.
+     */
+    nativeFeeMax?: bigint;
+    /** LayerZero fee paid in LZ token (wei) — only present for native OFT routes */
     lzTokenFee?: bigint;
     /**
-     * How long the bridge is expected to take. Only present for USDT0 (OFT) routes,
+     * OFT-level accounting for the send: what the adapter itself debits, credits
+     * and charges, independent of the LayerZero messaging fee. Only present for
+     * native OFT routes, and omitted when the `quoteOFT` read failed.
+     */
+    oft?: BridgeOftQuote;
+    /**
+     * Source-chain execution cost of the `send` transaction. Only present for
+     * native OFT routes, and omitted when neither simulation nor fallback could
+     * produce a number. Excludes {@link BridgeQuote.nativeFee}.
+     */
+    srcGas?: BridgeGasEstimate;
+    /**
+     * Everything the sender pays out of their native balance, in wei:
+     * `srcGas.costWei + nativeFee`. Present only when both parts are known.
+     */
+    totalCostWei?: bigint;
+    /**
+     * How long the bridge is expected to take. Only present for native OFT routes,
      * and omitted if the estimate could not be resolved — never treat it as required.
      */
     estimate?: BridgeTimeEstimate;
 }
 /**
- * Expected end-to-end delivery time for a USDT0 (LayerZero OFT) bridge.
+ * One fee the OFT itself reports for a send, from `quoteOFT`'s `oftFeeDetails`.
+ *
+ * Every pathway in BRIDGE_CHAIN_CONFIGS reported none when checked on 2026-08-20
+ * (Ethereum, Stable, Arbitrum and Plasma adapters), so an empty `fees` array is the
+ * normal case rather than a failed read. A deployment that does charge at the OFT
+ * level — the kind of thing a bridge UI shows as its own fee row — reports it here
+ * rather than inside the LayerZero messaging fee.
+ */
+interface BridgeOftFee {
+    /** Fee in the source token's smallest unit. Negative means a credit, not a charge. */
+    amountLD: bigint;
+    /** Human-readable amount, same sign convention as {@link BridgeOftFee.amountLD} */
+    amount: number;
+    /** Whatever the adapter calls this fee — its own string, shown as-is */
+    description: string;
+}
+/** What the OFT adapter reports for a send, read from `quoteOFT`. */
+interface BridgeOftQuote {
+    /** Amount debited on the source chain, in the source token's smallest unit */
+    amountSentLD: bigint;
+    /** Amount credited on the destination chain, in the source token's smallest unit */
+    amountReceivedLD: bigint;
+    /** Human-readable {@link BridgeOftQuote.amountReceivedLD} */
+    amountReceived: number;
+    /** Fees the adapter charges. Empty on pathways that charge none. */
+    fees: BridgeOftFee[];
+    /** Smallest amount this pathway accepts, in the source token's smallest unit */
+    minAmountLD: bigint;
+    /** Largest amount this pathway accepts, in the source token's smallest unit */
+    maxAmountLD: bigint;
+}
+/** Source-chain gas for the OFT `send` transaction. */
+interface BridgeGasEstimate {
+    /** Gas units */
+    gas: bigint;
+    /** Price per gas unit (wei) — `maxFeePerGas` where the chain is EIP-1559 */
+    gasPriceWei: bigint;
+    /** `gas × gasPriceWei` */
+    costWei: bigint;
+    /**
+     * `"simulated"` means `gas` came from simulating the real `send` — trust it.
+     * `"fallback"` means the simulation failed (no allowance or no balance yet is
+     * the usual reason when quoting before approving) and `gas` is a typical-send
+     * constant, so treat the cost as indicative only.
+     */
+    source: "simulated" | "fallback";
+}
+/**
+ * Expected end-to-end delivery time for a native (LayerZero OFT) bridge.
  *
  * Almost all of the wait is source-chain finality: the DVNs securing the pathway
  * refuse to attest until the send transaction is buried under `confirmations`
@@ -159,13 +256,17 @@ interface BridgeStatus {
 }
 /**
  * Bridge route selection:
- * - `"usdt0"` — force the USDT0 LayerZero OFT path (no protocol fee, just gas + LZ
- *   messaging fee; slower). Throws if the chain pair has no USDT0 adapter.
+ * - `"oft"` — force the native LayerZero OFT path for whichever asset the token
+ *   addresses name, USDT0 or XAUt0 (no protocol fee, just gas + LZ messaging fee;
+ *   slower). Throws if the chain pair has no adapter for that asset.
+ * - `"usdt0"` — deprecated alias for `"oft"`, kept for compatibility. It does not
+ *   restrict the route to USDT0; the token addresses decide the asset.
  * - `"lifi"` — force the LI.FI aggregator path (fast, charges a fee).
- * - `"auto"` — use USDT0 when both chains support it and tokens match, else LI.FI.
+ * - `"auto"` — use the native OFT mesh (USDT0 or XAUt0) when both chains deploy
+ *   the requested asset and the token addresses match, else LI.FI.
  *   This is the default.
  */
-type BridgeRoute = "auto" | "usdt0" | "lifi";
+type BridgeRoute = "auto" | "oft" | "usdt0" | "lifi";
 interface BridgeParams {
     fromChain: Chain;
     toChain: Chain;
@@ -174,17 +275,124 @@ interface BridgeParams {
     /** Destination token contract address */
     toToken: string;
     amount: number;
-    /** Source token decimals (default: 6) */
+    /**
+     * Source token decimals (default: 6). **LI.FI routes only.**
+     *
+     * Native OFT routes parse the amount with the decimals the token has on the
+     * source chain, which the SDK already knows from
+     * {@link BRIDGE_CHAIN_CONFIGS}. Passing a value that disagrees with those
+     * throws rather than silently sending a different amount.
+     */
     fromDecimals?: number;
     /** Recipient address — defaults to the signer */
     recipient?: string;
     /**
-     * Which bridge to use. Defaults to "auto" (USDT0 OFT when available, else LI.FI).
+     * Which bridge to use. Defaults to "auto" (native OFT when available, else LI.FI).
      * See {@link BridgeRoute}.
      */
     route?: BridgeRoute;
-    /** Pre-fetched quote from quoteBridge() — skips the quote fetch when passed to bridge() */
+    /**
+     * Destination native token (wei) to airdrop to the recipient alongside the
+     * tokens — LayerZero's executor native-drop option, what bridge UIs call
+     * "gas on destination". Paid for by the sender through a larger
+     * {@link BridgeQuote.nativeFee}.
+     *
+     * Only supported on native OFT routes, and capped per pathway by the
+     * executor's configured `nativeCap`: asking for more makes `quoteSend`
+     * revert rather than silently clamping.
+     */
+    dstNativeDrop?: bigint;
+    /**
+     * Pre-fetched quote from quoteBridge() — skips the quote fetch when passed to
+     * bridge(). Must have been quoted with the same `dstNativeDrop`, since the
+     * drop is part of what `nativeFee` pays for.
+     */
     quote?: BridgeQuote;
+    /**
+     * How much to pad the quoted LayerZero messaging fee by when sending, in basis
+     * points (100 = 1%). Defaults to 500 (5%); 0 sends exactly the quoted fee.
+     * Native OFT routes only.
+     *
+     * The fee a send must carry is whatever the pathway costs at the moment it
+     * lands, and `send` demands an exact match: too little reverts, and the
+     * endpoint refunds the excess to the sender. Between the quote and the
+     * signature that number can only have moved, so the buffer trades a refund
+     * round trip for not reverting — and a revert costs the gas either way.
+     */
+    feeBufferBps?: number;
+    /**
+     * Where LayerZero returns messaging fee it did not need — the excess left over
+     * once the endpoint has taken what the pathway actually cost. Defaults to the
+     * sender. Native OFT routes only.
+     */
+    refundAddress?: string;
+}
+/**
+ * A bridge to build but not send — see
+ * {@link StableClient.prepareBridgeCalldata}.
+ */
+interface PrepareBridgeParams extends BridgeParams {
+    /**
+     * The address that will sign and send these transactions. Its allowance is
+     * what decides whether an approval step is needed, and it is the default
+     * recipient and — via {@link BridgeParams.refundAddress} — refund address.
+     */
+    from: string;
+}
+/** One transaction to sign and broadcast, as built by an unsigned-build helper. */
+interface BridgeCalldataStep {
+    /** The chain this must be sent on — always the bridge's source chain */
+    chainId: number;
+    to: string;
+    data: string;
+    /** Native token to attach, in wei: 0 for the approvals, the fee for the send */
+    value: bigint;
+}
+/**
+ * A built, unsigned bridge: the transactions, the quote behind them, and the send
+ * they encode in readable form.
+ */
+interface BridgeCalldata {
+    /**
+     * Transactions to send in order, each confirmed before the next: an allowance
+     * reset and an approve where the pathway needs them, then the OFT `send`.
+     *
+     * Approvals appear only when the source chain's adapter pulls the token with
+     * `transferFrom` and the current allowance is short. A short but non-zero
+     * allowance takes two of them — legacy USDT refuses to overwrite a non-zero
+     * allowance with another non-zero value — which is why this is a list and not
+     * an optional single approval.
+     */
+    steps: BridgeCalldataStep[];
+    /** The source chain every step must be sent on */
+    chainId: number;
+    /** Which OFT mesh this send moves through */
+    asset: "usdt0" | "xaut0";
+    /** The quote these steps were built from, whether supplied or freshly read */
+    quote: BridgeQuote;
+    /**
+     * The `send` step's arguments, decoded — enough to check the calldata against
+     * what was intended without re-deriving the ABI encoding.
+     */
+    send: {
+        /** LayerZero endpoint ID of the destination chain */
+        dstEid: number;
+        /** Recipient address on the destination chain */
+        recipient: string;
+        /** `recipient`, left-padded to the bytes32 the OFT takes */
+        to: string;
+        /** Amount debited on the source chain, in the token's smallest unit */
+        amountLD: bigint;
+        /** Slippage floor: what the adapter quoted it would deliver */
+        minAmountLD: bigint;
+        /** Encoded LayerZero executor options, including any destination native drop */
+        extraOptions: string;
+        /** Messaging fee the send carries as its `value`, buffer included */
+        nativeFee: bigint;
+        lzTokenFee: bigint;
+        /** Where the endpoint returns unused fee */
+        refundAddress: string;
+    };
 }
 interface EarnDepositParams {
     /** Amount of underlying assets to deposit (human-readable) */
@@ -416,11 +624,23 @@ interface StableClient {
     quoteBridge(params: BridgeParams): Promise<BridgeQuote>;
     bridge(params: BridgeParams): Promise<OperationResult>;
     /**
-     * Expected delivery time for a USDT0 (LayerZero OFT) bridge, before sending.
-     * Throws for chain pairs with no USDT0 adapter — LI.FI carries its own ETA.
+     * Build a bridge's transactions without signing or sending them — for a
+     * backend that quotes, builds and checks while the holder's wallet only signs.
+     *
+     * Native OFT routes only: LI.FI hands back its own transaction request from
+     * its API, so a pair that resolves to LI.FI throws rather than returning
+     * something shaped the same but built elsewhere.
      */
-    estimateBridgeTime(params: Pick<BridgeParams, "fromChain" | "toChain">): Promise<BridgeTimeEstimate>;
-    /** Delivery status of an in-flight USDT0 bridge, by source transaction hash. */
+    prepareBridgeCalldata(params: PrepareBridgeParams): Promise<BridgeCalldata>;
+    /**
+     * Expected delivery time for a native OFT (LayerZero) bridge, before sending.
+     * Throws for chain pairs with no OFT adapter — LI.FI carries its own ETA.
+     *
+     * Pass `fromToken`/`toToken` to estimate a specific asset; omitting them
+     * estimates the USDT0 pathway.
+     */
+    estimateBridgeTime(params: Pick<BridgeParams, "fromChain" | "toChain"> & Partial<Pick<BridgeParams, "fromToken" | "toToken">>): Promise<BridgeTimeEstimate>;
+    /** Delivery status of an in-flight OFT bridge, by source transaction hash. */
     trackBridge(srcTxHash: string): Promise<BridgeStatus>;
     quoteSwap(params: SwapParams): Promise<SwapQuote>;
     swap(params: SwapParams): Promise<OperationResult>;
@@ -472,7 +692,7 @@ interface StableReader {
         };
     };
 }
-declare function createStable({ network, rpc: rpcOverride, account, transport, walletClient, earn: earnConfig, merklApiBase, }: StableConfig): StableClient;
+declare function createStable({ network, rpc: rpcOverride, rpcOverrides, account, transport, walletClient, earn: earnConfig, merklApiBase, }: StableConfig): StableClient;
 declare function createStableReader(config: StableReaderConfig): StableReader;
 
 interface ChainConfig {
@@ -484,9 +704,37 @@ interface ChainConfig {
 }
 declare const CHAIN_CONFIGS: Partial<Record<Chain, ChainConfig>>;
 
+/** An asset with its own LayerZero OFT mesh. Each has separate adapters per chain. */
+type BridgeAsset = "usdt0" | "xaut0";
+/** One asset's deployment on one chain. */
+interface BridgeTokenConfig {
+    /** The ERC-20 a holder owns — what gets debited, and approved when required */
+    address: Address;
+    /** Decimals of that ERC-20 on this chain */
+    decimals: number;
+    /** The OFT (or OFT Adapter) that escrows-or-burns on send */
+    oftAdapter: Address;
+    /**
+     * Whether `send` pulls the token via `transferFrom` and so needs an allowance.
+     * Only the lockbox chain does; remote deployments burn from the caller directly.
+     * Undefined means "approve when the allowance is short" — the safe default.
+     */
+    approvalRequired?: boolean;
+    /** False when the adapter exists but has no outbound send pathways configured */
+    lzOutbound?: boolean;
+}
 interface BridgeChainConfig extends ChainConfig {
     lzEid: number;
-    /** Only set on source chains that have an OFT Adapter deployed */
+    /**
+     * Which OFT assets this chain can bridge. A chain may carry one and not the
+     * other — BSC has XAUt0 but no USDT0 deployment.
+     */
+    tokens: Partial<Record<BridgeAsset, BridgeTokenConfig>>;
+    /**
+     * The USDT0 adapter. Predates XAUt0 and is part of the exported
+     * BRIDGE_CHAIN_CONFIGS surface, so it still means USDT0 specifically —
+     * prefer `tokens[asset].oftAdapter`.
+     */
     oftAdapter?: Address;
     /** False when the OFT adapter exists but has no outbound send pathways configured */
     lzOutbound?: boolean;
@@ -497,8 +745,175 @@ interface BridgeChainConfig extends ChainConfig {
     blockTimeSec?: number;
 }
 declare const BRIDGE_CHAIN_CONFIGS: Partial<Record<Chain, BridgeChainConfig>>;
+/**
+ * Which OFT asset a token address refers to on a chain, or undefined when the
+ * chain has no OFT deployment matching it.
+ */
+declare function bridgeAssetFor(cfg: BridgeChainConfig, token: string): BridgeAsset | undefined;
+declare const OFT_ADAPTER_ABI: readonly [{
+    readonly name: "quoteSend";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_sendParam";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "dstEid";
+            readonly type: "uint32";
+        }, {
+            readonly name: "to";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "amountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "minAmountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "extraOptions";
+            readonly type: "bytes";
+        }, {
+            readonly name: "composeMsg";
+            readonly type: "bytes";
+        }, {
+            readonly name: "oftCmd";
+            readonly type: "bytes";
+        }];
+    }, {
+        readonly name: "_payInLzToken";
+        readonly type: "bool";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "msgFee";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "nativeFee";
+            readonly type: "uint256";
+        }, {
+            readonly name: "lzTokenFee";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "quoteOFT";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_sendParam";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "dstEid";
+            readonly type: "uint32";
+        }, {
+            readonly name: "to";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "amountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "minAmountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "extraOptions";
+            readonly type: "bytes";
+        }, {
+            readonly name: "composeMsg";
+            readonly type: "bytes";
+        }, {
+            readonly name: "oftCmd";
+            readonly type: "bytes";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "oftLimit";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "minAmountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "maxAmountLD";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "oftFeeDetails";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "feeAmountLD";
+            readonly type: "int256";
+        }, {
+            readonly name: "description";
+            readonly type: "string";
+        }];
+    }, {
+        readonly name: "oftReceipt";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "amountSentLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "amountReceivedLD";
+            readonly type: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "send";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_sendParam";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "dstEid";
+            readonly type: "uint32";
+        }, {
+            readonly name: "to";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "amountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "minAmountLD";
+            readonly type: "uint256";
+        }, {
+            readonly name: "extraOptions";
+            readonly type: "bytes";
+        }, {
+            readonly name: "composeMsg";
+            readonly type: "bytes";
+        }, {
+            readonly name: "oftCmd";
+            readonly type: "bytes";
+        }];
+    }, {
+        readonly name: "_fee";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "nativeFee";
+            readonly type: "uint256";
+        }, {
+            readonly name: "lzTokenFee";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "_refundAddress";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+}];
 /** Drop cached pathway configs and observed timings — forces the next estimate to refetch. */
 declare function clearBridgeEstimateCache(): void;
+/**
+ * Encode LayerZero V2 executor options.
+ *
+ * `gasLimit = 0` tells the executor to use its built-in minimum for lzReceive —
+ * matches the Stable bridge tutorial, and is what every plain token transfer wants.
+ *
+ * A non-zero `nativeDrop` appends the executor's native-drop option: that many wei
+ * of the *destination* chain's native token, airdropped to `dropReceiver` when the
+ * message is executed. The executor prices it into `quoteSend`'s `nativeFee`, and
+ * rejects a drop above the pathway's configured `nativeCap`.
+ */
+declare function buildLzOptions(gasLimit?: bigint, nativeDrop?: bigint, dropReceiver?: Address): Hex;
 
 declare const STABLE_USDT_ADDRESS: Address;
 declare const STABLE_VAULT_ADDRESS: Address;
@@ -560,4 +975,4 @@ declare class StableBulkError extends StableError {
     });
 }
 
-export { BRIDGE_CHAIN_CONFIGS, type BridgeChainConfig, type BridgeDeliveryState, type BridgeParams, type BridgeQuote, type BridgeRoute, type BridgeStatus, type BridgeTimeEstimate, type BulkDepositOptions, type BulkEarnResult, type BulkEarnResultItem, type BulkWithdrawOptions, CHAIN_CONFIGS, Chain, type ChainConfig, type EarnConfig, type EarnDepositCalldata, type EarnDepositParams, type EarnRedeemParams, type EarnResult, type EarnWithdrawCalldata, type EarnWithdrawParams, type ForceDeallocation, type ForceRedeemParams, type ForceWithdrawParams, type MerklClaimCalldata, type MerklClaimResult, type MerklReward, type MerklRewardToken, type MerklRewardsResult, Network, type OperationResult, STABLE_USDT_ADDRESS, STABLE_VAULT_ADDRESS, StableBulkError, type StableClient, type StableConfig, StableError, StableNetworkError, StableQuoteError, type StableReader, type StableReaderConfig, StableTransactionError, StableValidationError, type SwapParams, type SwapQuote, type TransferParams, type VaultPosition, type VaultYield, type VaultYieldReward, type WithdrawStatus, type YieldPreview, clearBridgeEstimateCache, createStable, createStableReader, erc3009Actions };
+export { BRIDGE_CHAIN_CONFIGS, type BridgeAsset, type BridgeCalldata, type BridgeCalldataStep, type BridgeChainConfig, type BridgeDeliveryState, type BridgeGasEstimate, type BridgeOftFee, type BridgeOftQuote, type BridgeParams, type BridgeQuote, type BridgeRoute, type BridgeStatus, type BridgeTimeEstimate, type BridgeTokenConfig, type BulkDepositOptions, type BulkEarnResult, type BulkEarnResultItem, type BulkWithdrawOptions, CHAIN_CONFIGS, Chain, type ChainConfig, type EarnConfig, type EarnDepositCalldata, type EarnDepositParams, type EarnRedeemParams, type EarnResult, type EarnWithdrawCalldata, type EarnWithdrawParams, type ForceDeallocation, type ForceRedeemParams, type ForceWithdrawParams, type MerklClaimCalldata, type MerklClaimResult, type MerklReward, type MerklRewardToken, type MerklRewardsResult, Network, OFT_ADAPTER_ABI, type OperationResult, type PrepareBridgeParams, STABLE_USDT_ADDRESS, STABLE_VAULT_ADDRESS, StableBulkError, type StableClient, type StableConfig, StableError, StableNetworkError, StableQuoteError, type StableReader, type StableReaderConfig, StableTransactionError, StableValidationError, type SwapParams, type SwapQuote, type TransferParams, type VaultPosition, type VaultYield, type VaultYieldReward, type WithdrawStatus, type YieldPreview, bridgeAssetFor, buildLzOptions, clearBridgeEstimateCache, createStable, createStableReader, erc3009Actions };