@oydual31/more-vaults-sdk 0.3.2 → 0.4.0

package/dist/ethers/index.d.ts

@@ -8,6 +8,9 @@ declare const CHAIN_IDS: {
     readonly arbitrum: 42161;
     readonly base: 8453;
     readonly ethereum: 1;
+    readonly optimism: 10;
+    readonly sonic: 146;
+    readonly bsc: 56;
 };
 /**
  * LayerZero Endpoint IDs (EID) for chains supported by MoreVaults.
@@ -20,11 +23,323 @@ declare const LZ_EIDS: {
     readonly arbitrum: 30110;
     readonly base: 30184;
     readonly ethereum: 30101;
+    readonly optimism: 30111;
+    readonly sonic: 30332;
+    readonly bsc: 30102;
 };
 /** LayerZero EID → EVM Chain ID */
 declare const EID_TO_CHAIN_ID: Record<number, number>;
 /** EVM Chain ID → LayerZero EID */
 declare const CHAIN_ID_TO_EID: Record<number, number>;
+/**
+ * LayerZero v2 OFT route config per asset symbol.
+ *
+ * Each entry maps chainId → { oft, token } where:
+ *   - `oft`   = OFT contract to call send() on (pass as `spokeOFT` to depositFromSpoke)
+ *   - `token` = underlying ERC-20 the user approves before bridging
+ *               (zero address = native ETH, no approval needed)
+ *
+ * All routes verified on-chain via quoteSend() or peers(). Issuers vary per asset.
+ */
+declare const OFT_ROUTES: {
+    /**
+     * stgUSDC — USDC bridged via Stargate v2.
+     * Underlying on Eth/Arb/Base/Op: native USDC. On Flow: stgUSDC (Stargate's wrapped USDC).
+     */
+    readonly stgUSDC: {
+        readonly 747: {
+            readonly oft: "0xAF54BE5B6eEc24d6BFACf1cce4eaF680A8239398";
+            readonly token: "0xF1815bd50389c46847f0Bda824eC8da914045D14";
+        };
+        readonly 1: {
+            readonly oft: "0xc026395860Db2d07ee33e05fE50ed7bD583189C7";
+            readonly token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+        };
+        readonly 42161: {
+            readonly oft: "0xe8CDF27AcD73a434D661C84887215F7598e7d0d3";
+            readonly token: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+        };
+        readonly 8453: {
+            readonly oft: "0x27a16dc786820B16E5c9028b75B99F6f604b5d26";
+            readonly token: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+        };
+        readonly 10: {
+            readonly oft: "0xcE8CcA271Ebc0533920C83d39F417ED6A0abB7D0";
+            readonly token: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85";
+        };
+        readonly 146: {
+            readonly oft: "0xA272fFe20cFfe769CdFc4b63088DCD2C82a2D8F9";
+            readonly token: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894";
+        };
+    };
+    /**
+     * USDT — USDT bridged via Stargate v2.
+     */
+    readonly USDT: {
+        readonly 747: {
+            readonly oft: "0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6";
+            readonly token: "0x674843C06FF83502ddb4D37c2E09C01cdA38cbc8";
+        };
+        readonly 1: {
+            readonly oft: "0x933597a323Eb81cAe705C5bC29985172fd5A3973";
+            readonly token: "0xdAC17F958D2ee523a2206206994597C13D831ec7";
+        };
+        readonly 42161: {
+            readonly oft: "0xcE8CcA271Ebc0533920C83d39F417ED6A0abB7D0";
+            readonly token: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9";
+        };
+        readonly 10: {
+            readonly oft: "0x19cFCE47eD54a88614648DC3f19A5980097007dD";
+            readonly token: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58";
+        };
+    };
+    /**
+     * USDF — USD Flow OFT. Bridges PYUSD (Ethereum) ↔ USDF (Flow EVM).
+     */
+    readonly USDF: {
+        readonly 747: {
+            readonly oft: "0x2aabea2058b5ac2d339b163c6ab6f2b6d53aabed";
+            readonly token: "0x2aabea2058b5ac2d339b163c6ab6f2b6d53aabed";
+        };
+        readonly 1: {
+            readonly oft: "0xfa0e06b54986ad96de87a8c56fea76fbd8d493f8";
+            readonly token: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8";
+        };
+    };
+    /**
+     * PYUSD — PayPal USD bridged via OFTAdapter (Paxos / LayerZero).
+     */
+    readonly PYUSD: {
+        readonly 747: {
+            readonly oft: "0x26d27d5AF2F6f1c14F40013C8619d97aaf015509";
+            readonly token: "0x99aF3EeA856556646C98c8B9b2548Fe815240750";
+        };
+        readonly 42161: {
+            readonly oft: "0x3CD2b89C49D130C08f1d683225b2e5DeB63ff876";
+            readonly token: "0x46850aD61C2B7d64d08c9C754F45254596696984";
+        };
+    };
+    /**
+     * WFLOW — Wrapped FLOW NativeOFTAdapter (issued by Flow Foundation).
+     */
+    readonly WFLOW: {
+        readonly 747: {
+            readonly oft: "0xd296588850bee2770136464ffdddd78c32f2a07c";
+            readonly token: "0xd296588850bee2770136464ffdddd78c32f2a07c";
+        };
+        readonly 1: {
+            readonly oft: "0xc1b45896b5fc9422a8f779653808297bb4f546f9";
+            readonly token: "0x5c147e74D63B1D31AA3Fd78Eb229B65161983B2b";
+        };
+    };
+    /**
+     * WETH — ETH OFT via Stargate v2. underlying = native ETH (no approval needed).
+     */
+    readonly WETH: {
+        readonly 747: {
+            readonly oft: "0x45f1A95A4D3f3836523F5c83673c797f4d4d263B";
+            readonly token: "0x2F6F07CDcf3588944Bf4C42aC74ff24bF56e7590";
+        };
+        readonly 1: {
+            readonly oft: "0x77b2043768d28E9C9aB44E1aBfC95944bcE57931";
+            readonly token: "0x0000000000000000000000000000000000000000";
+        };
+        readonly 42161: {
+            readonly oft: "0xA45B5130f36CDcA45667738e2a258AB09f4A5f7F";
+            readonly token: "0x0000000000000000000000000000000000000000";
+        };
+        readonly 8453: {
+            readonly oft: "0xdc181Bd607330aeeBEF6ea62e03e5e1Fb4B6F7C7";
+            readonly token: "0x0000000000000000000000000000000000000000";
+        };
+    };
+    /**
+     * sUSDe — Ethena staked USDe (yield-bearing stablecoin).
+     */
+    readonly sUSDe: {
+        readonly 1: {
+            readonly oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+            readonly token: "0x9D39A5DE30e57443BfF2A8307A4256c8797A3497";
+        };
+        readonly 42161: {
+            readonly oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+            readonly token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+        };
+        readonly 8453: {
+            readonly oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+            readonly token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+        };
+        readonly 10: {
+            readonly oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+            readonly token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+        };
+        readonly 56: {
+            readonly oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+            readonly token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2";
+        };
+    };
+    /**
+     * USDe — Ethena USD stablecoin.
+     */
+    readonly USDe: {
+        readonly 1: {
+            readonly oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+            readonly token: "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3";
+        };
+        readonly 42161: {
+            readonly oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+            readonly token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+        };
+        readonly 8453: {
+            readonly oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+            readonly token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+        };
+        readonly 10: {
+            readonly oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+            readonly token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+        };
+        readonly 56: {
+            readonly oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+            readonly token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34";
+        };
+    };
+    /**
+     * weETH — Ether.Fi liquid restaking token.
+     */
+    readonly weETH: {
+        readonly 1: {
+            readonly oft: "0xcd2eb13d6831d4602d80e5db9230a57596cdca63";
+            readonly token: "0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee";
+        };
+        readonly 8453: {
+            readonly oft: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a";
+            readonly token: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a";
+        };
+        readonly 10: {
+            readonly oft: "0x5a7facb970d094b6c7ff1df0ea68d99e6e73cbff";
+            readonly token: "0x5a7facb970d094b6c7ff1df0ea68d99e6e73cbff";
+        };
+        readonly 56: {
+            readonly oft: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a";
+            readonly token: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a";
+        };
+        readonly 146: {
+            readonly oft: "0xa3d68b74bf0528fdd07263c60d6488749044914b";
+            readonly token: "0xa3d68b74bf0528fdd07263c60d6488749044914b";
+        };
+    };
+    /**
+     * rsETH — Kelp DAO liquid restaking token.
+     */
+    readonly rsETH: {
+        readonly 1: {
+            readonly oft: "0x85d456b2dff1fd8245387c0bfb64dfb700e98ef3";
+            readonly token: "0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7";
+        };
+        readonly 42161: {
+            readonly oft: "0x4186bfc76e2e237523cbc30fd220fe055156b41f";
+            readonly token: "0x4186bfc76e2e237523cbc30fd220fe055156b41f";
+        };
+        readonly 8453: {
+            readonly oft: "0x1bc71130a0e39942a7658878169764bbd8a45993";
+            readonly token: "0x1bc71130a0e39942a7658878169764bbd8a45993";
+        };
+        readonly 10: {
+            readonly oft: "0x4186bfc76e2e237523cbc30fd220fe055156b41f";
+            readonly token: "0x4186bfc76e2e237523cbc30fd220fe055156b41f";
+        };
+        readonly 146: {
+            readonly oft: "0xd75787ba9aba324420d522bda84c08c87e5099b1";
+            readonly token: "0xd75787ba9aba324420d522bda84c08c87e5099b1";
+        };
+    };
+    /**
+     * rswETH — Swell Network liquid restaking token.
+     */
+    readonly rswETH: {
+        readonly 1: {
+            readonly oft: "0x1486d39646cdee84619bd05997319545a8575079";
+            readonly token: "0xFAe103DC9cf190eD75350761e95403b7b8aFa6c0";
+        };
+        readonly 42161: {
+            readonly oft: "0xb1fe27b32ffb5ce54e272c096547f1e86c19e72f";
+            readonly token: "0xb1fe27b32ffb5ce54e272c096547f1e86c19e72f";
+        };
+        readonly 8453: {
+            readonly oft: "0x850cdf416668210ed0c36bfff5d21921c7ada3b8";
+            readonly token: "0x850cdf416668210ed0c36bfff5d21921c7ada3b8";
+        };
+    };
+    /**
+     * USR — Resolv Labs USD stablecoin.
+     */
+    readonly USR: {
+        readonly 1: {
+            readonly oft: "0xd2ee2776f34ef4e7325745b06e6d464b08d4be0e";
+            readonly token: "0x66a1E37c9b0eAddca17d3662D6c05F4DECf3e110";
+        };
+        readonly 42161: {
+            readonly oft: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9";
+            readonly token: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9";
+        };
+        readonly 8453: {
+            readonly oft: "0x35e5db674d8e93a03d814fa0ada70731efe8a4b9";
+            readonly token: "0x35e5db674d8e93a03d814fa0ada70731efe8a4b9";
+        };
+        readonly 56: {
+            readonly oft: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9";
+            readonly token: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9";
+        };
+    };
+    /**
+     * wstUSR — Resolv Labs wrapped staked USR (yield-bearing).
+     */
+    readonly wstUSR: {
+        readonly 1: {
+            readonly oft: "0xab17c1fe647c37ceb9b96d1c27dd189bf8451978";
+            readonly token: "0x1202F5C7b4B9E47a1A484E8B270be34dbbC75055";
+        };
+        readonly 42161: {
+            readonly oft: "0x66cfbd79257dc5217903a36293120282548e2254";
+            readonly token: "0x66cfbd79257dc5217903a36293120282548e2254";
+        };
+        readonly 8453: {
+            readonly oft: "0xb67675158b412d53fe6b68946483ba920b135ba1";
+            readonly token: "0xb67675158b412d53fe6b68946483ba920b135ba1";
+        };
+        readonly 56: {
+            readonly oft: "0x4254813524695def4163a169e901f3d7a1a55429";
+            readonly token: "0x4254813524695def4163a169e901f3d7a1a55429";
+        };
+    };
+    /**
+     * USDtb — Ethena treasury-backed stablecoin.
+     */
+    readonly USDtb: {
+        readonly 1: {
+            readonly oft: "0xc708b6887db46005da033501f8aebee72d191a5d";
+            readonly token: "0xC139190F447e929f090Edeb554D95AbB8b18aC1C";
+        };
+        readonly 42161: {
+            readonly oft: "0xc708b6887db46005da033501f8aebee72d191a5d";
+            readonly token: "0xc708b6887db46005da033501f8aebee72d191a5d";
+        };
+        readonly 8453: {
+            readonly oft: "0xc708b6887db46005da033501f8aebee72d191a5d";
+            readonly token: "0xc708b6887db46005da033501f8aebee72d191a5d";
+        };
+    };
+};
+/**
+ * Uniswap V3 SwapRouter addresses per chain.
+ * Used by curator swap helpers to build calldata for on-chain swaps.
+ *
+ * Note on struct differences:
+ *   - SwapRouter (Eth/Arb/Op, 0xE592...): exactInputSingle struct includes `deadline`
+ *   - SwapRouter02 (Base, 0x2626...): exactInputSingle struct does NOT include `deadline`
+ *   - FlowSwap V3 (Flow EVM, 0xeEDC...): derived from original UniV3, includes `deadline`
+ */
+declare const UNISWAP_V3_ROUTERS: Record<number, string>;
 /**
  * Recommended timeouts for cross-chain operations (milliseconds).
  * UIs should show a progress indicator and NOT timeout before these values.
@@ -107,6 +422,104 @@ interface CrossChainRequestInfo {
     finalizationResult: bigint;
     amountLimit: bigint;
 }
+interface SwapParams {
+    targetContract: string;
+    tokenIn: string;
+    tokenOut: string;
+    maxAmountIn: bigint;
+    minAmountOut: bigint;
+    swapCallData: string;
+}
+interface BatchSwapParams {
+    swaps: SwapParams[];
+}
+interface BridgeParams {
+    oftToken: string;
+    dstEid: number;
+    amount: bigint;
+    dstVault: string;
+    refundAddress: string;
+}
+interface PendingAction {
+    nonce: bigint;
+    actionsData: string[];
+    pendingUntil: bigint;
+    isExecutable: boolean;
+}
+interface SubmitActionsResult {
+    receipt: ContractTransactionReceipt;
+    nonce: bigint;
+}
+type CuratorAction = {
+    type: 'swap';
+    params: SwapParams;
+} | {
+    type: 'batchSwap';
+    params: BatchSwapParams;
+} | {
+    type: 'erc4626Deposit';
+    vault: string;
+    assets: bigint;
+} | {
+    type: 'erc4626Redeem';
+    vault: string;
+    shares: bigint;
+} | {
+    type: 'erc7540RequestDeposit';
+    vault: string;
+    assets: bigint;
+} | {
+    type: 'erc7540Deposit';
+    vault: string;
+    assets: bigint;
+} | {
+    type: 'erc7540RequestRedeem';
+    vault: string;
+    shares: bigint;
+} | {
+    type: 'erc7540Redeem';
+    vault: string;
+    shares: bigint;
+};
+interface CuratorVaultStatus {
+    curator: string;
+    timeLockPeriod: bigint;
+    maxSlippagePercent: bigint;
+    currentNonce: bigint;
+    availableAssets: string[];
+    lzAdapter: string;
+    paused: boolean;
+}
+interface AssetInfo {
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+}
+interface VaultAnalysis {
+    /** All tokens the vault can hold/swap (curator-managed) */
+    availableAssets: AssetInfo[];
+    /** Tokens users can deposit */
+    depositableAssets: AssetInfo[];
+    /** Whether deposit whitelist is enabled (restricts who can deposit) */
+    depositWhitelistEnabled: boolean;
+    /** Registry address for global protocol whitelist checks */
+    registryAddress: string | null;
+}
+interface AssetBalance extends AssetInfo {
+    /** Raw balance held by the vault */
+    balance: bigint;
+}
+interface VaultAssetBreakdown {
+    /** Per-asset balances held by the vault on the hub chain */
+    assets: AssetBalance[];
+    /** totalAssets() as reported by the vault (all positions converted to underlying) */
+    totalAssets: bigint;
+    /** totalSupply() of vault shares */
+    totalSupply: bigint;
+    /** Vault underlying token decimals */
+    underlyingDecimals: number;
+}
 
 /**
  * Human-readable ABI fragments for MoreVaults diamond facets.
@@ -119,6 +532,42 @@ declare const METADATA_ABI: readonly ["function name() view returns (string)", "
 declare const ERC20_ABI: readonly ["function approve(address spender, uint256 amount) returns (bool)", "function allowance(address owner, address spender) view returns (uint256)", "function balanceOf(address account) view returns (uint256)", "function transfer(address to, uint256 amount) returns (bool)"];
 declare const OFT_ABI: readonly ["function send(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, tuple(uint256 nativeFee, uint256 lzTokenFee) fee, address refundAddress) payable returns (tuple(bytes32 guid, uint64 nonce, uint256 amountSentLD, uint256 amountReceivedLD) receipt, tuple(uint256 nativeFee, uint256 lzTokenFee) fee)", "function quoteSend(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, bool payInLzToken) view returns (tuple(uint256 nativeFee, uint256 lzTokenFee))"];
 declare const LZ_ENDPOINT_ABI: readonly ["function composeQueue(address from, address to, bytes32 guid, uint16 index) view returns (bytes32 messageHash)", "function lzCompose(address _from, address _to, bytes32 _guid, uint16 _index, bytes _message, bytes _extraData) payable"];
+/**
+ * MulticallFacet ABI — curator action submission and execution with timelock.
+ */
+declare const MULTICALL_ABI: readonly ["function submitActions(bytes[] actionsData) returns (uint256 nonce)", "function executeActions(uint256 actionsNonce)", "function getPendingActions(uint256 actionsNonce) view returns (bytes[] actionsData, uint256 pendingUntil)", "function getCurrentNonce() view returns (uint256)", "function vetoActions(uint256[] actionsNonces)"];
+/**
+ * GenericDexFacet ABI — single and batch token swaps through any DEX aggregator.
+ */
+declare const DEX_ABI: readonly ["function executeSwap(tuple(address targetContract, address tokenIn, address tokenOut, uint256 maxAmountIn, uint256 minAmountOut, bytes swapCallData) params) returns (uint256 amountOut)", "function executeBatchSwap(tuple(tuple(address targetContract, address tokenIn, address tokenOut, uint256 maxAmountIn, uint256 minAmountOut, bytes swapCallData)[] swaps) params) returns (uint256[] amountsOut)"];
+/**
+ * BridgeFacet ABI — curator bridging and cross-chain request initiation.
+ */
+declare const BRIDGE_FACET_ABI: readonly ["function executeBridging(address adapter, address token, uint256 amount, bytes bridgeSpecificParams) payable", "function initVaultActionRequest(uint8 actionType, bytes actionCallData, uint256 amountLimit, bytes extraOptions) payable returns (bytes32 guid)", "function executeRequest(bytes32 guid)"];
+/**
+ * ERC7540Facet ABI — async deposit and redeem operations on ERC7540 vaults.
+ */
+declare const ERC7540_FACET_ABI: readonly ["function erc7540RequestDeposit(address vault, uint256 assets) returns (uint256 requestId)", "function erc7540RequestRedeem(address vault, uint256 shares) returns (uint256 requestId)", "function erc7540Deposit(address vault, uint256 assets) returns (uint256 shares)", "function erc7540Redeem(address vault, uint256 shares) returns (uint256 assets)"];
+/**
+ * ERC4626Facet ABI — synchronous deposit and redeem into whitelisted ERC-4626 vaults.
+ */
+declare const ERC4626_FACET_ABI: readonly ["function erc4626Deposit(address vault, uint256 assets) returns (uint256 shares)", "function erc4626Redeem(address vault, uint256 shares) returns (uint256 assets)"];
+/**
+ * ConfigurationFacet ABI — extended with curator-relevant read functions.
+ */
+declare const CURATOR_CONFIG_ABI: readonly ["function curator() view returns (address)", "function timeLockPeriod() view returns (uint256)", "function getAvailableAssets() view returns (address[])", "function getMaxSlippagePercent() view returns (uint256)", "function getCrossChainAccountingManager() view returns (address)", "function paused() view returns (bool)"];
+/**
+ * LzAdapter ABI — fee quoting for bridge and LZ Read operations.
+ */
+declare const LZ_ADAPTER_ABI: readonly ["function quoteBridgeFee(bytes bridgeSpecificParams) view returns (uint256 nativeFee)", "function quoteReadFee(address[] vaults, uint32[] eids, bytes _extraOptions) view returns (tuple(uint256 nativeFee, uint256 lzTokenFee) fee)"];
+/**
+ * Vault analysis ABIs — per-vault whitelist and registry reads.
+ */
+declare const VAULT_ANALYSIS_ABI: readonly ["function getAvailableAssets() view returns (address[])", "function getDepositableAssets() view returns (address[])", "function isAssetAvailable(address asset) view returns (bool)", "function isAssetDepositable(address asset) view returns (bool)", "function isDepositWhitelistEnabled() view returns (bool)", "function getAvailableToDeposit(address depositor) view returns (uint256)", "function moreVaultsRegistry() view returns (address)"];
+/**
+ * MoreVaultsRegistry ABI — global protocol and bridge whitelist checks.
+ */
+declare const REGISTRY_ABI: readonly ["function isWhitelisted(address protocol) view returns (bool)", "function isBridgeAllowed(address bridge) view returns (bool)", "function getAllowedFacets() view returns (address[])"];
 
 /**
  * Typed error classes for the MoreVaults SDK.
@@ -331,6 +780,50 @@ declare function quoteComposeFee(provider: Provider, vault: string, spokeEid?: n
 declare function executeCompose(signer: Signer, from: string, to: string, guid: string, message: string, fee: bigint, index?: number): Promise<{
     receipt: ContractTransactionReceipt;
 }>;
+/**
+ * Data needed to execute a pending LZ compose on the hub chain.
+ * Returned by `depositFromSpoke` when the OFT is a Stargate V2 pool.
+ * The SDK user must call `executeCompose()` with this data as TX2 on the hub.
+ */
+interface ComposeData {
+    /** LZ Endpoint address on the hub chain */
+    endpoint: string;
+    /** The OFT/pool address that sent the compose (Stargate pool on hub) — resolved by waitForCompose */
+    from: string;
+    /** MoreVaultsComposer address on the hub */
+    to: string;
+    /** LayerZero GUID from the original OFT.send() */
+    guid: string;
+    /** Compose index (default 0) */
+    index: number;
+    /** Full compose message bytes — resolved by waitForCompose from ComposeSent event */
+    message: string;
+    /** Whether this is a Stargate OFT (2-TX flow) */
+    isStargate: boolean;
+    /** Hub chain ID */
+    hubChainId: number;
+    /** Block number on hub chain right before depositFromSpoke TX — used to bound event scan */
+    hubBlockStart: bigint;
+}
+/**
+ * Wait for a pending compose to appear in the LZ Endpoint's composeQueue on the hub chain.
+ *
+ * After `depositFromSpoke` sends tokens via Stargate, the LZ network delivers the message
+ * to the hub chain. The endpoint stores the compose hash in `composeQueue` and emits
+ * a `ComposeSent` event with the full message bytes.
+ *
+ * Strategy: scan ComposeSent events on the LZ Endpoint starting from `hubBlockStart`
+ * (captured by `depositFromSpoke` right before TX1). We scan forward in 500-block chunks,
+ * matching by composer address and receiver in the message body.
+ *
+ * @param hubProvider      Read-only provider on the HUB chain
+ * @param composeData      Partial compose data (includes hubBlockStart, to, guid)
+ * @param receiver         Receiver address to match in the compose message
+ * @param pollIntervalMs   Polling interval (default 20s)
+ * @param timeoutMs        Timeout (default 30 min)
+ * @returns                Complete ComposeData ready for executeCompose
+ */
+declare function waitForCompose(hubProvider: Provider, composeData: ComposeData, receiver: string, pollIntervalMs?: number, timeoutMs?: number): Promise<ComposeData>;
 
 /**
  * Redeem `shares` for underlying assets.
@@ -464,6 +957,52 @@ declare function smartRedeem(signer: Signer, addresses: VaultAddresses, shares:
 declare function bridgeAssetsToSpoke(signer: Signer, assetOFT: string, spokeChainEid: number, amount: bigint, receiver: string, lzFee: bigint, isStargate?: boolean): Promise<{
     receipt: ContractTransactionReceipt;
 }>;
+interface SpokeRedeemRoute {
+    /** Hub chain ID */
+    hubChainId: number;
+    /** Spoke chain ID */
+    spokeChainId: number;
+    /** LZ EID for the hub */
+    hubEid: number;
+    /** LZ EID for the spoke */
+    spokeEid: number;
+    /** Vault underlying asset address on hub */
+    hubAsset: string;
+    /** SHARE_OFT on spoke chain */
+    spokeShareOft: string;
+    /** Asset OFT on hub for bridging back */
+    hubAssetOft: string;
+    /** Underlying asset address on spoke chain */
+    spokeAsset: string;
+    /** Whether the asset OFT is a Stargate pool */
+    isStargate: boolean;
+    /** OFT route symbol (e.g. 'stgUSDC') */
+    symbol: string;
+}
+/**
+ * Quote the LZ fee for bridging shares from spoke to hub via SHARE_OFT.
+ *
+ * IMPORTANT: `amountLD` must be in SHARE_OFT native decimals (e.g. 18),
+ * NOT vault decimals (e.g. 8). Use the raw `SHARE_OFT.balanceOf(user)` value.
+ *
+ * @param spokeProvider  Read-only provider on the SPOKE chain
+ * @param shareOFT       SHARE_OFT address on the spoke chain
+ * @param hubChainEid    LayerZero Endpoint ID for the hub chain
+ * @param amountLD       Shares in SHARE_OFT native decimals (raw balanceOf)
+ * @param receiver       Receiver address on the hub chain
+ * @returns              LZ native fee in wei
+ */
+declare function quoteShareBridgeFee(spokeProvider: Provider, shareOFT: string, hubChainEid: number, amountLD: bigint, receiver: string): Promise<bigint>;
+/**
+ * Resolve all addresses needed for a full spoke→hub→spoke redeem flow.
+ *
+ * @param hubProvider  Read-only provider on the HUB chain
+ * @param vault        Vault address
+ * @param hubChainId   Hub chain ID
+ * @param spokeChainId Spoke chain ID where user has shares
+ * @returns            All addresses needed for bridgeSharesToHub + redeemShares + bridgeAssetsToSpoke
+ */
+declare function resolveRedeemAddresses(hubProvider: Provider, vault: string, hubChainId: number, spokeChainId: number): Promise<SpokeRedeemRoute>;
 
 /**
  * Utility helpers for the MoreVaults ethers.js v6 SDK.
@@ -586,6 +1125,17 @@ declare function getAsyncRequestStatus(provider: Provider, vault: string, guid:
  * @returns         Full vault status snapshot
  */
 declare function getVaultStatus(provider: Provider, vault: string): Promise<VaultStatus>;
