@oydual31/more-vaults-sdk 0.3.3 → 0.4.1

package/dist/ethers/index.cjs

@@ -8,29 +8,356 @@ var CHAIN_IDS = {
   flowEVMTestnet: 545,
   arbitrum: 42161,
   base: 8453,
-  ethereum: 1
+  ethereum: 1,
+  optimism: 10,
+  sonic: 146,
+  bsc: 56
 };
 var LZ_EIDS = {
   flowMainnet: 30336,
   flowTestnet: 30333,
   arbitrum: 30110,
   base: 30184,
-  ethereum: 30101
+  ethereum: 30101,
+  optimism: 30111,
+  sonic: 30332,
+  bsc: 30102
 };
 var EID_TO_CHAIN_ID = {
   [LZ_EIDS.flowMainnet]: CHAIN_IDS.flowEVMMainnet,
   [LZ_EIDS.flowTestnet]: CHAIN_IDS.flowEVMTestnet,
   [LZ_EIDS.arbitrum]: CHAIN_IDS.arbitrum,
   [LZ_EIDS.base]: CHAIN_IDS.base,
-  [LZ_EIDS.ethereum]: CHAIN_IDS.ethereum
+  [LZ_EIDS.ethereum]: CHAIN_IDS.ethereum,
+  [LZ_EIDS.optimism]: CHAIN_IDS.optimism,
+  [LZ_EIDS.sonic]: CHAIN_IDS.sonic,
+  [LZ_EIDS.bsc]: CHAIN_IDS.bsc
 };
 var CHAIN_ID_TO_EID = {
   [CHAIN_IDS.flowEVMMainnet]: LZ_EIDS.flowMainnet,
   [CHAIN_IDS.flowEVMTestnet]: LZ_EIDS.flowTestnet,
   [CHAIN_IDS.arbitrum]: LZ_EIDS.arbitrum,
   [CHAIN_IDS.base]: LZ_EIDS.base,
-  [CHAIN_IDS.ethereum]: LZ_EIDS.ethereum
+  [CHAIN_IDS.ethereum]: LZ_EIDS.ethereum,
+  [CHAIN_IDS.optimism]: LZ_EIDS.optimism,
+  [CHAIN_IDS.sonic]: LZ_EIDS.sonic,
+  [CHAIN_IDS.bsc]: LZ_EIDS.bsc
 };