+/**
+ * Detect whether an OFT address is a Stargate V2 pool by calling `stargateType()`.
+ *
+ * Stargate pools implement this function (returns 0=Pool, 1=OFT).
+ * Standard OFTs revert because they don't have it.
+ *
+ * @param provider  Read-only provider on the OFT's chain
+ * @param oft       OFT contract address
+ * @returns         true if the contract is a Stargate V2 pool/OFT
+ */
+declare function detectStargateOft(provider: Provider, oft: string): Promise<boolean>;
 
 /**
  * Pre-flight validation helpers for MoreVaults ethers.js v6 SDK flows.
@@ -640,6 +1190,63 @@ declare function preflightRedeemLiquidity(provider: Provider, vault: string, sha
  * @param vault     Vault address (diamond proxy)
  */
 declare function preflightSync(provider: Provider, vault: string): Promise<void>;
+/**
+ * Pre-flight checks for spoke-to-hub deposits (D6 / D7 via OFT Compose).
+ *
+ * Validates that:
+ * 1. User has enough tokens on the spoke chain to deposit.
+ * 2. User has enough native gas on the spoke chain for TX1 (OFT.send).
+ * 3. For Stargate OFTs (2-TX flow): user has enough ETH on the hub chain for TX2.
+ *
+ * @param spokeProvider  Read-only provider on the SPOKE chain
+ * @param vault          Vault address
+ * @param spokeOFT       OFT contract address on the spoke chain
+ * @param hubEid         LZ EID for the hub chain
+ * @param spokeEid       LZ EID for the spoke chain
+ * @param amount         Amount of tokens to deposit
+ * @param userAddress    User's wallet address
+ * @param lzFee          LZ fee for TX1 (from quoteDepositFromSpokeFee)
+ * @returns              Object with validated balances for UI display
+ */
+declare function preflightSpokeDeposit(spokeProvider: Provider, vault: string, spokeOFT: string, hubEid: number, spokeEid: number, amount: bigint, userAddress: string, lzFee: bigint): Promise<{
+    spokeTokenBalance: bigint;
+    spokeNativeBalance: bigint;
+    hubNativeBalance: bigint;
+    estimatedComposeFee: bigint;
+    isStargate: boolean;
+}>;
+/**
+ * Pre-flight checks for spoke→hub→spoke redeem (R6 + R1 + R7).
+ *
+ * Validates that:
+ * 1. User has shares on the spoke chain.
+ * 2. User has enough native gas on the spoke for TX1.
+ * 3. User has enough native gas on the hub for TX2 (redeem) + TX3 (asset bridge).
+ *
+ * @param route           SpokeRedeemRoute from resolveRedeemAddresses
+ * @param shares          Shares the user intends to redeem
+ * @param userAddress     User's wallet address
+ * @param shareBridgeFee  LZ fee for share bridge (TX1)
+ * @returns               Validated balances for UI display
+ */
+declare function preflightSpokeRedeem(route: {
+    hubChainId: number;
+    spokeChainId: number;
+    hubEid: number;
+    spokeEid: number;
+    hubAsset: string;
+    spokeShareOft: string;
+    hubAssetOft: string;
+    spokeAsset: string;
+    isStargate: boolean;
+}, shares: bigint, userAddress: string, shareBridgeFee: bigint): Promise<{
+    sharesOnSpoke: bigint;
+    spokeNativeBalance: bigint;
+    hubNativeBalance: bigint;
+    estimatedAssetBridgeFee: bigint;
+    estimatedAssetsOut: bigint;
+    hubLiquidBalance: bigint;
+}>;
 
 /**
  * User-facing helper functions for the MoreVaults ethers.js v6 SDK.
@@ -781,6 +1388,545 @@ type VaultSummary = VaultStatus & VaultMetadata;
  * @returns         Merged VaultStatus and VaultMetadata
  */
 declare function getVaultSummary(provider: Provider, vault: string): Promise<VaultSummary>;
+interface MultiChainUserPosition {
+    /** Shares held directly on the hub vault (vault.balanceOf) */
+    hubShares: bigint;
+    /** Per-spoke SHARE_OFT balances normalized to vault decimals: { [chainId]: bigint } */
+    spokeShares: Record<number, bigint>;
+    /** Per-spoke SHARE_OFT raw balances in OFT native decimals: { [chainId]: bigint }
+     *  Use these for bridgeSharesToHub() and quoteShareBridgeFee() */
+    rawSpokeShares: Record<number, bigint>;
+    /** hubShares + sum of all spokeShares (in vault decimals) */
+    totalShares: bigint;
+    /** convertToAssets(totalShares) on the hub */
+    estimatedAssets: bigint;
+    /** Share price: convertToAssets(10^decimals) */
+    sharePrice: bigint;
+    /** Vault decimals */
+    decimals: number;
+    /** Pending async withdrawal request on hub, or null */
+    pendingWithdrawal: {
+        shares: bigint;
+        timelockEndsAt: bigint;
+        canRedeemNow: boolean;
+    } | null;
+}
+/**
+ * Read the user's position across all chains of an omni vault.
+ *
+ * Discovers topology automatically, reads hub shares + pending withdrawal,
+ * then reads SHARE_OFT balances on each spoke chain in parallel.
+ *
+ * For local (single-chain) vaults, spokeShares will be empty and this
+ * behaves identically to getUserPosition.
+ *
+ * @param vault  Vault address (same on all chains via CREATE3)
+ * @param user   User wallet address
+ * @returns      Aggregated position across all chains
+ */
+declare function getUserPositionMultiChain(vault: string, user: string): Promise<MultiChainUserPosition>;
+
+/**
+ * Curator / vault-manager read helpers for the MoreVaults ethers.js v6 SDK.
+ *
+ * All functions are read-only (no wallet needed) and use Multicall3 for
+ * batched RPC efficiency.
+ */
+
+/**
+ * Read a comprehensive status snapshot for the curator dashboard.
+ *
+ * Fetches in one multicall batch:
+ *   curator, timeLockPeriod, getMaxSlippagePercent, getCurrentNonce,
+ *   getAvailableAssets, getCrossChainAccountingManager, paused
+ *
+ * @param provider  Read-only provider (must be on the vault's chain)
+ * @param vault     Vault address (diamond proxy)
+ * @returns         CuratorVaultStatus snapshot
+ */
+declare function getCuratorVaultStatus(provider: Provider, vault: string): Promise<CuratorVaultStatus>;
+/**
+ * Fetch pending actions for a specific nonce and resolve whether they are
+ * executable (i.e. the timelock has expired).
+ *
+ * @param provider  Read-only provider (must be on the vault's chain)
+ * @param vault     Vault address (diamond proxy)
+ * @param nonce     Action nonce to query
+ * @returns         PendingAction with isExecutable flag set
+ */
+declare function getPendingActions(provider: Provider, vault: string, nonce: bigint): Promise<PendingAction>;
+/**
+ * Check whether a given address is the curator of the vault.
+ *
+ * @param provider  Read-only provider (must be on the vault's chain)
+ * @param vault     Vault address (diamond proxy)
+ * @param address   Address to check
+ * @returns         true if address is the current curator
+ */
+declare function isCurator(provider: Provider, vault: string, address: string): Promise<boolean>;
+/**
+ * Full vault analysis — available assets with metadata, depositable assets, whitelist config.
+ * Useful for curator dashboards to understand what the vault can do.
+ *
+ * @param provider  Read-only provider (must be on the vault's chain)
+ * @param vault     Vault address (diamond proxy)
+ * @returns         VaultAnalysis snapshot
+ */
+declare function getVaultAnalysis(provider: Provider, vault: string): Promise<VaultAnalysis>;
+/**
+ * Check if specific protocol addresses are whitelisted in the global registry.
+ * Useful for curators to verify DEX routers before building swap calldata.
+ *
+ * @param provider   Read-only provider (must be on the vault's chain)
+ * @param vault      Vault address (diamond proxy)
+ * @param protocols  Protocol addresses to check
+ * @returns          Record mapping address → whitelisted boolean
+ */
+declare function checkProtocolWhitelist(provider: Provider, vault: string, protocols: string[]): Promise<Record<string, boolean>>;
+/**
+ * Get the vault's per-asset balance breakdown on the hub chain.
+ *
+ * Returns the balance of every available asset held by the vault, plus
+ * totalAssets and totalSupply for context. Useful for portfolio views
+ * that need to show individual holdings rather than a single USD-denominated total.
+ *
+ * @param provider  Read-only provider (must be on the vault's hub chain)
+ * @param vault     Vault address (diamond proxy)
+ * @returns         VaultAssetBreakdown with per-asset balances
+ */
+declare function getVaultAssetBreakdown(provider: Provider, vault: string): Promise<VaultAssetBreakdown>;
+
+/**
+ * Curator MulticallFacet write operations for the MoreVaults ethers.js v6 SDK.
+ *
+ * Provides typed helpers to submit, execute, and veto curator action batches
+ * on any MoreVaults diamond that has the MulticallFacet installed.
+ *
+ * @module curatorMulticall
+ */
+
+/**
+ * Encode a single typed CuratorAction into raw calldata bytes suitable for
+ * passing into `submitActions(bytes[] actionsData)`.
+ *
+ * The encoded bytes are the full ABI-encoded function call (4-byte selector +
+ * arguments) targeting the vault diamond itself — the MulticallFacet will
+ * call `address(this).call(actionsData[i])` for each entry.
+ *
+ * @param action  A discriminated-union CuratorAction describing what to do
+ * @returns       ABI-encoded calldata hex string
+ */
+declare function encodeCuratorAction(action: CuratorAction): string;
+/**
+ * Encode an array of CuratorActions into a calldata array ready for
+ * `submitActions`.
+ *
+ * @param actions  Array of typed CuratorAction objects
+ * @returns        Array of ABI-encoded calldata hex strings
+ */
+declare function buildCuratorBatch(actions: CuratorAction[]): string[];
+/**
+ * Submit a batch of curator actions to the vault's MulticallFacet.
+ *
+ * When `timeLockPeriod == 0` the contract immediately executes the actions
+ * inside `submitActions` itself. When a timelock is configured the actions
+ * are queued and must be executed later with `executeActions`.
+ *
+ * After the write succeeds, reads `getCurrentNonce` to determine which nonce
+ * was assigned (nonce - 1 after the submit increments it).
+ *
+ * @param signer   Signer with curator account attached
+ * @param vault    Vault address (diamond proxy)
+ * @param actions  Array of raw calldata bytes — use `buildCuratorBatch` to build
+ * @returns        Receipt and the nonce assigned to this batch
+ */
+declare function submitActions(signer: Signer, vault: string, actions: string[]): Promise<SubmitActionsResult>;
+/**
+ * Execute pending actions after their timelock period has expired.
+ *
+ * Can only be called when `block.timestamp >= pendingUntil`. The contract
+ * reverts with `ActionsStillPending` if the timelock has not expired.
+ *
+ * @param signer  Signer with curator account attached
+ * @param vault   Vault address (diamond proxy)
+ * @param nonce   The action batch nonce to execute
+ * @returns       Transaction receipt
+ */
+declare function executeActions(signer: Signer, vault: string, nonce: bigint): Promise<ContractTransactionReceipt>;
+/**
+ * Guardian-only: cancel (veto) one or more pending action batches.
+ *
+ * Deletes the pending actions from storage, preventing them from ever being
+ * executed. Only the vault guardian can call this.
+ *
+ * @param signer   Signer with guardian account attached
+ * @param vault    Vault address (diamond proxy)
+ * @param nonces   Array of action nonces to cancel
+ * @returns        Transaction receipt
+ */
+declare function vetoActions(signer: Signer, vault: string, nonces: bigint[]): Promise<ContractTransactionReceipt>;
+
+/**
+ * Curator swap helpers for Uniswap V3-compatible DEXes.
+ *
+ * Provides typed helpers to build CuratorAction objects and raw calldata for
+ * Uniswap V3 exactInputSingle swaps, automatically resolving the correct router
+ * and ABI variant (SwapRouter vs SwapRouter02) per chain.
+ *
+ * Supported chains and routers:
+ *   - Base (8453):        SwapRouter02 0x2626...  — NO deadline field
+ *   - Ethereum (1):       SwapRouter   0xE592...  — HAS deadline field
+ *   - Arbitrum (42161):   SwapRouter   0xE592...  — HAS deadline field
+ *   - Optimism (10):      SwapRouter   0xE592...  — HAS deadline field
+ *   - Flow EVM (747):     FlowSwap V3  0xeEDC...  — HAS deadline field
+ *
+ * @module curatorSwaps
+ */
+
+/**
+ * Encode Uniswap V3 exactInputSingle calldata directly.
+ * For curators who want raw calldata without the CuratorAction wrapper.
+ *
+ * Automatically selects the correct ABI variant (SwapRouter vs SwapRouter02)
+ * based on the chainId. The deadline (for SwapRouter chains) is set to
+ * `now + 20 minutes` to prevent stale transactions from executing.
+ *
+ * @param params.chainId       EVM chain ID — must be present in UNISWAP_V3_ROUTERS
+ * @param params.tokenIn       Input token address
+ * @param params.tokenOut      Output token address
+ * @param params.fee           Pool fee tier: 100, 500, 3000, or 10000
+ * @param params.amountIn      Exact input amount (in tokenIn units)
+ * @param params.minAmountOut  Minimum acceptable output (slippage protection)
+ * @param params.recipient     Address to receive the output tokens (usually the vault)
+ * @returns                    The router contract address and ABI-encoded calldata
+ * @throws                     If no router is configured for the given chainId
+ */
+declare function encodeUniswapV3SwapCalldata(params: {
+    chainId: number;
+    tokenIn: string;
+    tokenOut: string;
+    fee: number;
+    amountIn: bigint;
+    minAmountOut: bigint;
+    recipient: string;
+}): {
+    targetContract: string;
+    swapCallData: string;
+};
+/**
+ * Build a CuratorAction for a Uniswap V3 exactInputSingle swap.
+ *
+ * Automatically resolves the router address from UNISWAP_V3_ROUTERS and
+ * selects the correct ABI struct (with or without deadline) based on chainId.
+ *
+ * The returned action is a `swap` variant ready to be passed to
+ * `buildCuratorBatch` and then `submitActions`.
+ *
+ * @param params.chainId       EVM chain ID — must be present in UNISWAP_V3_ROUTERS
+ * @param params.tokenIn       Input token address
+ * @param params.tokenOut      Output token address
+ * @param params.fee           Pool fee tier: 100, 500, 3000, or 10000
+ * @param params.amountIn      Exact input amount (in tokenIn units)
+ * @param params.minAmountOut  Minimum acceptable output (slippage protection)
+ * @param params.recipient     Address to receive output tokens (usually the vault)
+ * @returns                    A typed CuratorAction ready for buildCuratorBatch
+ * @throws                     If no router is configured for the given chainId
+ *
+ * @example
+ * ```typescript
+ * const action = buildUniswapV3Swap({
+ *   chainId: 8453,
+ *   tokenIn:  '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC
+ *   tokenOut: '0x4200000000000000000000000000000000000006', // WETH
+ *   fee: 500,           // 0.05% pool
+ *   amountIn: 150_000n, // 0.15 USDC (6 decimals)
+ *   minAmountOut: 1n,   // accept any amount (set properly in production)
+ *   recipient: VAULT,
+ * })
+ * const batch = buildCuratorBatch([action])
+ * await submitActions(signer, vault, batch)
+ * ```
+ */
+declare function buildUniswapV3Swap(params: {
+    chainId: number;
+    tokenIn: string;
+    tokenOut: string;
+    fee: number;
+    amountIn: bigint;
+    minAmountOut: bigint;
+    recipient: string;
+}): CuratorAction;
+
+/**
+ * Vault topology helpers for the MoreVaults ethers.js v6 SDK.
+ *
+ * Resolves the cross-chain hub/spoke structure of a vault using the
+ * MoreVaults OmniFactory contract (same address on every supported chain via CREATE3).
+ */
+
+declare const OMNI_FACTORY_ADDRESS = "0x7bDB8B17604b03125eFAED33cA0c55FBf856BB0C";
+interface VaultTopology {
+    /**
+     * Role of this vault on the chain you queried:
+     * - 'hub'   → this chain holds the TVL, users deposit here
+     * - 'spoke' → this chain is a yield deployment; deposits go to the hub
+     * - 'local' → single-chain vault, no cross-chain setup
+     */
+    role: "hub" | "spoke" | "local";
+    /** Chain ID where the hub lives. Same as the queried chain when role='hub'. */
+    hubChainId: number;
+    /**
+     * All spoke chain IDs registered under this hub.
+     * Empty when role='local'.
+     * Since vaults are CREATE3-deployed, the vault address is the same on all chains.
+     */
+    spokeChainIds: number[];
+}
+/**
+ * Resolve the cross-chain topology of a vault: hub chain + all spoke chains.
+ *
+ * Works for hub vaults, spoke vaults, and local (single-chain) vaults.
+ * Because MoreVaults uses CREATE3, the vault address is identical on every chain —
+ * only the chain IDs differ.
+ *
+ * @param provider       Connected to the chain you want to inspect
+ * @param vault          Vault address (same on all chains)
+ * @param factoryAddress MoreVaults factory (defaults to OMNI_FACTORY_ADDRESS)
+ *
+ * @example
+ * // Querying from Base — will detect hub + Ethereum/Arbitrum spokes
+ * const topo = await getVaultTopology(baseProvider, '0x8f740...')
+ * // { role: 'hub', hubChainId: 8453, spokeChainIds: [1, 42161] }
+ *
+ * // Querying from Ethereum — same vault is a spoke there
+ * const topo = await getVaultTopology(ethProvider, '0x8f740...')
+ * // { role: 'spoke', hubChainId: 8453, spokeChainIds: [1, 42161] }
+ */
+declare function getVaultTopology(provider: Provider, vault: string, factoryAddress?: string): Promise<VaultTopology>;
+/**
+ * Resolve the FULL topology of a vault by querying the hub chain directly.
+ *
+ * Provide a provider connected to the hub chain for complete spoke data.
+ * If you don't know which chain is the hub, call `getVaultTopology` first
+ * from any chain and use the returned `hubChainId` to create the hub provider.
+ *
+ * @param hubChainProvider  Provider connected to the hub chain
+ * @param vault             Vault address
+ * @param factoryAddress    MoreVaults factory (defaults to OMNI_FACTORY_ADDRESS)
+ */
+declare function getFullVaultTopology(hubChainProvider: Provider, vault: string, factoryAddress?: string): Promise<VaultTopology>;
+/**
+ * Discover a vault's topology across all supported chains.
+ *
+ * Unlike `getVaultTopology` (which queries a single chain), this function
+ * automatically iterates all supported chains when the initial query returns
+ * `role: "local"`. This handles the case where the caller doesn't know which
+ * chain the vault is deployed on, or when no provider is connected.
+ *
+ * If a `provider` is provided, it's tried first. If that returns "local",
+ * every other supported chain is probed via public RPCs.
+ * If no `provider` is provided, all chains are probed.
+ *
+ * Once a hub is found, `getFullVaultTopology` is called to get the complete
+ * spoke list.
+ *
+ * @param vault          Vault address (same on all chains via CREATE3)
+ * @param provider       Optional — provider for the "preferred" chain to try first
+ * @param factoryAddress MoreVaults factory (defaults to OMNI_FACTORY_ADDRESS)
+ *
+ * @example
+ * // No wallet connected — discovers that 0x8f74... is hub on Base
+ * const topo = await discoverVaultTopology('0x8f740...')
+ * // { role: 'hub', hubChainId: 8453, spokeChainIds: [1, 42161] }
+ */
+declare function discoverVaultTopology(vault: string, provider?: Provider | null, factoryAddress?: string): Promise<VaultTopology>;
+/**
+ * Check if a wallet is connected to the hub chain for a given vault.
+ * Useful for showing a "Switch to Base" prompt before deposit.
+ *
+ * @param currentChainId  Chain ID the wallet is currently connected to
+ * @param topology        Result of getVaultTopology
+ */
+declare function isOnHubChain(currentChainId: number, topology: VaultTopology): boolean;
+/**
+ * Get all chain IDs where this vault is deployed (hub + all spokes).
+ */
+declare function getAllVaultChainIds(topology: VaultTopology): number[];
+
+/**
+ * Vault distribution helpers for the MoreVaults ethers.js v6 SDK.
+ *
+ * Reads the cross-chain capital distribution of a vault: hub balance,
+ * spoke balances, and aggregate totals.
+ */
+
+interface SpokeBalance {
+    chainId: number;
+    totalAssets: bigint;
+    /** false if the RPC call to this spoke failed */
+    isReachable: boolean;
+}
+interface VaultDistribution {
+    hubChainId: number;
+    /** Underlying token balance idle on the hub (not deployed to strategies) */
+    hubLiquidBalance: bigint;
+    /** Hub totalAssets minus hubLiquidBalance (capital in Morpho, Aave, etc.) */
+    hubStrategyBalance: bigint;
+    /** Hub vault totalAssets() */
+    hubTotalAssets: bigint;
+    /** What the hub's accounting thinks is deployed on spokes */
+    spokesDeployedBalance: bigint;
+    /** Actual per-spoke balances read directly from each spoke chain */
+    spokeBalances: SpokeBalance[];
+    /** hubTotalAssets + sum of reachable spoke totalAssets */
+    totalActual: bigint;
+    oracleAccountingEnabled: boolean;
+}
+/**
+ * Read the full cross-chain capital distribution of a vault.
+ *
+ * Queries the hub for its status, then reads `totalAssets()` on each spoke
+ * chain in parallel. Spoke calls are individually wrapped so a single
+ * unreachable RPC never fails the entire call.
+ *
+ * @param hubProvider     Provider connected to the hub chain
+ * @param vault           Vault address (same on all chains via CREATE3)
+ * @param spokeProviders  Map of chainId → Provider for each spoke chain
+ *
+ * @example
+ * ```ts
+ * const dist = await getVaultDistribution(baseProvider, VAULT, {
+ *   [1]: ethProvider,
+ *   [42161]: arbProvider,
+ * })
+ * console.log(`Hub liquid: ${dist.hubLiquidBalance}`)
+ * console.log(`Total actual: ${dist.totalActual}`)
+ * ```
+ */
+declare function getVaultDistribution(hubProvider: Provider, vault: string, spokeProviders: Record<number, Provider>): Promise<VaultDistribution>;
+/**
+ * Hub-only distribution — uses topology to discover spokes but does NOT
+ * read spoke chains (no spoke providers needed).
+ *
+ * Returns hub data plus the list of spoke chainIds from the factory.
+ * `spokeBalances` will be empty — callers must provide spoke providers to
+ * `getVaultDistribution` for actual spoke reads.
+ *
+ * @param hubProvider  Provider connected to the hub chain
+ * @param vault        Vault address
+ *
+ * @example
+ * ```ts
+ * const dist = await getVaultDistributionWithTopology(baseProvider, VAULT)
+ * // dist.spokeBalances === [] (no spoke providers provided)
+ * // dist.spokeChainIds tells you which chains to query
+ * ```
+ */
+declare function getVaultDistributionWithTopology(hubProvider: Provider, vault: string): Promise<VaultDistribution & {
+    spokeChainIds: number[];
+}>;
+
+/**
+ * Spoke route helpers for the MoreVaults ethers.js v6 SDK.
+ *
+ * Provides functions to discover inbound/outbound cross-chain deposit and
+ * redemption routes, and to quote LayerZero fees for those routes.
+ */
+interface OutboundRoute {
+    /** Chain ID where user can receive shares/assets */
+    chainId: number;
+    /** Whether this chain is the hub (direct redeem) or a spoke (shares bridged back) */
+    routeType: "hub" | "spoke";
+    /** LZ EID for this chain */
+    eid: number;
+    /** Native gas symbol */
+    nativeSymbol: string;
+}
+interface InboundRoute {
+    /** Internal route identifier from OFT_ROUTES (e.g. 'stgUSDC') — do NOT show to users */
+    symbol: string;
+    /** Chain ID where user sends from */
+    spokeChainId: number;
+    /**
+     * How the deposit is executed:
+     * - 'direct'       → user is on the hub chain, vault uses standard ERC-4626 (depositSimple). No LZ fee.
+     * - 'direct-async' → user is on the hub chain, vault uses async accounting (depositAsync). LZ fee required.
+     * - 'oft-compose'  → user is on a spoke chain, use depositFromSpoke via OFT compose. LZ fee required.
+     */
+    depositType: "direct" | "direct-async" | "oft-compose";
+    /** OFT contract on spoke chain — pass as `spokeOFT` to depositFromSpoke. Null for direct deposits. */
+    spokeOft: string | null;
+    /** Token user must approve on spoke chain (ZeroAddress = native ETH) */
+    spokeToken: string;
+    /**
+     * Human-readable symbol of the token the user needs to hold on the spoke chain.
+     * For OFTAdapters this is the underlying token symbol (e.g. 'USDC', 'weETH').
+     * For pure OFTs this is the OFT's own symbol (e.g. 'sUSDe', 'USDe').
+     * Use this — not `symbol` — when displaying the token name to users.
+     */
+    sourceTokenSymbol: string;
+    /** OFT contract on hub chain — receives tokens for the composer. Null for direct deposits. */
+    hubOft: string | null;
+    /** oftCmd to use in SendParam (0x01 for Stargate taxi, 0x for standard OFT) */
+    oftCmd: string;
+    /** LZ fee estimate in native wei of the SPOKE chain (not always ETH — e.g. FLOW on Flow EVM) */
+    lzFeeEstimate: bigint;
+    /** Native gas token symbol for the spoke chain — use this when displaying the fee */
+    nativeSymbol: string;
+}
+interface InboundRouteWithBalance extends InboundRoute {
+    /** User's token balance on the spoke chain */
+    userBalance: bigint;
+}
+/** Native gas token symbol per chain ID — lzFeeEstimate is denominated in this token */
+declare const NATIVE_SYMBOL: Partial<Record<number, string>>;
+/**
+ * Find all valid OFT inbound routes for a vault.
+ *
+ * Only returns routes for chains where the vault has a registered spoke —
+ * this is required so the composer can send shares back to the user's chain.
+ * The hub chain is always included as a 'direct' deposit option.
+ *
+ * Routes that revert on quoteSend() (no liquidity, no peer) are excluded.
+ *
+ * @param hubChainId   Chain ID of the vault hub (e.g. 8453 for Base)
+ * @param vault        Vault address (to resolve registered spoke chains)
+ * @param vaultAsset   vault.asset() address on the hub chain
+ * @param userAddress  User address (used as receiver for fee quote)
+ */
+declare function getInboundRoutes(hubChainId: number, vault: string, vaultAsset: string, userAddress: string): Promise<InboundRoute[]>;
+/**
+ * Fetch user token balances for each inbound route in parallel.
+ * Routes with native ETH as token (ZeroAddress) return the chain's ETH balance.
+ *
+ * @param routes       Inbound routes from getInboundRoutes()
+ * @param userAddress  User wallet address
+ */
+declare function getUserBalancesForRoutes(routes: InboundRoute[], userAddress: string): Promise<InboundRouteWithBalance[]>;
+/**
+ * Find all outbound routes for a vault — chains where a user can receive
+ * shares/assets when redeeming.
+ *
+ * The hub chain is always first (direct redeem). Spoke chains follow
+ * (shares are bridged back via the composer).
+ *
+ * @param hubChainId  Chain ID of the vault hub (e.g. 8453 for Base)
+ * @param vault       Vault address (to resolve registered spoke chains)
+ */
+declare function getOutboundRoutes(hubChainId: number, vault: string): Promise<OutboundRoute[]>;
+/**
+ * Quote the LayerZero native fee for a cross-chain deposit with a real amount.
+ *
+ * More precise than the `lzFeeEstimate` field on `InboundRoute`, which uses
+ * a dummy 1 USDC amount.
+ *
+ * @param route       An InboundRoute from `getInboundRoutes()`
+ * @param hubChainId  Chain ID of the vault hub (needed for LZ destination EID)
+ * @param amount      Real deposit amount in token decimals
+ * @param userAddress User address (used as receiver for fee quote)
+ * @returns Native fee in wei of the spoke chain's gas token, or 0n for direct deposits
+ */
+declare function quoteRouteDepositFee(route: InboundRoute, hubChainId: number, amount: bigint, userAddress: string): Promise<bigint>;
 
 /**
  * Cast an ethers Signer (e.g. from wagmi's useEthersSigner adapter) to
@@ -795,4 +1941,4 @@ declare function getVaultSummary(provider: Provider, vault: string): Promise<Vau
  */
 declare function asSdkSigner(signer: unknown): Signer;
 