+var OFT_ROUTES = {
+  /**
+   * stgUSDC — USDC bridged via Stargate v2.
+   * Underlying on Eth/Arb/Base/Op: native USDC. On Flow: stgUSDC (Stargate's wrapped USDC).
+   */
+  stgUSDC: {
+    [
+      747
+      /* flowEVMMainnet */
+    ]: { oft: "0xAF54BE5B6eEc24d6BFACf1cce4eaF680A8239398", token: "0xF1815bd50389c46847f0Bda824eC8da914045D14" },
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xc026395860Db2d07ee33e05fE50ed7bD583189C7", token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0xe8CDF27AcD73a434D661C84887215F7598e7d0d3", token: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x27a16dc786820B16E5c9028b75B99F6f604b5d26", token: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" },
+    [
+      10
+      /* optimism       */
+    ]: { oft: "0xcE8CcA271Ebc0533920C83d39F417ED6A0abB7D0", token: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" },
+    [
+      146
+      /* sonic          */
+    ]: { oft: "0xA272fFe20cFfe769CdFc4b63088DCD2C82a2D8F9", token: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894" }
+  },
+  /**
+   * USDT — USDT bridged via Stargate v2.
+   */
+  USDT: {
+    [
+      747
+      /* flowEVMMainnet */
+    ]: { oft: "0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6", token: "0x674843C06FF83502ddb4D37c2E09C01cdA38cbc8" },
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0x933597a323Eb81cAe705C5bC29985172fd5A3973", token: "0xdAC17F958D2ee523a2206206994597C13D831ec7" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0xcE8CcA271Ebc0533920C83d39F417ED6A0abB7D0", token: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9" },
+    [
+      10
+      /* optimism       */
+    ]: { oft: "0x19cFCE47eD54a88614648DC3f19A5980097007dD", token: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58" }
+  },
+  /**
+   * USDF — USD Flow OFT. Bridges PYUSD (Ethereum) ↔ USDF (Flow EVM).
+   */
+  USDF: {
+    [
+      747
+      /* flowEVMMainnet */
+    ]: { oft: "0x2aabea2058b5ac2d339b163c6ab6f2b6d53aabed", token: "0x2aabea2058b5ac2d339b163c6ab6f2b6d53aabed" },
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xfa0e06b54986ad96de87a8c56fea76fbd8d493f8", token: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8" }
+  },
+  /**
+   * PYUSD — PayPal USD bridged via OFTAdapter (Paxos / LayerZero).
+   */
+  PYUSD: {
+    [
+      747
+      /* flowEVMMainnet */
+    ]: { oft: "0x26d27d5AF2F6f1c14F40013C8619d97aaf015509", token: "0x99aF3EeA856556646C98c8B9b2548Fe815240750" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0x3CD2b89C49D130C08f1d683225b2e5DeB63ff876", token: "0x46850aD61C2B7d64d08c9C754F45254596696984" }
+  },
+  /**
+   * WFLOW — Wrapped FLOW NativeOFTAdapter (issued by Flow Foundation).
+   */
+  WFLOW: {
+    [
+      747
+      /* flowEVMMainnet */
+    ]: { oft: "0xd296588850bee2770136464ffdddd78c32f2a07c", token: "0xd296588850bee2770136464ffdddd78c32f2a07c" },
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xc1b45896b5fc9422a8f779653808297bb4f546f9", token: "0x5c147e74D63B1D31AA3Fd78Eb229B65161983B2b" }
+  },
+  /**
+   * WETH — ETH OFT via Stargate v2. underlying = native ETH (no approval needed).
+   */
+  WETH: {
+    [
+      747
+      /* flowEVMMainnet */
+    ]: { oft: "0x45f1A95A4D3f3836523F5c83673c797f4d4d263B", token: "0x2F6F07CDcf3588944Bf4C42aC74ff24bF56e7590" },
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0x77b2043768d28E9C9aB44E1aBfC95944bcE57931", token: "0x0000000000000000000000000000000000000000" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0xA45B5130f36CDcA45667738e2a258AB09f4A5f7F", token: "0x0000000000000000000000000000000000000000" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0xdc181Bd607330aeeBEF6ea62e03e5e1Fb4B6F7C7", token: "0x0000000000000000000000000000000000000000" }
+  },
+  /**
+   * sUSDe — Ethena staked USDe (yield-bearing stablecoin).
+   */
+  sUSDe: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2", token: "0x9D39A5DE30e57443BfF2A8307A4256c8797A3497" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2", token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2", token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2" },
+    [
+      10
+      /* optimism       */
+    ]: { oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2", token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2" },
+    [
+      56
+      /* bsc            */
+    ]: { oft: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2", token: "0x211cc4dd073734da055fbf44a2b4667d5e5fe5d2" }
+  },
+  /**
+   * USDe — Ethena USD stablecoin.
+   */
+  USDe: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", token: "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34" },
+    [
+      10
+      /* optimism       */
+    ]: { oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34" },
+    [
+      56
+      /* bsc            */
+    ]: { oft: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", token: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34" }
+  },
+  /**
+   * weETH — Ether.Fi liquid restaking token.
+   */
+  weETH: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xcd2eb13d6831d4602d80e5db9230a57596cdca63", token: "0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a", token: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a" },
+    [
+      10
+      /* optimism       */
+    ]: { oft: "0x5a7facb970d094b6c7ff1df0ea68d99e6e73cbff", token: "0x5a7facb970d094b6c7ff1df0ea68d99e6e73cbff" },
+    [
+      56
+      /* bsc            */
+    ]: { oft: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a", token: "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a" },
+    [
+      146
+      /* sonic          */
+    ]: { oft: "0xa3d68b74bf0528fdd07263c60d6488749044914b", token: "0xa3d68b74bf0528fdd07263c60d6488749044914b" }
+  },
+  /**
+   * rsETH — Kelp DAO liquid restaking token.
+   */
+  rsETH: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0x85d456b2dff1fd8245387c0bfb64dfb700e98ef3", token: "0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0x4186bfc76e2e237523cbc30fd220fe055156b41f", token: "0x4186bfc76e2e237523cbc30fd220fe055156b41f" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x1bc71130a0e39942a7658878169764bbd8a45993", token: "0x1bc71130a0e39942a7658878169764bbd8a45993" },
+    [
+      10
+      /* optimism       */
+    ]: { oft: "0x4186bfc76e2e237523cbc30fd220fe055156b41f", token: "0x4186bfc76e2e237523cbc30fd220fe055156b41f" },
+    [
+      146
+      /* sonic          */
+    ]: { oft: "0xd75787ba9aba324420d522bda84c08c87e5099b1", token: "0xd75787ba9aba324420d522bda84c08c87e5099b1" }
+  },
+  /**
+   * rswETH — Swell Network liquid restaking token.
+   */
+  rswETH: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0x1486d39646cdee84619bd05997319545a8575079", token: "0xFAe103DC9cf190eD75350761e95403b7b8aFa6c0" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0xb1fe27b32ffb5ce54e272c096547f1e86c19e72f", token: "0xb1fe27b32ffb5ce54e272c096547f1e86c19e72f" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x850cdf416668210ed0c36bfff5d21921c7ada3b8", token: "0x850cdf416668210ed0c36bfff5d21921c7ada3b8" }
+  },
+  /**
+   * USR — Resolv Labs USD stablecoin.
+   */
+  USR: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xd2ee2776f34ef4e7325745b06e6d464b08d4be0e", token: "0x66a1E37c9b0eAddca17d3662D6c05F4DECf3e110" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9", token: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0x35e5db674d8e93a03d814fa0ada70731efe8a4b9", token: "0x35e5db674d8e93a03d814fa0ada70731efe8a4b9" },
+    [
+      56
+      /* bsc            */
+    ]: { oft: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9", token: "0x2492d0006411af6c8bbb1c8afc1b0197350a79e9" }
+  },
+  /**
+   * wstUSR — Resolv Labs wrapped staked USR (yield-bearing).
+   */
+  wstUSR: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xab17c1fe647c37ceb9b96d1c27dd189bf8451978", token: "0x1202F5C7b4B9E47a1A484E8B270be34dbbC75055" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0x66cfbd79257dc5217903a36293120282548e2254", token: "0x66cfbd79257dc5217903a36293120282548e2254" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0xb67675158b412d53fe6b68946483ba920b135ba1", token: "0xb67675158b412d53fe6b68946483ba920b135ba1" },
+    [
+      56
+      /* bsc            */
+    ]: { oft: "0x4254813524695def4163a169e901f3d7a1a55429", token: "0x4254813524695def4163a169e901f3d7a1a55429" }
+  },
+  /**
+   * USDtb — Ethena treasury-backed stablecoin.
+   */
+  USDtb: {
+    [
+      1
+      /* ethereum       */
+    ]: { oft: "0xc708b6887db46005da033501f8aebee72d191a5d", token: "0xC139190F447e929f090Edeb554D95AbB8b18aC1C" },
+    [
+      42161
+      /* arbitrum       */
+    ]: { oft: "0xc708b6887db46005da033501f8aebee72d191a5d", token: "0xc708b6887db46005da033501f8aebee72d191a5d" },
+    [
+      8453
+      /* base           */
+    ]: { oft: "0xc708b6887db46005da033501f8aebee72d191a5d", token: "0xc708b6887db46005da033501f8aebee72d191a5d" }
+  }
+};
+var UNISWAP_V3_ROUTERS = {
+  [8453]: "0x2626664c2603336E57B271c5C0b26F421741e481",
+  // Base — SwapRouter02 (no deadline)
+  [1]: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+  // Ethereum — SwapRouter
+  [42161]: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+  // Arbitrum — SwapRouter
+  [10]: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+  // Optimism — SwapRouter
+  [747]: "0xeEDC6Ff75e1b10B903D9013c358e446a73d35341"
+  // Flow EVM — FlowSwap V3 SwapRouter
+};
+var PUBLIC_RPCS = {
+  1: ["https://ethereum-rpc.publicnode.com", "https://eth.drpc.org", "https://eth.llamarpc.com"],
+  10: ["https://mainnet.optimism.io", "https://optimism-rpc.publicnode.com"],
+  42161: ["https://arbitrum-one-rpc.publicnode.com", "https://arbitrum.publicnode.com"],
+  8453: ["https://base-rpc.publicnode.com", "https://base.llamarpc.com", "https://mainnet.base.org"],
+  747: ["https://mainnet.evm.nodes.onflow.org"],
+  146: ["https://rpc.soniclabs.com"],
+  56: ["https://bsc-dataseed1.binance.org", "https://bsc-dataseed2.binance.org"]
+};
+function createChainProvider(chainId) {
+  const rpcs = PUBLIC_RPCS[chainId];
+  if (!rpcs?.length) return null;
+  return new ethers.JsonRpcProvider(rpcs[0], chainId, { staticNetwork: true });
+}
 var LZ_TIMEOUTS = {
   /** Poll interval between balance/event checks */
   POLL_INTERVAL: 3e4,
@@ -134,6 +461,58 @@ var LZ_ENDPOINT_ABI = [
   "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"
 ];
+var MULTICALL_ABI = [
+  "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)"
+];
+var DEX_ABI = [
+  "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)"
+];
+var BRIDGE_FACET_ABI = [
+  "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)"
+];
+var ERC7540_FACET_ABI = [
+  "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)"
+];
+var ERC4626_FACET_ABI = [
+  "function erc4626Deposit(address vault, uint256 assets) returns (uint256 shares)",
+  "function erc4626Redeem(address vault, uint256 shares) returns (uint256 assets)"
+];
+var CURATOR_CONFIG_ABI = [
+  "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)"
+];
+var LZ_ADAPTER_ABI = [
+  "function quoteBridgeFee(bytes bridgeSpecificParams) view returns (uint256 nativeFee)",
+  "function quoteReadFee(address[] vaults, uint32[] eids, bytes _extraOptions) view returns (tuple(uint256 nativeFee, uint256 lzTokenFee) fee)"
+];
+var VAULT_ANALYSIS_ABI = [
+  "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)"
+];
+var REGISTRY_ABI = [
+  "function isWhitelisted(address protocol) view returns (bool)",
+  "function isBridgeAllowed(address bridge) view returns (bool)",
+  "function getAllowedFacets() view returns (address[])"
+];
 
 // src/ethers/errors.ts
 var MoreVaultsError = class extends Error {
@@ -208,89 +587,9 @@ var WrongChainError = class extends MoreVaultsError {
     this.name = "WrongChainError";
   }
 };
-async function preflightAsync(provider, vault, escrow) {
-  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
-  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
-  const [ccManager, registeredEscrow, isHub, oraclesEnabled, isPaused] = await Promise.all([
-    config.getCrossChainAccountingManager(),
-    config.getEscrow(),
-    config.isHub(),
-    bridge.oraclesCrossChainAccounting(),
-    config.paused()
-  ]);
-  if (ccManager === ethers.ZeroAddress) {
-    throw new Error(
-      `[MoreVaults] CCManager not configured on vault ${vault}. Call setCrossChainAccountingManager(ccManagerAddress) as vault owner first.`
-    );
-  }
-  if (registeredEscrow === ethers.ZeroAddress) {
-    throw new Error(
-      `[MoreVaults] Escrow not configured for vault ${vault}. The registry must have an escrow set for this vault.`
-    );
-  }
-  if (!isHub) {
-    throw new Error(
-      `[MoreVaults] Vault ${vault} is not a hub vault. Async flows (D4/D5/R5) only work on hub vaults.`
-    );
-  }
-  if (oraclesEnabled) {
-    throw new Error(
-      `[MoreVaults] Vault ${vault} has oracle-based cross-chain accounting enabled. Use depositSimple/depositCrossChainOracleOn instead of async flows.`
-    );
-  }
-  if (isPaused) {
-    throw new Error(
-      `[MoreVaults] Vault ${vault} is paused. Cannot perform any actions.`
-    );
-  }
-}
-async function preflightRedeemLiquidity(provider, vault, shares) {
-  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
-  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
-  const [isHub, oraclesEnabled] = await Promise.all([
-    config.isHub(),
-    bridge.oraclesCrossChainAccounting()
-  ]);
-  if (!isHub || oraclesEnabled) return;
-  const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
-  const underlying = await vaultContract.asset();
-  const underlyingContract = new ethers.Contract(underlying, ERC20_ABI, provider);
-  const [hubLiquid, assetsNeeded] = await Promise.all([
-    underlyingContract.balanceOf(vault),
-    vaultContract.convertToAssets(shares)
-  ]);
-  if (hubLiquid < assetsNeeded) {
-    throw new InsufficientLiquidityError(vault, hubLiquid, assetsNeeded);
-  }
-}
-async function preflightSync(provider, vault) {
-  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
-  const [isPaused, depositCapResult] = await Promise.all([
-    config.paused(),
-    config.maxDeposit(ethers.ZeroAddress).catch(() => null)
-  ]);
-  if (isPaused) {
-    throw new Error(
-      `[MoreVaults] Vault ${vault} is paused. Cannot perform any actions.`
-    );
-  }
-  if (depositCapResult !== null && depositCapResult === 0n) {
-    throw new Error(
-      `[MoreVaults] Vault ${vault} has reached deposit capacity. No more deposits accepted.`
-    );
-  }
-}
-
-// src/ethers/chainValidation.ts
-async function validateWalletChain(signer, hubChainId) {
-  if (!hubChainId) return;
-  const network = await signer.provider?.getNetwork();
-  if (!network) return;
-  const current = Number(network.chainId);
-  if (current !== hubChainId) {
-    throw new WrongChainError(current, hubChainId);
-  }
-}
+var STARGATE_TYPE_ABI = [
+  "function stargateType() view returns (uint8)"
+];
 var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
 var MULTICALL3_ABI = [
   "function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)"
@@ -470,8 +769,18 @@ async function getVaultStatus(provider, vault) {
     issues
   };
 }
-
-// src/ethers/depositFlows.ts
+async function detectStargateOft(provider, oft) {
+  try {
+    const contract = new ethers.Contract(oft, STARGATE_TYPE_ABI, provider);
+    await contract.stargateType();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var LZ_ENDPOINT = "0x1a44076050125825900e736c501f859c50fe728c";
+var EMPTY_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var RECEIVED_HASH = "0x0000000000000000000000000000000000000000000000000000000000000001";
 async function ensureAllowance2(signer, token, spender, amount) {
   const owner = await signer.getAddress();
   const erc20 = new ethers.Contract(token, ERC20_ABI, signer);
@@ -481,176 +790,34 @@ async function ensureAllowance2(signer, token, spender, amount) {
     await tx.wait();
   }
 }
-async function depositSimple(signer, addresses, assets, receiver) {
-  const provider = signer.provider;
-  await validateWalletChain(signer, addresses.hubChainId);
-  await preflightSync(provider, addresses.vault);
-  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
-  const underlying = await vault.asset();
-  await ensureAllowance2(signer, underlying, addresses.vault, assets);
-  const tx = await vault["deposit(uint256,address)"](assets, receiver);
-  const receipt = await tx.wait();
-  let shares = 0n;
-  for (const log of receipt.logs) {
-    try {
-      const parsed = vault.interface.parseLog({
-        topics: log.topics,
-        data: log.data
-      });
-      if (parsed && parsed.name === "Transfer" && parsed.args[0] === "0x0000000000000000000000000000000000000000") {
-        shares = parsed.args[2];
-        break;
-      }
-    } catch {
-    }
-  }
-  return { receipt, shares };
-}
-async function depositMultiAsset(signer, addresses, tokens, amounts, receiver, minShares) {
-  await validateWalletChain(signer, addresses.hubChainId);
-  for (let i = 0; i < tokens.length; i++) {
-    await ensureAllowance2(signer, tokens[i], addresses.vault, amounts[i]);
-  }
-  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
-  const tx = await vault["deposit(address[],uint256[],address,uint256)"](tokens, amounts, receiver, minShares);
-  const receipt = await tx.wait();
-  let shares = 0n;
-  for (const log of receipt.logs) {
-    try {
-      const parsed = vault.interface.parseLog({
-        topics: log.topics,
-        data: log.data
-      });
-      if (parsed && parsed.name === "Deposit") {
-        shares = parsed.args[4];
-        break;
-      }
-    } catch {
-    }
-  }
-  return { receipt, shares };
-}
-var depositCrossChainOracleOn = depositSimple;
-async function depositAsync(signer, addresses, assets, receiver, lzFee, extraOptions = "0x") {
-  const provider = signer.provider;
-  const escrow = addresses.escrow ?? await new ethers.Contract(addresses.vault, ["function getEscrow() view returns (address)"], provider).getEscrow();
-  if (escrow === ethers.ZeroAddress) throw new EscrowNotConfiguredError(addresses.vault);
-  await validateWalletChain(signer, addresses.hubChainId);
-  await preflightAsync(provider, addresses.vault);
-  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
-  const underlying = await vault.asset();
-  await ensureAllowance2(signer, underlying, escrow, assets);
+async function depositFromSpoke(signer, spokeOFT, composer, hubEid, spokeEid, amount, receiver, lzFee, minMsgValue = 0n, minSharesOut = 0n, minAmountLD, extraOptions = "0x") {
+  await ensureAllowance2(signer, spokeOFT, spokeOFT, amount);
+  const oft = new ethers.Contract(spokeOFT, OFT_ABI, signer);
+  const refundAddress = await signer.getAddress();
+  const receiverBytes32 = ethers.zeroPadValue(receiver, 32);
+  const composerBytes32 = ethers.zeroPadValue(composer, 32);
+  const hopSendParam = {
+    dstEid: spokeEid,
+    to: receiverBytes32,
+    amountLD: 0n,
+    minAmountLD: minSharesOut,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
   const coder = ethers.AbiCoder.defaultAbiCoder();
-  const actionCallData = coder.encode(
-    ["uint256", "address"],
-    [assets, receiver]
+  const composeMsg = coder.encode(
+    [
+      "tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)",
+      "uint256"
+    ],
+    [hopSendParam, minMsgValue]
   );
-  const bridge = new ethers.Contract(addresses.vault, BRIDGE_ABI, signer);
-  const guid = await bridge.initVaultActionRequest.staticCall(
-    ActionType.DEPOSIT,
-    actionCallData,
-    0,
-    extraOptions,
-    { value: lzFee }
-  );
-  const tx = await bridge.initVaultActionRequest(
-    ActionType.DEPOSIT,
-    actionCallData,
-    0,
-    // amountLimit = 0 for deposits (minAmountOut handled by cross-chain manager)
-    extraOptions,
-    { value: lzFee }
-  );
-  const receipt = await tx.wait();
-  return { receipt, guid };
-}
-async function mintAsync(signer, addresses, shares, maxAssets, receiver, lzFee, extraOptions = "0x") {
-  const provider = signer.provider;
-  const escrow = addresses.escrow ?? await new ethers.Contract(addresses.vault, ["function getEscrow() view returns (address)"], provider).getEscrow();
-  if (escrow === ethers.ZeroAddress) throw new EscrowNotConfiguredError(addresses.vault);
-  await validateWalletChain(signer, addresses.hubChainId);
-  await preflightAsync(provider, addresses.vault);
-  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
-  const underlying = await vault.asset();
-  await ensureAllowance2(signer, underlying, escrow, maxAssets);
-  const coder = ethers.AbiCoder.defaultAbiCoder();
-  const actionCallData = coder.encode(
-    ["uint256", "address"],
-    [shares, receiver]
-  );
-  const bridge = new ethers.Contract(addresses.vault, BRIDGE_ABI, signer);
-  const guid = await bridge.initVaultActionRequest.staticCall(
-    ActionType.MINT,
-    actionCallData,
-    maxAssets,
-    extraOptions,
-    { value: lzFee }
-  );
-  const tx = await bridge.initVaultActionRequest(
-    ActionType.MINT,
-    actionCallData,
-    maxAssets,
-    extraOptions,
-    { value: lzFee }
-  );
-  const receipt = await tx.wait();
-  return { receipt, guid };
-}
-async function smartDeposit(signer, provider, addresses, assets, receiver, extraOptions = "0x") {
-  const vault = addresses.vault;
-  const status = await getVaultStatus(provider, vault);
-  if (status.mode === "paused") {
-    throw new VaultPausedError(vault);
-  }
-  if (status.mode === "full") {
-    throw new CapacityFullError(vault);
-  }
-  if (status.recommendedDepositFlow === "depositAsync") {
-    const lzFee = await quoteLzFee(provider, vault, extraOptions);
-    return depositAsync(signer, addresses, assets, receiver, lzFee, extraOptions);
-  }
-  return depositSimple(signer, addresses, assets, receiver);
-}
-var LZ_ENDPOINT = "0x1a44076050125825900e736c501f859c50fe728c";
-var EMPTY_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var RECEIVED_HASH = "0x0000000000000000000000000000000000000000000000000000000000000001";
-async function ensureAllowance3(signer, token, spender, amount) {
-  const owner = await signer.getAddress();
-  const erc20 = new ethers.Contract(token, ERC20_ABI, signer);
-  const current = await erc20.allowance(owner, spender);
-  if (current < amount) {
-    const tx = await erc20.approve(spender, amount);
-    await tx.wait();
-  }
-}
-async function depositFromSpoke(signer, spokeOFT, composer, hubEid, spokeEid, amount, receiver, lzFee, minMsgValue = 0n, minSharesOut = 0n, minAmountLD, extraOptions = "0x") {
-  await ensureAllowance3(signer, spokeOFT, spokeOFT, amount);
-  const oft = new ethers.Contract(spokeOFT, OFT_ABI, signer);
-  const refundAddress = await signer.getAddress();
-  const receiverBytes32 = ethers.zeroPadValue(receiver, 32);
-  const composerBytes32 = ethers.zeroPadValue(composer, 32);
-  const hopSendParam = {
-    dstEid: spokeEid,
-    to: receiverBytes32,
-    amountLD: 0n,
-    minAmountLD: minSharesOut,
-    extraOptions: "0x",
-    composeMsg: "0x",
-    oftCmd: "0x"
-  };
-  const coder = ethers.AbiCoder.defaultAbiCoder();
-  const composeMsg = coder.encode(
-    [
-      "tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)",
-      "uint256"
-    ],
-    [hopSendParam, minMsgValue]
-  );
-  const sendParam = {
-    dstEid: hubEid,
-    to: composerBytes32,
-    amountLD: amount,
-    minAmountLD: minAmountLD ?? amount,
+  const sendParam = {
+    dstEid: hubEid,
+    to: composerBytes32,
+    amountLD: amount,
+    minAmountLD: minAmountLD ?? amount,
     extraOptions,
     composeMsg,
     oftCmd: "0x"
@@ -691,68 +858,621 @@ async function quoteDepositFromSpokeFee(provider, spokeOFT, composer, hubEid, sp
       minMsgValue
     ]
   );
-  const sendParam = {
-    dstEid: hubEid,
-    to: composerBytes32,
-    amountLD: amount,
-    minAmountLD: minAmountLD ?? amount,
+  const sendParam = {
+    dstEid: hubEid,
+    to: composerBytes32,
+    amountLD: amount,
+    minAmountLD: minAmountLD ?? amount,
+    extraOptions,
+    composeMsg: composeMsgBytes,
+    oftCmd: "0x"
+  };
+  const oft = new ethers.Contract(spokeOFT, OFT_ABI, provider);
+  const fee = await oft.quoteSend(sendParam, false);
+  return fee.nativeFee;
+}
+async function quoteComposeFee(provider, vault, spokeEid, receiver) {
+  try {
+    const vaultContract = new ethers.Contract(vault, BRIDGE_ABI, provider);
+    const readFee = await vaultContract.quoteAccountingFee("0x");
+    let shareSendFee = 0n;
+    if (spokeEid && receiver) {
+      try {
+        const COMPOSER_ABI = ["function SHARE_OFT() view returns (address)"];
+        const FACTORY_ABI2 = ["function vaultComposer(address _vault) view returns (address)"];
+        const factory = new ethers.Contract("0x7bDB8B17604b03125eFAED33cA0c55FBf856BB0C", FACTORY_ABI2, provider);
+        const composerAddr = await factory.vaultComposer(vault);
+        const composer = new ethers.Contract(composerAddr, COMPOSER_ABI, provider);
+        const shareOftAddr = await composer.SHARE_OFT();
+        const shareOft = new ethers.Contract(shareOftAddr, OFT_ABI, provider);
+        const receiverBytes32 = ethers.zeroPadValue(receiver, 32);
+        const fee = await shareOft.quoteSend({
+          dstEid: spokeEid,
+          to: receiverBytes32,
+          amountLD: 1000000n,
+          minAmountLD: 0n,
+          extraOptions: "0x",
+          composeMsg: "0x",
+          oftCmd: "0x"
+        }, false);
+        shareSendFee = fee.nativeFee;
+      } catch {
+      }
+    }
+    return (readFee + shareSendFee) * 110n / 100n;
+  } catch {
+    return 500000000000000n;
+  }
+}
+async function executeCompose(signer, from, to, guid, message, fee, index = 0) {
+  const endpoint = new ethers.Contract(LZ_ENDPOINT, LZ_ENDPOINT_ABI, signer);
+  const hash = await endpoint.composeQueue(from, to, guid, index);
+  if (hash === EMPTY_HASH) {
+    throw new Error("Compose not found in queue (hash = 0). Never sent or wrong parameters.");
+  }
+  if (hash === RECEIVED_HASH) {
+    throw new Error("Compose already delivered \u2014 no action needed.");
+  }
+  const tx = await endpoint.lzCompose(from, to, guid, index, message, "0x", {
+    value: fee,
+    gasLimit: 5000000n
+  });
+  const receipt = await tx.wait();
+  return { receipt };
+}
+async function waitForCompose(hubProvider, composeData, receiver, pollIntervalMs = 2e4, timeoutMs = 18e5) {
+  const deadline = Date.now() + timeoutMs;
+  const composer = composeData.to.toLowerCase();
+  const endpoint = composeData.endpoint;
+  const receiverNeedle = receiver.replace(/^0x/, "").toLowerCase();
+  const startBlock = composeData.hubBlockStart;
+  const hubChainId = composeData.hubChainId;
+  const candidateAddresses = [];
+  for (const chainMap of Object.values(OFT_ROUTES)) {
+    const entry = chainMap[hubChainId];
+    if (entry) candidateAddresses.push(entry.oft.toLowerCase());
+  }
+  const stargateChecks = await Promise.all(
+    candidateAddresses.map(async (addr) => ({
+      addr,
+      isSg: await detectStargateOft(hubProvider, addr)
+    }))
+  );
+  const knownFromAddresses = stargateChecks.filter((c) => c.isSg).map((c) => c.addr);
+  const endpointContract = new ethers.Contract(endpoint, LZ_ENDPOINT_ABI, hubProvider);
+  const COMPOSE_SENT_TOPIC = "0x0c68e6a0b0fb0f33c52455a8da89b21fc640a3dd4a1b21d9bfcc8aeee4a43e84";
+  let attempt = 0;
+  let scannedUpTo = startBlock - 1n;
+  while (Date.now() < deadline) {
+    attempt++;
+    const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1e3);
+    try {
+      const currentBlock = BigInt(await hubProvider.getBlockNumber());
+      const chunkSize = 500n;
+      let from = scannedUpTo + 1n;
+      while (from <= currentBlock) {
+        const chunkEnd = from + chunkSize > currentBlock ? currentBlock : from + chunkSize;
+        try {
+          const logs = await hubProvider.getLogs({
+            address: endpoint,
+            topics: [COMPOSE_SENT_TOPIC],
+            fromBlock: `0x${from.toString(16)}`,
+            toBlock: `0x${chunkEnd.toString(16)}`
+          });
+          for (const log of logs) {
+            try {
+              const coder = ethers.AbiCoder.defaultAbiCoder();
+              const decoded = coder.decode(
+                ["address", "address", "bytes32", "uint16", "bytes"],
+                log.data
+              );
+              const logFrom = decoded[0].toLowerCase();
+              const logTo = decoded[1].toLowerCase();
+              const logGuid = decoded[2];
+              const logIndex = Number(decoded[3]);
+              const logMessage = decoded[4];
+              if (logTo === composer && logMessage.toLowerCase().includes(receiverNeedle)) {
+                const hash = await endpointContract.composeQueue(
+                  logFrom,
+                  composer,
+                  logGuid,
+                  logIndex
+                );
+                if (hash !== EMPTY_HASH && hash !== RECEIVED_HASH) {
+                  console.log(`[${elapsed}s] Poll #${attempt} \u2014 compose found! (block ${log.blockNumber})`);
+                  return {
+                    ...composeData,
+                    from: decoded[0],
+                    to: composeData.to,
+                    guid: logGuid,
+                    index: logIndex,
+                    message: logMessage
+                  };
+                }
+              }
+            } catch {
+            }
+          }
+        } catch {
+          break;
+        }
+        from = chunkEnd + 1n;
+      }
+      scannedUpTo = currentBlock;
+    } catch {
+    }
+    let guidMatchFound = false;
+    for (const fromAddr of knownFromAddresses) {
+      try {
+        const hash = await endpointContract.composeQueue(
+          fromAddr,
+          composer,
+          composeData.guid,
+          0
+        );
+        if (hash !== EMPTY_HASH && hash !== RECEIVED_HASH) {
+          console.log(`[${elapsed}s] Poll #${attempt} \u2014 composeQueue confirms pending (GUID match), re-scanning for message...`);
+          scannedUpTo = startBlock - 1n;
+          guidMatchFound = true;
+        }
+      } catch {
+      }
+    }
+    if (!guidMatchFound) {
+      console.log(`[${elapsed}s] Poll #${attempt} \u2014 compose not found yet, waiting ${pollIntervalMs / 1e3}s...`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error(
+    `Timeout waiting for compose after ${timeoutMs / 6e4} min. Check LayerZero scan for composer ${composeData.to}.`
+  );
+}
+
+// src/ethers/preflight.ts
+async function preflightAsync(provider, vault, escrow) {
+  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
+  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
+  const [ccManager, registeredEscrow, isHub, oraclesEnabled, isPaused] = await Promise.all([
+    config.getCrossChainAccountingManager(),
+    config.getEscrow(),
+    config.isHub(),
+    bridge.oraclesCrossChainAccounting(),
+    config.paused()
+  ]);
+  if (ccManager === ethers.ZeroAddress) {
+    throw new Error(
+      `[MoreVaults] CCManager not configured on vault ${vault}. Call setCrossChainAccountingManager(ccManagerAddress) as vault owner first.`
+    );
+  }
+  if (registeredEscrow === ethers.ZeroAddress) {
+    throw new Error(
+      `[MoreVaults] Escrow not configured for vault ${vault}. The registry must have an escrow set for this vault.`
+    );
+  }
+  if (!isHub) {
+    throw new Error(
+      `[MoreVaults] Vault ${vault} is not a hub vault. Async flows (D4/D5/R5) only work on hub vaults.`
+    );
+  }
+  if (oraclesEnabled) {
+    throw new Error(
+      `[MoreVaults] Vault ${vault} has oracle-based cross-chain accounting enabled. Use depositSimple/depositCrossChainOracleOn instead of async flows.`
+    );
+  }
+  if (isPaused) {
+    throw new Error(
+      `[MoreVaults] Vault ${vault} is paused. Cannot perform any actions.`
+    );
+  }
+}
+async function preflightRedeemLiquidity(provider, vault, shares) {
+  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
+  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
+  const [isHub, oraclesEnabled] = await Promise.all([
+    config.isHub(),
+    bridge.oraclesCrossChainAccounting()
+  ]);
+  if (!isHub || oraclesEnabled) return;
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
+  const underlying = await vaultContract.asset();
+  const underlyingContract = new ethers.Contract(underlying, ERC20_ABI, provider);
+  const [hubLiquid, assetsNeeded] = await Promise.all([
+    underlyingContract.balanceOf(vault),
+    vaultContract.convertToAssets(shares)
+  ]);
+  if (hubLiquid < assetsNeeded) {
+    throw new InsufficientLiquidityError(vault, hubLiquid, assetsNeeded);
+  }
+}
+async function preflightSync(provider, vault) {
+  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
+  const [isPaused, depositCapResult] = await Promise.all([
+    config.paused(),
+    config.maxDeposit(ethers.ZeroAddress).catch(() => null)
+  ]);
+  if (isPaused) {
+    throw new Error(
+      `[MoreVaults] Vault ${vault} is paused. Cannot perform any actions.`
+    );
+  }
+  if (depositCapResult !== null && depositCapResult === 0n) {
+    throw new Error(
+      `[MoreVaults] Vault ${vault} has reached deposit capacity. No more deposits accepted.`
+    );
+  }
+}
+async function preflightSpokeDeposit(spokeProvider, vault, spokeOFT, hubEid, spokeEid, amount, userAddress, lzFee) {
+  const OFT_TOKEN_ABI = ["function token() view returns (address)"];
+  const oftContract = new ethers.Contract(spokeOFT, OFT_TOKEN_ABI, spokeProvider);
+  const spokeToken = await oftContract.token();
+  const tokenContract = new ethers.Contract(spokeToken, ERC20_ABI, spokeProvider);
+  const [spokeTokenBalance, spokeNativeBalance] = await Promise.all([
+    tokenContract.balanceOf(userAddress),
+    spokeProvider.getBalance(userAddress)
+  ]);
+  if (spokeTokenBalance < amount) {
+    throw new Error(
+      `[MoreVaults] Insufficient token balance on spoke chain.
+  Need:  ${amount}
+  Have:  ${spokeTokenBalance}
+  Token: ${spokeToken}`
+    );
+  }
+  const gasBuffer = 500000000000000n;
+  if (spokeNativeBalance < lzFee + gasBuffer) {
+    throw new Error(
+      `[MoreVaults] Insufficient native gas on spoke chain for TX1.
+  Need:  ~${lzFee + gasBuffer} wei (LZ fee + gas)
+  Have:  ${spokeNativeBalance} wei`
+    );
+  }
+  const isStargate = await detectStargateOft(spokeProvider, spokeOFT);
+  let hubNativeBalance = 0n;
+  let estimatedComposeFee = 0n;
+  if (isStargate) {
+    const hubChainId = EID_TO_CHAIN_ID[hubEid];
+    const hubProvider = createChainProvider(hubChainId);
+    if (hubProvider) {
+      [hubNativeBalance, estimatedComposeFee] = await Promise.all([
+        hubProvider.getBalance(userAddress),
+        quoteComposeFee(hubProvider, vault, spokeEid, userAddress)
+      ]);
+      const hubGasBuffer = 300000000000000n;
+      const totalNeeded = estimatedComposeFee + hubGasBuffer;
+      if (hubNativeBalance < totalNeeded) {
+        throw new Error(
+          `[MoreVaults] Insufficient ETH on hub chain for TX2 (compose retry).
+  This is a Stargate 2-TX flow \u2014 TX2 requires ETH on the hub chain.
+  Need:  ~${totalNeeded} wei (compose fee ${estimatedComposeFee} + gas)
+  Have:  ${hubNativeBalance} wei
+  Short: ${totalNeeded - hubNativeBalance} wei
+  Send ETH to ${userAddress} on chainId ${hubChainId} before depositing.`
+        );
+      }
+    }
+  }
+  return {
+    spokeTokenBalance,
+    spokeNativeBalance,
+    hubNativeBalance,
+    estimatedComposeFee,
+    isStargate
+  };
+}
+async function preflightSpokeRedeem(route, shares, userAddress, shareBridgeFee) {
+  const spokeProvider = createChainProvider(route.spokeChainId);
+  const hubProvider = createChainProvider(route.hubChainId);
+  if (!spokeProvider) throw new Error(`No public RPC for spoke chainId ${route.spokeChainId}`);
+  if (!hubProvider) throw new Error(`No public RPC for hub chainId ${route.hubChainId}`);
+  const spokeShareContract = new ethers.Contract(route.spokeShareOft, ERC20_ABI, spokeProvider);
+  const [sharesOnSpoke, spokeNativeBalance, hubNativeBalance] = await Promise.all([
+    spokeShareContract.balanceOf(userAddress),
+    spokeProvider.getBalance(userAddress),
+    hubProvider.getBalance(userAddress)
+  ]);
+  if (sharesOnSpoke < shares) {
+    throw new Error(
+      `[MoreVaults] Insufficient shares on spoke chain.
+  Need:  ${shares}
+  Have:  ${sharesOnSpoke}
+  Token: ${route.spokeShareOft}`
+    );
+  }
+  const spokeGasBuffer = 500000000000000n;
+  if (spokeNativeBalance < shareBridgeFee + spokeGasBuffer) {
+    throw new Error(
+      `[MoreVaults] Insufficient native gas on spoke for TX1 (share bridge).
+  Need:  ~${shareBridgeFee + spokeGasBuffer} wei (LZ fee + gas)
+  Have:  ${spokeNativeBalance} wei`
+    );
+  }
+  let estimatedAssetBridgeFee = 0n;
+  try {
+    const toBytes32 = `0x${userAddress.replace(/^0x/, "").padStart(64, "0")}`;
+    const dummyAmount = 1000000n;
+    const hubOft = new ethers.Contract(route.hubAssetOft, OFT_ABI, hubProvider);
+    const feeResult = await hubOft.quoteSend({
+      dstEid: route.spokeEid,
+      to: toBytes32,
+      amountLD: dummyAmount,
+      minAmountLD: dummyAmount * 99n / 100n,
+      extraOptions: "0x",
+      composeMsg: "0x",
+      oftCmd: route.isStargate ? "0x01" : "0x"
+    }, false);
+    estimatedAssetBridgeFee = feeResult.nativeFee;
+  } catch {
+    estimatedAssetBridgeFee = 300000000000000n;
+  }
+  const hubGasBuffer = 300000000000000n;
+  const totalHubNeeded = estimatedAssetBridgeFee + hubGasBuffer;
+  if (hubNativeBalance < totalHubNeeded) {
+    throw new Error(
+      `[MoreVaults] Insufficient ETH on hub chain for TX2 (redeem) + TX3 (asset bridge).
+  Need:  ~${totalHubNeeded} wei (LZ fee ${estimatedAssetBridgeFee} + gas)
+  Have:  ${hubNativeBalance} wei
+  Short: ${totalHubNeeded - hubNativeBalance} wei
+  Send ETH to ${userAddress} on chainId ${route.hubChainId} before redeeming.`
+    );
+  }
+  return {
+    sharesOnSpoke,
+    spokeNativeBalance,
+    hubNativeBalance,
+    estimatedAssetBridgeFee,
+    estimatedAssetsOut: 0n,
+    hubLiquidBalance: 0n
+  };
+}
+
+// src/ethers/chainValidation.ts
+async function validateWalletChain(signer, hubChainId) {
+  if (!hubChainId) return;
+  const network = await signer.provider?.getNetwork();
+  if (!network) return;
+  const current = Number(network.chainId);
+  if (current !== hubChainId) {
+    throw new WrongChainError(current, hubChainId);
+  }
+}
+
+// src/ethers/depositFlows.ts
+async function ensureAllowance3(signer, token, spender, amount) {
+  const owner = await signer.getAddress();
+  const erc20 = new ethers.Contract(token, ERC20_ABI, signer);
+  const current = await erc20.allowance(owner, spender);
+  if (current < amount) {
+    const tx = await erc20.approve(spender, amount);
+    await tx.wait();
+  }
+}
+async function depositSimple(signer, addresses, assets, receiver) {
+  const provider = signer.provider;
+  await validateWalletChain(signer, addresses.hubChainId);
+  await preflightSync(provider, addresses.vault);
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const underlying = await vault.asset();
+  await ensureAllowance3(signer, underlying, addresses.vault, assets);
+  const tx = await vault["deposit(uint256,address)"](assets, receiver);
+  const receipt = await tx.wait();
+  let shares = 0n;
+  for (const log of receipt.logs) {
+    try {
+      const parsed = vault.interface.parseLog({
+        topics: log.topics,
+        data: log.data
+      });
+      if (parsed && parsed.name === "Transfer" && parsed.args[0] === "0x0000000000000000000000000000000000000000") {
+        shares = parsed.args[2];
+        break;
+      }
+    } catch {
+    }
+  }
+  return { receipt, shares };
+}
+async function depositMultiAsset(signer, addresses, tokens, amounts, receiver, minShares) {
+  await validateWalletChain(signer, addresses.hubChainId);
+  for (let i = 0; i < tokens.length; i++) {
+    await ensureAllowance3(signer, tokens[i], addresses.vault, amounts[i]);
+  }
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const tx = await vault["deposit(address[],uint256[],address,uint256)"](tokens, amounts, receiver, minShares);
+  const receipt = await tx.wait();
+  let shares = 0n;
+  for (const log of receipt.logs) {
+    try {
+      const parsed = vault.interface.parseLog({
+        topics: log.topics,
+        data: log.data
+      });
+      if (parsed && parsed.name === "Deposit") {
+        shares = parsed.args[4];
+        break;
+      }
+    } catch {
+    }
+  }
+  return { receipt, shares };
+}
+var depositCrossChainOracleOn = depositSimple;
+async function depositAsync(signer, addresses, assets, receiver, lzFee, extraOptions = "0x") {
+  const provider = signer.provider;
+  const escrow = addresses.escrow ?? await new ethers.Contract(addresses.vault, ["function getEscrow() view returns (address)"], provider).getEscrow();
+  if (escrow === ethers.ZeroAddress) throw new EscrowNotConfiguredError(addresses.vault);
+  await validateWalletChain(signer, addresses.hubChainId);
+  await preflightAsync(provider, addresses.vault);
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const underlying = await vault.asset();
+  await ensureAllowance3(signer, underlying, escrow, assets);
+  const coder = ethers.AbiCoder.defaultAbiCoder();
+  const actionCallData = coder.encode(
+    ["uint256", "address"],
+    [assets, receiver]
+  );
+  const bridge = new ethers.Contract(addresses.vault, BRIDGE_ABI, signer);
+  const guid = await bridge.initVaultActionRequest.staticCall(
+    ActionType.DEPOSIT,
+    actionCallData,
+    0,
+    extraOptions,
+    { value: lzFee }
+  );
+  const tx = await bridge.initVaultActionRequest(
+    ActionType.DEPOSIT,
+    actionCallData,
+    0,
+    // amountLimit = 0 for deposits (minAmountOut handled by cross-chain manager)
+    extraOptions,
+    { value: lzFee }
+  );
+  const receipt = await tx.wait();
+  return { receipt, guid };
+}
+async function mintAsync(signer, addresses, shares, maxAssets, receiver, lzFee, extraOptions = "0x") {
+  const provider = signer.provider;
+  const escrow = addresses.escrow ?? await new ethers.Contract(addresses.vault, ["function getEscrow() view returns (address)"], provider).getEscrow();
+  if (escrow === ethers.ZeroAddress) throw new EscrowNotConfiguredError(addresses.vault);
+  await validateWalletChain(signer, addresses.hubChainId);
+  await preflightAsync(provider, addresses.vault);
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const underlying = await vault.asset();
+  await ensureAllowance3(signer, underlying, escrow, maxAssets);
+  const coder = ethers.AbiCoder.defaultAbiCoder();
+  const actionCallData = coder.encode(
+    ["uint256", "address"],
+    [shares, receiver]
+  );
+  const bridge = new ethers.Contract(addresses.vault, BRIDGE_ABI, signer);
+  const guid = await bridge.initVaultActionRequest.staticCall(
+    ActionType.MINT,
+    actionCallData,
+    maxAssets,
+    extraOptions,
+    { value: lzFee }
+  );
+  const tx = await bridge.initVaultActionRequest(
+    ActionType.MINT,
+    actionCallData,
+    maxAssets,
     extraOptions,
-    composeMsg: composeMsgBytes,
-    oftCmd: "0x"
-  };
-  const oft = new ethers.Contract(spokeOFT, OFT_ABI, provider);
-  const fee = await oft.quoteSend(sendParam, false);
-  return fee.nativeFee;
+    { value: lzFee }
+  );
+  const receipt = await tx.wait();
+  return { receipt, guid };
 }
-async function quoteComposeFee(provider, vault, spokeEid, receiver) {
-  try {
-    const vaultContract = new ethers.Contract(vault, BRIDGE_ABI, provider);
-    const readFee = await vaultContract.quoteAccountingFee("0x");
-    let shareSendFee = 0n;
-    if (spokeEid && receiver) {
-      try {
-        const COMPOSER_ABI = ["function SHARE_OFT() view returns (address)"];
-        const FACTORY_ABI = ["function vaultComposer(address _vault) view returns (address)"];
-        const factory = new ethers.Contract("0x7bDB8B17604b03125eFAED33cA0c55FBf856BB0C", FACTORY_ABI, provider);
-        const composerAddr = await factory.vaultComposer(vault);
-        const composer = new ethers.Contract(composerAddr, COMPOSER_ABI, provider);
-        const shareOftAddr = await composer.SHARE_OFT();
-        const shareOft = new ethers.Contract(shareOftAddr, OFT_ABI, provider);
-        const receiverBytes32 = ethers.zeroPadValue(receiver, 32);
-        const fee = await shareOft.quoteSend({
-          dstEid: spokeEid,
-          to: receiverBytes32,
-          amountLD: 1000000n,
-          minAmountLD: 0n,
-          extraOptions: "0x",
-          composeMsg: "0x",
-          oftCmd: "0x"
-        }, false);
-        shareSendFee = fee.nativeFee;
-      } catch {
-      }
-    }
-    return (readFee + shareSendFee) * 110n / 100n;
-  } catch {
-    return 500000000000000n;
+async function smartDeposit(signer, provider, addresses, assets, receiver, extraOptions = "0x") {
+  const vault = addresses.vault;
+  const status = await getVaultStatus(provider, vault);
+  if (status.mode === "paused") {
+    throw new VaultPausedError(vault);
+  }
+  if (status.mode === "full") {
+    throw new CapacityFullError(vault);
+  }
+  if (status.recommendedDepositFlow === "depositAsync") {
+    const lzFee = await quoteLzFee(provider, vault, extraOptions);
+    return depositAsync(signer, addresses, assets, receiver, lzFee, extraOptions);
   }
+  return depositSimple(signer, addresses, assets, receiver);
 }
-async function executeCompose(signer, from, to, guid, message, fee, index = 0) {
-  const endpoint = new ethers.Contract(LZ_ENDPOINT, LZ_ENDPOINT_ABI, signer);
-  const hash = await endpoint.composeQueue(from, to, guid, index);
-  if (hash === EMPTY_HASH) {
-    throw new Error("Compose not found in queue (hash = 0). Never sent or wrong parameters.");
+var OMNI_FACTORY_ADDRESS = "0x7bDB8B17604b03125eFAED33cA0c55FBf856BB0C";
+var FACTORY_ABI = [
+  "function localEid() view returns (uint32)",
+  "function isCrossChainVault(uint32 __eid, address _vault) view returns (bool)",
+  "function hubToSpokes(uint32 __eid, address _hubVault) view returns (uint32[] eids, address[] vaults)",
+  "function spokeToHub(uint32 __eid, address _spokeVault) view returns (uint32 eid, address vault)"
+];
+var DISCOVERY_CHAIN_IDS = Object.values(CHAIN_IDS).filter(
+  (id) => id !== 545
+  // exclude testnet
+);
+async function getVaultTopology(provider, vault, factoryAddress = OMNI_FACTORY_ADDRESS) {
+  const factory = new ethers.Contract(factoryAddress, FACTORY_ABI, provider);
+  const localEid = Number(await factory.localEid());
+  const isHub = await factory.isCrossChainVault(localEid, vault);
+  if (isHub) {
+    const result = await factory.hubToSpokes(localEid, vault);
+    const spokeEids = result[0];
+    const localChainId2 = EID_TO_CHAIN_ID[localEid] ?? 0;
+    const spokeChainIds = spokeEids.map((eid) => EID_TO_CHAIN_ID[Number(eid)]).filter((id) => id !== void 0);
+    return { role: "hub", hubChainId: localChainId2, spokeChainIds };
   }
-  if (hash === RECEIVED_HASH) {
-    throw new Error("Compose already delivered \u2014 no action needed.");
+  const spokeResult = await factory.spokeToHub(localEid, vault);
+  const hubEid = Number(spokeResult[0]);
+  const hubVault = spokeResult[1];
+  if (hubEid !== 0 && hubVault !== "0x0000000000000000000000000000000000000000") {
+    const hubChainId = EID_TO_CHAIN_ID[hubEid] ?? 0;
+    const spokeChainIds = [];
+    const localChainId2 = EID_TO_CHAIN_ID[localEid];
+    if (localChainId2 !== void 0) spokeChainIds.push(localChainId2);
+    return { role: "spoke", hubChainId, spokeChainIds };
   }
-  const tx = await endpoint.lzCompose(from, to, guid, index, message, "0x", {
-    value: fee,
-    gasLimit: 5000000n
-  });
-  const receipt = await tx.wait();
-  return { receipt };
+  const localChainId = EID_TO_CHAIN_ID[localEid] ?? 0;
+  return { role: "local", hubChainId: localChainId, spokeChainIds: [] };
+}
+async function getFullVaultTopology(hubChainProvider, vault, factoryAddress = OMNI_FACTORY_ADDRESS) {
+  const topo = await getVaultTopology(hubChainProvider, vault, factoryAddress);
+  if (topo.role !== "hub") {
+    throw new Error(
+      `getFullVaultTopology: provider must be connected to the hub chain (${topo.hubChainId}), but got role="${topo.role}". Connect to chainId ${topo.hubChainId} instead.`
+    );
+  }
+  return topo;
+}
+async function discoverVaultTopology(vault, provider, factoryAddress = OMNI_FACTORY_ADDRESS) {
+  let triedChainId;
+  if (provider) {
+    try {
+      const topo = await getVaultTopology(provider, vault, factoryAddress);
+      if (topo.role !== "local") {
+        if (topo.role === "spoke") {
+          const hubProvider = createChainProvider(topo.hubChainId);
+          if (hubProvider) {
+            try {
+              return await getFullVaultTopology(hubProvider, vault, factoryAddress);
+            } catch {
+            }
+          }
+        }
+        return topo;
+      }
+      const network = await provider.getNetwork();
+      triedChainId = Number(network.chainId);
+    } catch {
+    }
+  }
+  for (const chainId of DISCOVERY_CHAIN_IDS) {
+    if (chainId === triedChainId) continue;
+    const chainProvider = createChainProvider(chainId);
+    if (!chainProvider) continue;
+    try {
+      const topo = await getVaultTopology(chainProvider, vault, factoryAddress);
+      if (topo.role === "hub") return topo;
+      if (topo.role === "spoke") {
+        const hubProvider = createChainProvider(topo.hubChainId);
+        if (hubProvider) {
+          try {
+            return await getFullVaultTopology(hubProvider, vault, factoryAddress);
+          } catch {
+            return topo;
+          }
+        }
+        return topo;
+      }
+    } catch {
+    }
+  }
+  return { role: "local", hubChainId: 0, spokeChainIds: [] };
 }
+function isOnHubChain(currentChainId, topology) {
+  return currentChainId === topology.hubChainId;
+}
+function getAllVaultChainIds(topology) {
+  return [topology.hubChainId, ...topology.spokeChainIds];
+}
+
+// src/ethers/redeemFlows.ts
 async function ensureAllowance4(signer, token, spender, amount) {
   const owner = await signer.getAddress();
   const erc20 = new ethers.Contract(token, ERC20_ABI, signer);
@@ -886,6 +1606,83 @@ async function bridgeAssetsToSpoke(signer, assetOFT, spokeChainEid, amount, rece
   const receipt = await tx.wait();
   return { receipt };
 }
+var FACTORY_COMPOSER_ABI_RF = [
+  "function vaultComposer(address _vault) view returns (address)"
+];
+var REDEEM_COMPOSER_ABI = [
+  "function SHARE_OFT() view returns (address)"
+];
+var OFT_PEERS_ABI_RF = [
+  "function peers(uint32 eid) view returns (bytes32)"
+];
+async function quoteShareBridgeFee(spokeProvider, shareOFT, hubChainEid, amountLD, receiver) {
+  const toBytes32 = ethers.zeroPadValue(receiver, 32);
+  const sendParam = {
+    dstEid: hubChainEid,
+    to: toBytes32,
+    amountLD,
+    minAmountLD: amountLD,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const oft = new ethers.Contract(shareOFT, OFT_ABI, spokeProvider);
+  const fee = await oft.quoteSend(sendParam, false);
+  return fee.nativeFee;
+}
+async function resolveRedeemAddresses(hubProvider, vault, hubChainId, spokeChainId) {
+  const hubEid = CHAIN_ID_TO_EID[hubChainId];
+  const spokeEid = CHAIN_ID_TO_EID[spokeChainId];
+  if (!hubEid || !spokeEid) {
+    throw new Error(`No LZ EID for chainId ${!hubEid ? hubChainId : spokeChainId}`);
+  }
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, hubProvider);
+  const factory = new ethers.Contract(OMNI_FACTORY_ADDRESS, FACTORY_COMPOSER_ABI_RF, hubProvider);
+  const [hubAsset, composerAddress] = await Promise.all([
+    vaultContract.asset(),
+    factory.vaultComposer(vault)
+  ]);
+  if (composerAddress === ethers.ZeroAddress) {
+    throw new Error(`[MoreVaults] No composer registered for vault ${vault} on hub chain ${hubChainId}`);
+  }
+  const composer = new ethers.Contract(composerAddress, REDEEM_COMPOSER_ABI, hubProvider);
+  const hubShareOft = await composer.SHARE_OFT();
+  const hubShareOftContract = new ethers.Contract(hubShareOft, OFT_PEERS_ABI_RF, hubProvider);
+  const spokeShareOftBytes32 = await hubShareOftContract.peers(spokeEid);
+  const spokeShareOft = `0x${spokeShareOftBytes32.slice(-40)}`;
+  let hubAssetOft = null;
+  let spokeAsset = null;
+  let symbol = "";
+  for (const [sym, chainMap] of Object.entries(OFT_ROUTES)) {
+    const hubEntry = chainMap[hubChainId];
+    const spokeEntry = chainMap[spokeChainId];
+    if (!hubEntry || !spokeEntry) continue;
+    if (hubEntry.token.toLowerCase() === hubAsset.toLowerCase()) {
+      hubAssetOft = hubEntry.oft;
+      spokeAsset = spokeEntry.token;
+      symbol = sym;
+      break;
+    }
+  }
+  if (!hubAssetOft || !spokeAsset) {
+    throw new Error(
+      `[MoreVaults] No OFT route found for vault asset ${hubAsset} between hub chain ${hubChainId} and spoke chain ${spokeChainId}`
+    );
+  }
+  const isStargate = await detectStargateOft(hubProvider, hubAssetOft);
+  return {
+    hubChainId,
+    spokeChainId,
+    hubEid,
+    spokeEid,
+    hubAsset,
+    spokeShareOft,
+    hubAssetOft,
+    spokeAsset,
+    isStargate,
+    symbol
+  };
+}
 var MULTICALL3_ADDRESS2 = "0xcA11bde05977b3631167028862bE2a173976CA11";
 var MULTICALL3_ABI2 = [
   "function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)"
@@ -955,11 +1752,11 @@ async function canDeposit(provider, vault, user) {
   return { allowed: true, reason: "ok" };
 }
 async function getVaultMetadata(provider, vault) {
-  const MULTICALL3_ADDRESS3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
-  const MULTICALL3_ABI3 = [
+  const MULTICALL3_ADDRESS4 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+  const MULTICALL3_ABI4 = [
     "function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)"
   ];
-  const mc = new ethers.Contract(MULTICALL3_ADDRESS3, MULTICALL3_ABI3, provider);
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS4, MULTICALL3_ABI4, provider);
   const metaIface = new ethers.Interface(METADATA_ABI);
   const vaultIface = new ethers.Interface(VAULT_ABI);
   const b1Calls = [
@@ -1096,6 +1893,644 @@ async function getVaultSummary(provider, vault) {
   ]);
   return { ...status, ...metadata };
 }
+var FACTORY_COMPOSER_ABI_UH = [
+  "function vaultComposer(address _vault) view returns (address)"
+];
+var COMPOSER_SHARE_OFT_ABI_UH = [
+  "function SHARE_OFT() view returns (address)"
+];
+var OFT_PEERS_ABI_UH = [
+  "function peers(uint32 eid) view returns (bytes32)"
+];
+async function getUserPositionMultiChain(vault, user) {
+  const topo = await discoverVaultTopology(vault);
+  const hubProvider = createChainProvider(topo.hubChainId);
+  if (!hubProvider) throw new Error(`No public RPC for hub chainId ${topo.hubChainId}`);
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS2, MULTICALL3_ABI2, hubProvider);
+  const vaultIface = new ethers.Interface(VAULT_ABI);
+  const decimalsIface = new ethers.Interface(["function decimals() view returns (uint8)"]);
+  const b1Calls = [
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("balanceOf", [user]) },
+    { target: vault, allowFailure: false, callData: decimalsIface.encodeFunctionData("decimals") },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("getWithdrawalRequest", [user]) }
+  ];
+  const [b1Raw, block] = await Promise.all([
+    mc.aggregate3.staticCall(b1Calls),
+    hubProvider.getBlock("latest")
+  ]);
+  const hubShares = vaultIface.decodeFunctionResult("balanceOf", b1Raw[0].returnData)[0];
+  const decimals = Number(decimalsIface.decodeFunctionResult("decimals", b1Raw[1].returnData)[0]);
+  const withdrawalResult = vaultIface.decodeFunctionResult("getWithdrawalRequest", b1Raw[2].returnData);
+  const withdrawShares = withdrawalResult[0];
+  const timelockEndsAt = withdrawalResult[1];
+  const spokeShares = {};
+  const rawSpokeShares = {};
+  if (topo.spokeChainIds.length > 0) {
+    let hubShareOft = null;
+    try {
+      const factory = new ethers.Contract(OMNI_FACTORY_ADDRESS, FACTORY_COMPOSER_ABI_UH, hubProvider);
+      const composerAddress = await factory.vaultComposer(vault);
+      if (composerAddress !== "0x0000000000000000000000000000000000000000") {
+        const composer = new ethers.Contract(composerAddress, COMPOSER_SHARE_OFT_ABI_UH, hubProvider);
+        hubShareOft = await composer.SHARE_OFT();
+      }
+    } catch {
+    }
+    if (hubShareOft) {
+      const hubShareOftContract = new ethers.Contract(hubShareOft, OFT_PEERS_ABI_UH, hubProvider);
+      const spokePromises = topo.spokeChainIds.map(async (spokeChainId) => {
+        try {
+          const spokeEid = CHAIN_ID_TO_EID[spokeChainId];
+          if (!spokeEid) return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+          const spokeOftBytes32 = await hubShareOftContract.peers(spokeEid);
+          const spokeOft = `0x${spokeOftBytes32.slice(-40)}`;
+          if (spokeOft === "0x0000000000000000000000000000000000000000") {
+            return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+          }
+          const spokeProvider = createChainProvider(spokeChainId);
+          if (!spokeProvider) return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+          const spokeMc = new ethers.Contract(MULTICALL3_ADDRESS2, MULTICALL3_ABI2, spokeProvider);
+          const erc20Iface = new ethers.Interface(ERC20_ABI);
+          const spokeDecimalsIface = new ethers.Interface(["function decimals() view returns (uint8)"]);
+          const spokeCalls = [
+            { target: spokeOft, allowFailure: false, callData: erc20Iface.encodeFunctionData("balanceOf", [user]) },
+            { target: spokeOft, allowFailure: false, callData: spokeDecimalsIface.encodeFunctionData("decimals") }
+          ];
+          const spokeRaw = await spokeMc.aggregate3.staticCall(spokeCalls);
+          const rawBalance = erc20Iface.decodeFunctionResult("balanceOf", spokeRaw[0].returnData)[0];
+          const spokeOftDecimals = Number(spokeDecimalsIface.decodeFunctionResult("decimals", spokeRaw[1].returnData)[0]);
+          let balance;
+          if (spokeOftDecimals > decimals) {
+            balance = rawBalance / 10n ** BigInt(spokeOftDecimals - decimals);
+          } else if (spokeOftDecimals < decimals) {
+            balance = rawBalance * 10n ** BigInt(decimals - spokeOftDecimals);
+          } else {
+            balance = rawBalance;
+          }
+          return { chainId: spokeChainId, balance, rawBalance };
+        } catch {
+          return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+        }
+      });
+      const results = await Promise.all(spokePromises);
+      for (const { chainId, balance, rawBalance } of results) {
+        spokeShares[chainId] = balance;
+        rawSpokeShares[chainId] = rawBalance;
+      }
+    }
+  }
+  const totalSpokeShares = Object.values(spokeShares).reduce((sum, b) => sum + b, 0n);
+  const totalShares = hubShares + totalSpokeShares;
+  const oneShare = 10n ** BigInt(decimals);
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, hubProvider);
+  const [estimatedAssets, sharePrice] = await Promise.all([
+    totalShares === 0n ? Promise.resolve(0n) : vaultContract.convertToAssets(totalShares),
+    vaultContract.convertToAssets(oneShare)
+  ]);
+  const currentTimestamp = BigInt(block?.timestamp ?? 0);
+  const pendingWithdrawal = withdrawShares === 0n ? null : {
+    shares: withdrawShares,
+    timelockEndsAt,
+    canRedeemNow: timelockEndsAt === 0n || currentTimestamp >= timelockEndsAt
+  };
+  return {
+    hubShares,
+    spokeShares,
+    rawSpokeShares,
+    totalShares,
+    estimatedAssets,
+    sharePrice,
+    decimals,
+    pendingWithdrawal
+  };
+}
+var MULTICALL3_ADDRESS3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+var MULTICALL3_ABI3 = [
+  "function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)"
+];
+async function getCuratorVaultStatus(provider, vault) {
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS3, MULTICALL3_ABI3, provider);
+  const curatorConfigIface = new ethers.Interface(CURATOR_CONFIG_ABI);
+  const multicallIface = new ethers.Interface(MULTICALL_ABI);
+  const calls = [
+    { target: vault, allowFailure: false, callData: curatorConfigIface.encodeFunctionData("curator") },
+    { target: vault, allowFailure: false, callData: curatorConfigIface.encodeFunctionData("timeLockPeriod") },
+    { target: vault, allowFailure: false, callData: curatorConfigIface.encodeFunctionData("getMaxSlippagePercent") },
+    { target: vault, allowFailure: false, callData: multicallIface.encodeFunctionData("getCurrentNonce") },
+    { target: vault, allowFailure: false, callData: curatorConfigIface.encodeFunctionData("getAvailableAssets") },
+    { target: vault, allowFailure: false, callData: curatorConfigIface.encodeFunctionData("getCrossChainAccountingManager") },
+    { target: vault, allowFailure: false, callData: curatorConfigIface.encodeFunctionData("paused") }
+  ];
+  const results = await mc.aggregate3.staticCall(calls);
+  const curator = curatorConfigIface.decodeFunctionResult("curator", results[0].returnData)[0];
+  const timeLockPeriod = curatorConfigIface.decodeFunctionResult("timeLockPeriod", results[1].returnData)[0];
+  const maxSlippagePercent = curatorConfigIface.decodeFunctionResult("getMaxSlippagePercent", results[2].returnData)[0];
+  const currentNonce = multicallIface.decodeFunctionResult("getCurrentNonce", results[3].returnData)[0];
+  const availableAssets = curatorConfigIface.decodeFunctionResult("getAvailableAssets", results[4].returnData)[0];
+  const lzAdapter = curatorConfigIface.decodeFunctionResult("getCrossChainAccountingManager", results[5].returnData)[0];
+  const paused = curatorConfigIface.decodeFunctionResult("paused", results[6].returnData)[0];
+  return {
+    curator,
+    timeLockPeriod,
+    maxSlippagePercent,
+    currentNonce,
+    availableAssets,
+    lzAdapter,
+    paused
+  };
+}
+async function getPendingActions(provider, vault, nonce) {
+  const multicallContract = new ethers.Contract(vault, MULTICALL_ABI, provider);
+  const [result, block] = await Promise.all([
+    multicallContract.getPendingActions(nonce),
+    provider.getBlock("latest")
+  ]);
+  const [actionsData, pendingUntil] = result;
+  const currentTimestamp = BigInt(block.timestamp);
+  const isExecutable = pendingUntil > 0n && currentTimestamp >= pendingUntil;
+  return {
+    nonce,
+    actionsData,
+    pendingUntil,
+    isExecutable
+  };
+}
+async function isCurator(provider, vault, address) {
+  const config = new ethers.Contract(vault, CURATOR_CONFIG_ABI, provider);
+  const curatorAddress = await config.curator();
+  return curatorAddress.toLowerCase() === address.toLowerCase();
+}
+async function getVaultAnalysis(provider, vault) {
+  const analysisContract = new ethers.Contract(vault, VAULT_ANALYSIS_ABI, provider);
+  const [availableRaw, depositableRaw, depositWhitelistEnabled, registryResult] = await Promise.all([
+    analysisContract.getAvailableAssets(),
+    analysisContract.getDepositableAssets(),
+    analysisContract.isDepositWhitelistEnabled(),
+    analysisContract.moreVaultsRegistry().catch(() => null)
+  ]);
+  const availableAddresses = availableRaw;
+  const depositableAddresses = depositableRaw;
+  const allAddresses = Array.from(/* @__PURE__ */ new Set([...availableAddresses, ...depositableAddresses]));
+  const assetInfoMap = /* @__PURE__ */ new Map();
+  if (allAddresses.length > 0) {
+    const mc = new ethers.Contract(MULTICALL3_ADDRESS3, MULTICALL3_ABI3, provider);
+    const metaIface = new ethers.Interface(METADATA_ABI);
+    const metadataCalls = allAddresses.flatMap((addr) => [
+      { target: addr, allowFailure: true, callData: metaIface.encodeFunctionData("name") },
+      { target: addr, allowFailure: true, callData: metaIface.encodeFunctionData("symbol") },
+      { target: addr, allowFailure: true, callData: metaIface.encodeFunctionData("decimals") }
+    ]);
+    const metadataResults = await mc.aggregate3.staticCall(metadataCalls);
+    for (let i = 0; i < allAddresses.length; i++) {
+      const addr = allAddresses[i];
+      const nameRes = metadataResults[i * 3];
+      const symbolRes = metadataResults[i * 3 + 1];
+      const decimalsRes = metadataResults[i * 3 + 2];
+      const name = nameRes.success ? metaIface.decodeFunctionResult("name", nameRes.returnData)[0] : "";
+      const symbol = symbolRes.success ? metaIface.decodeFunctionResult("symbol", symbolRes.returnData)[0] : "";
+      const decimals = decimalsRes.success ? Number(metaIface.decodeFunctionResult("decimals", decimalsRes.returnData)[0]) : 18;
+      assetInfoMap.set(addr.toLowerCase(), { address: addr, name, symbol, decimals });
+    }
+  }
+  const registryAddress = registryResult ? registryResult : null;
+  return {
+    availableAssets: availableAddresses.map((a) => assetInfoMap.get(a.toLowerCase())),
+    depositableAssets: depositableAddresses.map((a) => assetInfoMap.get(a.toLowerCase())),
+    depositWhitelistEnabled,
+    registryAddress
+  };
+}
+async function checkProtocolWhitelist(provider, vault, protocols) {
+  const analysisContract = new ethers.Contract(vault, VAULT_ANALYSIS_ABI, provider);
+  const registry = await analysisContract.moreVaultsRegistry();
+  if (protocols.length === 0) return {};
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS3, MULTICALL3_ABI3, provider);
+  const registryIface = new ethers.Interface(REGISTRY_ABI);
+  const calls = protocols.map((protocol) => ({
+    target: registry,
+    allowFailure: true,
+    callData: registryIface.encodeFunctionData("isWhitelisted", [protocol])
+  }));
+  const results = await mc.aggregate3.staticCall(calls);
+  const out = {};
+  for (let i = 0; i < protocols.length; i++) {
+    const r = results[i];
+    const whitelisted = r.success ? registryIface.decodeFunctionResult("isWhitelisted", r.returnData)[0] : false;
+    out[protocols[i].toLowerCase()] = whitelisted;
+  }
+  return out;
+}
+async function getVaultAssetBreakdown(provider, vault) {
+  const analysisContract = new ethers.Contract(vault, VAULT_ANALYSIS_ABI, provider);
+  const availableRaw = await analysisContract.getAvailableAssets();
+  const addresses = availableRaw;
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS3, MULTICALL3_ABI3, provider);
+  const vaultIface = new ethers.Interface(VAULT_ABI);
+  const metaIface = new ethers.Interface(METADATA_ABI);
+  const erc20Iface = new ethers.Interface(ERC20_ABI);
+  const perAssetCalls = addresses.flatMap((addr) => [
+    { target: addr, allowFailure: true, callData: erc20Iface.encodeFunctionData("balanceOf", [vault]) },
+    { target: addr, allowFailure: true, callData: metaIface.encodeFunctionData("name") },
+    { target: addr, allowFailure: true, callData: metaIface.encodeFunctionData("symbol") },
+    { target: addr, allowFailure: true, callData: metaIface.encodeFunctionData("decimals") }
+  ]);
+  const totalCalls = [
+    ...perAssetCalls,
+    { target: vault, allowFailure: true, callData: vaultIface.encodeFunctionData("totalAssets") },
+    { target: vault, allowFailure: true, callData: vaultIface.encodeFunctionData("totalSupply") },
+    { target: vault, allowFailure: true, callData: metaIface.encodeFunctionData("decimals") }
+  ];
+  const results = await mc.aggregate3.staticCall(totalCalls);
+  const perAssetFields = 4;
+  const assets = addresses.map((addr, i) => {
+    const base = i * perAssetFields;
+    const balance = results[base].success ? erc20Iface.decodeFunctionResult("balanceOf", results[base].returnData)[0] : 0n;
+    const name = results[base + 1].success ? metaIface.decodeFunctionResult("name", results[base + 1].returnData)[0] : "";
+    const symbol = results[base + 2].success ? metaIface.decodeFunctionResult("symbol", results[base + 2].returnData)[0] : "";
+    const decimals = results[base + 3].success ? Number(metaIface.decodeFunctionResult("decimals", results[base + 3].returnData)[0]) : 18;
+    return { address: addr, name, symbol, decimals, balance };
+  });
+  const totalsBase = addresses.length * perAssetFields;
+  const totalAssets = results[totalsBase].success ? vaultIface.decodeFunctionResult("totalAssets", results[totalsBase].returnData)[0] : 0n;
+  const totalSupply = results[totalsBase + 1].success ? vaultIface.decodeFunctionResult("totalSupply", results[totalsBase + 1].returnData)[0] : 0n;
+  const underlyingDecimals = results[totalsBase + 2].success ? Number(metaIface.decodeFunctionResult("decimals", results[totalsBase + 2].returnData)[0]) : 6;
+  return { assets, totalAssets, totalSupply, underlyingDecimals };
+}
+function encodeCuratorAction(action) {
+  switch (action.type) {
+    case "swap": {
+      const iface = new ethers.Interface(DEX_ABI);
+      return iface.encodeFunctionData("executeSwap", [
+        {
+          targetContract: action.params.targetContract,
+          tokenIn: action.params.tokenIn,
+          tokenOut: action.params.tokenOut,
+          maxAmountIn: action.params.maxAmountIn,
+          minAmountOut: action.params.minAmountOut,
+          swapCallData: action.params.swapCallData
+        }
+      ]);
+    }
+    case "batchSwap": {
+      const iface = new ethers.Interface(DEX_ABI);
+      return iface.encodeFunctionData("executeBatchSwap", [
+        {
+          swaps: action.params.swaps.map((s) => ({
+            targetContract: s.targetContract,
+            tokenIn: s.tokenIn,
+            tokenOut: s.tokenOut,
+            maxAmountIn: s.maxAmountIn,
+            minAmountOut: s.minAmountOut,
+            swapCallData: s.swapCallData
+          }))
+        }
+      ]);
+    }
+    case "erc4626Deposit": {
+      const iface = new ethers.Interface(ERC4626_FACET_ABI);
+      return iface.encodeFunctionData("erc4626Deposit", [action.vault, action.assets]);
+    }
+    case "erc4626Redeem": {
+      const iface = new ethers.Interface(ERC4626_FACET_ABI);
+      return iface.encodeFunctionData("erc4626Redeem", [action.vault, action.shares]);
+    }
+    case "erc7540RequestDeposit": {
+      const iface = new ethers.Interface(ERC7540_FACET_ABI);
+      return iface.encodeFunctionData("erc7540RequestDeposit", [action.vault, action.assets]);
+    }
+    case "erc7540Deposit": {
+      const iface = new ethers.Interface(ERC7540_FACET_ABI);
+      return iface.encodeFunctionData("erc7540Deposit", [action.vault, action.assets]);
+    }
+    case "erc7540RequestRedeem": {
+      const iface = new ethers.Interface(ERC7540_FACET_ABI);
+      return iface.encodeFunctionData("erc7540RequestRedeem", [action.vault, action.shares]);
+    }
+    case "erc7540Redeem": {
+      const iface = new ethers.Interface(ERC7540_FACET_ABI);
+      return iface.encodeFunctionData("erc7540Redeem", [action.vault, action.shares]);
+    }
+    default: {
+      const _exhaustive = action;
+      throw new Error(`[MoreVaults] Unknown CuratorAction type: ${_exhaustive.type}`);
+    }
+  }
+}
+function buildCuratorBatch(actions) {
+  return actions.map(encodeCuratorAction);
+}
+async function submitActions(signer, vault, actions) {
+  const multicallContract = new ethers.Contract(vault, MULTICALL_ABI, signer);
+  const tx = await multicallContract.submitActions(actions);
+  const receipt = await tx.wait();
+  const nextNonce = await multicallContract.getCurrentNonce();
+  const nonce = nextNonce - 1n;
+  return { receipt, nonce };
+}
+async function executeActions(signer, vault, nonce) {
+  const multicallContract = new ethers.Contract(vault, MULTICALL_ABI, signer);
+  const tx = await multicallContract.executeActions(nonce);
+  return tx.wait();
+}
+async function vetoActions(signer, vault, nonces) {
+  const multicallContract = new ethers.Contract(vault, MULTICALL_ABI, signer);
+  const tx = await multicallContract.vetoActions(nonces);
+  return tx.wait();
+}
+var UNISWAP_V3_SWAP_ROUTER_ABI = [
+  "function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) payable returns (uint256 amountOut)"
+];
+var UNISWAP_V3_SWAP_ROUTER02_ABI = [
+  "function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96) params) payable returns (uint256 amountOut)"
+];
+var SWAP_ROUTER02_CHAINS = /* @__PURE__ */ new Set([8453]);
+function encodeUniswapV3SwapCalldata(params) {
+  const { chainId, tokenIn, tokenOut, fee, amountIn, minAmountOut, recipient } = params;
+  const router = UNISWAP_V3_ROUTERS[chainId];
+  if (!router) {
+    throw new Error(
+      `[MoreVaults] No Uniswap V3 router configured for chainId ${chainId}. Supported chains: ${Object.keys(UNISWAP_V3_ROUTERS).join(", ")}`
+    );
+  }
+  let swapCallData;
+  if (SWAP_ROUTER02_CHAINS.has(chainId)) {
+    const iface = new ethers.Interface(UNISWAP_V3_SWAP_ROUTER02_ABI);
+    swapCallData = iface.encodeFunctionData("exactInputSingle", [
+      {
+        tokenIn,
+        tokenOut,
+        fee,
+        recipient,
+        amountIn,
+        amountOutMinimum: minAmountOut,
+        sqrtPriceLimitX96: 0n
+      }
+    ]);
+  } else {
+    const deadline = BigInt(Math.floor(Date.now() / 1e3) + 1200);
+    const iface = new ethers.Interface(UNISWAP_V3_SWAP_ROUTER_ABI);
+    swapCallData = iface.encodeFunctionData("exactInputSingle", [
+      {
+        tokenIn,
+        tokenOut,
+        fee,
+        recipient,
+        deadline,
+        amountIn,
+        amountOutMinimum: minAmountOut,
+        sqrtPriceLimitX96: 0n
+      }
+    ]);
+  }
+  return { targetContract: router, swapCallData };
+}
+function buildUniswapV3Swap(params) {
+  const { targetContract, swapCallData } = encodeUniswapV3SwapCalldata(params);
+  return {
+    type: "swap",
+    params: {
+      targetContract,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      maxAmountIn: params.amountIn,
+      minAmountOut: params.minAmountOut,
+      swapCallData
+    }
+  };
+}
+
+// src/ethers/distribution.ts
+async function getVaultDistribution(hubProvider, vault, spokeProviders) {
+  const hubStatus = await getVaultStatus(hubProvider, vault);
+  const hubChainId = Number((await hubProvider.getNetwork()).chainId);
+  const hubTotalAssets = hubStatus.totalAssets;
+  const hubLiquidBalance = hubStatus.hubLiquidBalance;
+  const hubStrategyBalance = hubTotalAssets > hubLiquidBalance ? hubTotalAssets - hubLiquidBalance : 0n;
+  const spokeEntries = Object.entries(spokeProviders).map(([chainIdStr, provider]) => ({
+    chainId: Number(chainIdStr),
+    provider
+  }));
+  const spokeBalances = await Promise.all(
+    spokeEntries.map(async ({ chainId, provider }) => {
+      try {
+        const spokeStatus = await getVaultStatus(provider, vault);
+        return { chainId, totalAssets: spokeStatus.totalAssets, isReachable: true };
+      } catch {
+        return { chainId, totalAssets: 0n, isReachable: false };
+      }
+    })
+  );
+  const reachableSpokeSum = spokeBalances.filter((s) => s.isReachable).reduce((acc, s) => acc + s.totalAssets, 0n);
+  const totalActual = hubTotalAssets + reachableSpokeSum;
+  return {
+    hubChainId,
+    hubLiquidBalance,
+    hubStrategyBalance,
+    hubTotalAssets,
+    spokesDeployedBalance: hubStatus.spokesDeployedBalance,
+    spokeBalances,
+    totalActual,
+    oracleAccountingEnabled: hubStatus.oracleAccountingEnabled
+  };
+}
+async function getVaultDistributionWithTopology(hubProvider, vault) {
+  const [hubStatus, topology] = await Promise.all([
+    getVaultStatus(hubProvider, vault),
+    getVaultTopology(hubProvider, vault)
+  ]);
+  const hubChainId = Number((await hubProvider.getNetwork()).chainId);
+  const hubTotalAssets = hubStatus.totalAssets;
+  const hubLiquidBalance = hubStatus.hubLiquidBalance;
+  const hubStrategyBalance = hubTotalAssets > hubLiquidBalance ? hubTotalAssets - hubLiquidBalance : 0n;
+  return {
+    hubChainId,
+    hubLiquidBalance,
+    hubStrategyBalance,
+    hubTotalAssets,
+    spokesDeployedBalance: hubStatus.spokesDeployedBalance,
+    spokeBalances: [],
+    totalActual: hubTotalAssets,
+    // hub-only, no spoke data
+    oracleAccountingEnabled: hubStatus.oracleAccountingEnabled,
+    spokeChainIds: topology.spokeChainIds
+  };
+}
+var NATIVE_SYMBOL = {
+  1: "ETH",
+  10: "ETH",
+  42161: "ETH",
+  8453: "ETH",
+  747: "FLOW",
+  146: "S",
+  56: "BNB"
+};
+var SYMBOL_ABI = [
+  "function symbol() view returns (string)"
+];
+async function readTokenSymbol(provider, token, fallbackSymbol) {
+  if (!provider) return fallbackSymbol;
+  try {
+    const contract = new ethers.Contract(token, SYMBOL_ABI, provider);
+    return await contract.symbol();
+  } catch {
+    return fallbackSymbol;
+  }
+}
+async function getInboundRoutes(hubChainId, vault, vaultAsset, userAddress) {
+  const hubEid = CHAIN_ID_TO_EID[hubChainId];
+  if (!hubEid) throw new Error(`No LZ EID for hub chainId ${hubChainId}`);
+  const hubProvider = createChainProvider(hubChainId);
+  if (!hubProvider) throw new Error(`No public RPC for hub chainId ${hubChainId}`);
+  const topology = await getVaultTopology(hubProvider, vault);
+  const registeredSpokes = new Set(topology.spokeChainIds);
+  const results = [];
+  const vaultAssetNorm = vaultAsset.toLowerCase();
+  for (const [symbol, chainMap] of Object.entries(OFT_ROUTES)) {
+    const hubEntry = chainMap[hubChainId];
+    if (!hubEntry) continue;
+    if (hubEntry.token.toLowerCase() !== vaultAssetNorm) continue;
+    const oftCmd = "0x";
+    const spokesToCheck = Object.keys(chainMap).map(Number).filter((id) => id !== hubChainId && registeredSpokes.has(id));
+    await Promise.allSettled(
+      spokesToCheck.map(async (spokeChainId) => {
+        const spokeEntry = chainMap[spokeChainId];
+        if (!spokeEntry) return;
+        const spokeProvider = createChainProvider(spokeChainId);
+        if (!spokeProvider) return;
+        try {
+          const receiverBytes32 = "0x" + userAddress.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+          const spokeOft = new ethers.Contract(spokeEntry.oft, OFT_ABI, spokeProvider);
+          const [feeResult, sourceTokenSymbol] = await Promise.all([
+            spokeOft.quoteSend(
+              {
+                dstEid: hubEid,
+                to: receiverBytes32,
+                amountLD: 1000000n,
+                minAmountLD: 0n,
+                extraOptions: "0x",
+                composeMsg: "0x",
+                oftCmd
+              },
+              false
+            ),
+            readTokenSymbol(spokeProvider, spokeEntry.token, symbol)
+          ]);
+          results.push({
+            symbol,
+            spokeChainId,
+            depositType: "oft-compose",
+            spokeOft: spokeEntry.oft,
+            spokeToken: spokeEntry.token,
+            sourceTokenSymbol,
+            hubOft: hubEntry.oft,
+            oftCmd,
+            lzFeeEstimate: feeResult.nativeFee,
+            nativeSymbol: NATIVE_SYMBOL[spokeChainId] ?? "ETH"
+          });
+        } catch {
+        }
+      })
+    );
+  }
+  const [asyncMode, ...hubOftEntries] = await Promise.all([
+    isAsyncMode(hubProvider, vault),
+    ...Object.entries(OFT_ROUTES).map(async ([sym, chainMap]) => {
+      const hubEntry = chainMap[hubChainId];
+      if (!hubEntry || hubEntry.token.toLowerCase() !== vaultAssetNorm) return null;
+      return { symbol: sym, hubEntry };
+    })
+  ]);
+  const hubOftEntry = hubOftEntries.find((e) => e !== null) ?? null;
+  if (hubOftEntry) {
+    const { symbol, hubEntry } = hubOftEntry;
+    const [sourceTokenSymbol, lzFeeEstimate] = await Promise.all([
+      readTokenSymbol(hubProvider, hubEntry.token, symbol),
+      asyncMode ? quoteLzFee(hubProvider, vault) : Promise.resolve(0n)
+    ]);
+    results.unshift({
+      symbol,
+      spokeChainId: hubChainId,
+      depositType: asyncMode ? "direct-async" : "direct",
+      spokeOft: null,
+      spokeToken: hubEntry.token,
+      sourceTokenSymbol,
+      hubOft: null,
+      oftCmd: "0x",
+      lzFeeEstimate,
+      nativeSymbol: NATIVE_SYMBOL[hubChainId] ?? "ETH"
+    });
+  }
+  return results;
+}
+async function getUserBalancesForRoutes(routes, userAddress) {
+  return Promise.all(
+    routes.map(async (route) => {
+      const provider = createChainProvider(route.spokeChainId);
+      if (!provider) return { ...route, userBalance: 0n };
+      try {
+        let userBalance;
+        if (route.spokeToken.toLowerCase() === ethers.ZeroAddress.toLowerCase()) {
+          userBalance = await provider.getBalance(userAddress);
+        } else {
+          const erc20 = new ethers.Contract(route.spokeToken, ERC20_ABI, provider);
+          userBalance = await erc20.balanceOf(userAddress);
+        }
+        return { ...route, userBalance };
+      } catch {
+        return { ...route, userBalance: 0n };
+      }
+    })
+  );
+}
+async function getOutboundRoutes(hubChainId, vault) {
+  const hubEid = CHAIN_ID_TO_EID[hubChainId];
+  if (!hubEid) throw new Error(`No LZ EID for hub chainId ${hubChainId}`);
+  const hubProvider = createChainProvider(hubChainId);
+  if (!hubProvider) throw new Error(`No public RPC for hub chainId ${hubChainId}`);
+  const topology = await getVaultTopology(hubProvider, vault);
+  const routes = [
+    {
+      chainId: hubChainId,
+      routeType: "hub",
+      eid: hubEid,
+      nativeSymbol: NATIVE_SYMBOL[hubChainId] ?? "ETH"
+    }
+  ];
+  for (const spokeChainId of topology.spokeChainIds) {
+    const eid = CHAIN_ID_TO_EID[spokeChainId];
+    if (!eid) continue;
+    routes.push({
+      chainId: spokeChainId,
+      routeType: "spoke",
+      eid,
+      nativeSymbol: NATIVE_SYMBOL[spokeChainId] ?? "ETH"
+    });
+  }
+  return routes;
+}
+async function quoteRouteDepositFee(route, hubChainId, amount, userAddress) {
+  if (route.depositType === "direct") return 0n;
+  const hubEid = CHAIN_ID_TO_EID[hubChainId];
+  if (!hubEid) throw new Error(`No LZ EID for hub chainId ${hubChainId}`);
+  if (!route.spokeOft) throw new Error("Route is oft-compose but spokeOft is null");
+  const spokeProvider = createChainProvider(route.spokeChainId);
+  if (!spokeProvider) throw new Error(`No public RPC for spoke chainId ${route.spokeChainId}`);
+  const receiverBytes32 = "0x" + userAddress.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+  const spokeOft = new ethers.Contract(route.spokeOft, OFT_ABI, spokeProvider);
+  const feeResult = await spokeOft.quoteSend(
+    {
+      dstEid: hubEid,
+      to: receiverBytes32,
+      amountLD: amount,
+      minAmountLD: 0n,
+      extraOptions: "0x",
+      composeMsg: "0x",
+      oftCmd: route.oftCmd
+    },
+    false
+  );
+  return feeResult.nativeFee;
+}
 
 // src/ethers/wagmiCompat.ts
 function asSdkSigner(signer) {
@@ -1105,63 +2540,107 @@ function asSdkSigner(signer) {
 
 exports.ActionType = ActionType;
 exports.BRIDGE_ABI = BRIDGE_ABI;
+exports.BRIDGE_FACET_ABI = BRIDGE_FACET_ABI;
 exports.CCManagerNotConfiguredError = CCManagerNotConfiguredError;
 exports.CHAIN_IDS = CHAIN_IDS;
 exports.CHAIN_ID_TO_EID = CHAIN_ID_TO_EID;
 exports.CONFIG_ABI = CONFIG_ABI;
+exports.CURATOR_CONFIG_ABI = CURATOR_CONFIG_ABI;
 exports.CapacityFullError = CapacityFullError;
+exports.DEX_ABI = DEX_ABI;
 exports.EID_TO_CHAIN_ID = EID_TO_CHAIN_ID;
 exports.ERC20_ABI = ERC20_ABI;
+exports.ERC4626_FACET_ABI = ERC4626_FACET_ABI;
+exports.ERC7540_FACET_ABI = ERC7540_FACET_ABI;
 exports.EscrowNotConfiguredError = EscrowNotConfiguredError;
 exports.InsufficientLiquidityError = InsufficientLiquidityError;
+exports.LZ_ADAPTER_ABI = LZ_ADAPTER_ABI;
 exports.LZ_EIDS = LZ_EIDS;
 exports.LZ_ENDPOINT_ABI = LZ_ENDPOINT_ABI;
 exports.LZ_TIMEOUTS = LZ_TIMEOUTS;
 exports.METADATA_ABI = METADATA_ABI;
+exports.MULTICALL_ABI = MULTICALL_ABI;
 exports.MissingEscrowAddressError = MissingEscrowAddressError;
 exports.MoreVaultsError = MoreVaultsError;
+exports.NATIVE_SYMBOL = NATIVE_SYMBOL;
 exports.NotHubVaultError = NotHubVaultError;
 exports.NotWhitelistedError = NotWhitelistedError;
 exports.OFT_ABI = OFT_ABI;
+exports.OFT_ROUTES = OFT_ROUTES;
+exports.OMNI_FACTORY_ADDRESS = OMNI_FACTORY_ADDRESS;
+exports.REGISTRY_ABI = REGISTRY_ABI;
+exports.UNISWAP_V3_ROUTERS = UNISWAP_V3_ROUTERS;
 exports.VAULT_ABI = VAULT_ABI;
+exports.VAULT_ANALYSIS_ABI = VAULT_ANALYSIS_ABI;
 exports.VaultPausedError = VaultPausedError;
 exports.WrongChainError = WrongChainError;
 exports.asSdkSigner = asSdkSigner;
 exports.bridgeAssetsToSpoke = bridgeAssetsToSpoke;
 exports.bridgeSharesToHub = bridgeSharesToHub;
+exports.buildCuratorBatch = buildCuratorBatch;
+exports.buildUniswapV3Swap = buildUniswapV3Swap;
 exports.canDeposit = canDeposit;
+exports.checkProtocolWhitelist = checkProtocolWhitelist;
 exports.depositAsync = depositAsync;
 exports.depositCrossChainOracleOn = depositCrossChainOracleOn;
 exports.depositFromSpoke = depositFromSpoke;
 exports.depositFromSpokeAsync = depositFromSpokeAsync;
 exports.depositMultiAsset = depositMultiAsset;
 exports.depositSimple = depositSimple;
+exports.detectStargateOft = detectStargateOft;
+exports.discoverVaultTopology = discoverVaultTopology;
+exports.encodeCuratorAction = encodeCuratorAction;
+exports.encodeUniswapV3SwapCalldata = encodeUniswapV3SwapCalldata;
 exports.ensureAllowance = ensureAllowance;
+exports.executeActions = executeActions;
 exports.executeCompose = executeCompose;
+exports.getAllVaultChainIds = getAllVaultChainIds;
 exports.getAsyncRequestStatus = getAsyncRequestStatus;
 exports.getAsyncRequestStatusLabel = getAsyncRequestStatusLabel;
+exports.getCuratorVaultStatus = getCuratorVaultStatus;
+exports.getFullVaultTopology = getFullVaultTopology;
+exports.getInboundRoutes = getInboundRoutes;
 exports.getMaxWithdrawable = getMaxWithdrawable;
+exports.getOutboundRoutes = getOutboundRoutes;
+exports.getPendingActions = getPendingActions;
 exports.getUserBalances = getUserBalances;
+exports.getUserBalancesForRoutes = getUserBalancesForRoutes;
 exports.getUserPosition = getUserPosition;
+exports.getUserPositionMultiChain = getUserPositionMultiChain;
+exports.getVaultAnalysis = getVaultAnalysis;
+exports.getVaultAssetBreakdown = getVaultAssetBreakdown;
+exports.getVaultDistribution = getVaultDistribution;
+exports.getVaultDistributionWithTopology = getVaultDistributionWithTopology;
 exports.getVaultMetadata = getVaultMetadata;
 exports.getVaultStatus = getVaultStatus;
 exports.getVaultSummary = getVaultSummary;
+exports.getVaultTopology = getVaultTopology;
 exports.getWithdrawalRequest = getWithdrawalRequest;
 exports.isAsyncMode = isAsyncMode;
+exports.isCurator = isCurator;
+exports.isOnHubChain = isOnHubChain;
 exports.mintAsync = mintAsync;
 exports.preflightAsync = preflightAsync;
 exports.preflightRedeemLiquidity = preflightRedeemLiquidity;
+exports.preflightSpokeDeposit = preflightSpokeDeposit;
+exports.preflightSpokeRedeem = preflightSpokeRedeem;
 exports.preflightSync = preflightSync;
 exports.previewDeposit = previewDeposit;
 exports.previewRedeem = previewRedeem;
 exports.quoteComposeFee = quoteComposeFee;
 exports.quoteDepositFromSpokeFee = quoteDepositFromSpokeFee;
 exports.quoteLzFee = quoteLzFee;
+exports.quoteRouteDepositFee = quoteRouteDepositFee;
+exports.quoteShareBridgeFee = quoteShareBridgeFee;
 exports.redeemAsync = redeemAsync;
 exports.redeemShares = redeemShares;
 exports.requestRedeem = requestRedeem;
+exports.resolveRedeemAddresses = resolveRedeemAddresses;
 exports.smartDeposit = smartDeposit;
 exports.smartRedeem = smartRedeem;
+exports.submitActions = submitActions;
+exports.vetoActions = vetoActions;
+exports.waitForCompose = waitForCompose;
 exports.withdrawAssets = withdrawAssets;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map