-export { ActionType, type ActionTypeValue, type AsyncRequestResult, type AsyncRequestStatus, type AsyncRequestStatusInfo, BRIDGE_ABI, CCManagerNotConfiguredError, CHAIN_IDS, CHAIN_ID_TO_EID, CONFIG_ABI, CapacityFullError, type CrossChainRequestInfo, type DepositBlockReason, type DepositEligibility, type DepositResult, EID_TO_CHAIN_ID, ERC20_ABI, EscrowNotConfiguredError, InsufficientLiquidityError, LZ_EIDS, LZ_ENDPOINT_ABI, LZ_TIMEOUTS, METADATA_ABI, type MaxWithdrawable, MissingEscrowAddressError, MoreVaultsError, NotHubVaultError, NotWhitelistedError, OFT_ABI, type RedeemResult, type UserBalances, type UserPosition, VAULT_ABI, type VaultAddresses, type VaultMetadata, type VaultMode, VaultPausedError, type VaultStatus, type VaultSummary, WrongChainError, asSdkSigner, bridgeAssetsToSpoke, bridgeSharesToHub, canDeposit, depositAsync, depositCrossChainOracleOn, depositFromSpoke, depositFromSpokeAsync, depositMultiAsset, depositSimple, ensureAllowance, executeCompose, getAsyncRequestStatus, getAsyncRequestStatusLabel, getMaxWithdrawable, getUserBalances, getUserPosition, getVaultMetadata, getVaultStatus, getVaultSummary, getWithdrawalRequest, isAsyncMode, mintAsync, preflightAsync, preflightRedeemLiquidity, preflightSync, previewDeposit, previewRedeem, quoteComposeFee, quoteDepositFromSpokeFee, quoteLzFee, redeemAsync, redeemShares, requestRedeem, smartDeposit, smartRedeem, withdrawAssets };
+export { ActionType, type ActionTypeValue, type AssetBalance, type AssetInfo, type AsyncRequestResult, type AsyncRequestStatus, type AsyncRequestStatusInfo, BRIDGE_ABI, BRIDGE_FACET_ABI, type BatchSwapParams, type BridgeParams, CCManagerNotConfiguredError, CHAIN_IDS, CHAIN_ID_TO_EID, CONFIG_ABI, CURATOR_CONFIG_ABI, CapacityFullError, type CrossChainRequestInfo, type CuratorAction, type CuratorVaultStatus, DEX_ABI, type DepositBlockReason, type DepositEligibility, type DepositResult, EID_TO_CHAIN_ID, ERC20_ABI, ERC4626_FACET_ABI, ERC7540_FACET_ABI, EscrowNotConfiguredError, type InboundRoute, type InboundRouteWithBalance, InsufficientLiquidityError, LZ_ADAPTER_ABI, LZ_EIDS, LZ_ENDPOINT_ABI, LZ_TIMEOUTS, METADATA_ABI, MULTICALL_ABI, type MaxWithdrawable, MissingEscrowAddressError, MoreVaultsError, type MultiChainUserPosition, NATIVE_SYMBOL, NotHubVaultError, NotWhitelistedError, OFT_ABI, OFT_ROUTES, OMNI_FACTORY_ADDRESS, type OutboundRoute, type PendingAction, REGISTRY_ABI, type RedeemResult, type SpokeBalance, type SpokeRedeemRoute, type SubmitActionsResult, type SwapParams, UNISWAP_V3_ROUTERS, type UserBalances, type UserPosition, VAULT_ABI, VAULT_ANALYSIS_ABI, type VaultAddresses, type VaultAnalysis, type VaultAssetBreakdown, type VaultDistribution, type VaultMetadata, type VaultMode, VaultPausedError, type VaultStatus, type VaultSummary, type VaultTopology, WrongChainError, asSdkSigner, bridgeAssetsToSpoke, bridgeSharesToHub, buildCuratorBatch, buildUniswapV3Swap, canDeposit, checkProtocolWhitelist, depositAsync, depositCrossChainOracleOn, depositFromSpoke, depositFromSpokeAsync, depositMultiAsset, depositSimple, detectStargateOft, discoverVaultTopology, encodeCuratorAction, encodeUniswapV3SwapCalldata, ensureAllowance, executeActions, executeCompose, getAllVaultChainIds, getAsyncRequestStatus, getAsyncRequestStatusLabel, getCuratorVaultStatus, getFullVaultTopology, getInboundRoutes, getMaxWithdrawable, getOutboundRoutes, getPendingActions, getUserBalances, getUserBalancesForRoutes, getUserPosition, getUserPositionMultiChain, getVaultAnalysis, getVaultAssetBreakdown, getVaultDistribution, getVaultDistributionWithTopology, getVaultMetadata, getVaultStatus, getVaultSummary, getVaultTopology, getWithdrawalRequest, isAsyncMode, isCurator, isOnHubChain, mintAsync, preflightAsync, preflightRedeemLiquidity, preflightSpokeDeposit, preflightSpokeRedeem, preflightSync, previewDeposit, previewRedeem, quoteComposeFee, quoteDepositFromSpokeFee, quoteLzFee, quoteRouteDepositFee, quoteShareBridgeFee, redeemAsync, redeemShares, requestRedeem, resolveRedeemAddresses, smartDeposit, smartRedeem, submitActions, vetoActions, waitForCompose, withdrawAssets };