@oydual31/more-vaults-sdk 0.1.0

package/dist/viem/index.js

@@ -0,0 +1,1377 @@
+import { getAddress, zeroAddress, encodeAbiParameters, pad } from 'viem';
+
+// src/viem/abis.ts
+var VAULT_ABI = [
+  {
+    type: "function",
+    name: "deposit",
+    inputs: [
+      { name: "assets", type: "uint256" },
+      { name: "receiver", type: "address" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "deposit",
+    inputs: [
+      { name: "tokens", type: "address[]" },
+      { name: "assets", type: "uint256[]" },
+      { name: "receiver", type: "address" },
+      { name: "minAmountOut", type: "uint256" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "mint",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "receiver", type: "address" }
+    ],
+    outputs: [{ name: "assets", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    inputs: [
+      { name: "assets", type: "uint256" },
+      { name: "receiver", type: "address" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "redeem",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "receiver", type: "address" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "assets", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "requestRedeem",
+    inputs: [
+      { name: "_shares", type: "uint256" },
+      { name: "_onBehalfOf", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "requestWithdraw",
+    inputs: [
+      { name: "_assets", type: "uint256" },
+      { name: "_onBehalfOf", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getWithdrawalRequest",
+    inputs: [{ name: "_owner", type: "address" }],
+    outputs: [
+      { name: "shares", type: "uint256" },
+      { name: "timelockEndsAt", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalAssets",
+    inputs: [],
+    outputs: [{ name: "_totalAssets", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "asset",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "convertToShares",
+    inputs: [{ name: "assets", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "convertToAssets",
+    inputs: [{ name: "shares", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "previewDeposit",
+    inputs: [{ name: "assets", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "previewRedeem",
+    inputs: [{ name: "shares", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var BRIDGE_ABI = [
+  {
+    type: "function",
+    name: "initVaultActionRequest",
+    inputs: [
+      { name: "actionType", type: "uint8" },
+      { name: "actionCallData", type: "bytes" },
+      { name: "amountLimit", type: "uint256" },
+      { name: "extraOptions", type: "bytes" }
+    ],
+    outputs: [{ name: "guid", type: "bytes32" }],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "getRequestInfo",
+    inputs: [{ name: "guid", type: "bytes32" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "initiator", type: "address" },
+          { name: "timestamp", type: "uint64" },
+          { name: "actionType", type: "uint8" },
+          { name: "actionCallData", type: "bytes" },
+          { name: "fulfilled", type: "bool" },
+          { name: "finalized", type: "bool" },
+          { name: "refunded", type: "bool" },
+          { name: "totalAssets", type: "uint256" },
+          { name: "finalizationResult", type: "uint256" },
+          { name: "amountLimit", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getFinalizationResult",
+    inputs: [{ name: "guid", type: "bytes32" }],
+    outputs: [{ name: "result", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteAccountingFee",
+    inputs: [{ name: "extraOptions", type: "bytes" }],
+    outputs: [{ name: "nativeFee", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "oraclesCrossChainAccounting",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  }
+];
+var CONFIG_ABI = [
+  {
+    type: "function",
+    name: "getEscrow",
+    inputs: [],
+    outputs: [{ name: "escrow", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCrossChainAccountingManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isHub",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getWithdrawalQueueStatus",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getWithdrawalTimelock",
+    inputs: [],
+    outputs: [{ name: "", type: "uint64" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "maxDeposit",
+    inputs: [{ name: "receiver", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var METADATA_ABI = [
+  { type: "function", name: "name", inputs: [], outputs: [{ name: "", type: "string" }], stateMutability: "view" },
+  { type: "function", name: "symbol", inputs: [], outputs: [{ name: "", type: "string" }], stateMutability: "view" },
+  { type: "function", name: "decimals", inputs: [], outputs: [{ name: "", type: "uint8" }], stateMutability: "view" }
+];
+var OFT_ABI = [
+  {
+    type: "function",
+    name: "send",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      {
+        name: "_fee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      },
+      { name: "_refundAddress", type: "address" }
+    ],
+    outputs: [
+      {
+        name: "msgReceipt",
+        type: "tuple",
+        components: [
+          { name: "guid", type: "bytes32" },
+          { name: "nonce", type: "uint64" },
+          {
+            name: "fee",
+            type: "tuple",
+            components: [
+              { name: "nativeFee", type: "uint256" },
+              { name: "lzTokenFee", type: "uint256" }
+            ]
+          }
+        ]
+      },
+      {
+        name: "oftReceipt",
+        type: "tuple",
+        components: [
+          { name: "amountSentLD", type: "uint256" },
+          { name: "amountReceivedLD", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "quoteSend",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      { name: "_payInLzToken", type: "bool" }
+    ],
+    outputs: [
+      {
+        name: "msgFee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/viem/types.ts
+var ActionType = {
+  DEPOSIT: 0,
+  MINT: 1,
+  WITHDRAW: 2,
+  REDEEM: 3,
+  MULTI_ASSETS_DEPOSIT: 4,
+  ACCRUE_FEES: 5
+};
+
+// src/viem/errors.ts
+var MoreVaultsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MoreVaultsError";
+  }
+};
+var VaultPausedError = class extends MoreVaultsError {
+  constructor(vault) {
+    super(`[MoreVaults] Vault ${vault} is paused. Cannot perform any actions.`);
+    this.name = "VaultPausedError";
+  }
+};
+var CapacityFullError = class extends MoreVaultsError {
+  constructor(vault) {
+    super(`[MoreVaults] Vault ${vault} has reached deposit capacity. No more deposits accepted.`);
+    this.name = "CapacityFullError";
+  }
+};
+var NotWhitelistedError = class extends MoreVaultsError {
+  constructor(vault, user) {
+    super(`[MoreVaults] Address ${user} is not whitelisted to deposit in vault ${vault}.`);
+    this.name = "NotWhitelistedError";
+  }
+};
+var InsufficientLiquidityError = class extends MoreVaultsError {
+  hubLiquid;
+  required;
+  constructor(vault, hubLiquid, required) {
+    super(
+      `[MoreVaults] Insufficient hub liquidity for redeem.
+  Hub liquid balance : ${hubLiquid}
+  Estimated required : ${required}
+Submitting this redeem will waste the LayerZero fee \u2014 the request will be auto-refunded.
+Ask the vault curator to repatriate liquidity from spoke chains first.`
+    );
+    this.name = "InsufficientLiquidityError";
+    this.hubLiquid = hubLiquid;
+    this.required = required;
+  }
+};
+var CCManagerNotConfiguredError = class extends MoreVaultsError {
+  constructor(vault) {
+    super(`[MoreVaults] CCManager not configured on vault ${vault}. Call setCrossChainAccountingManager(ccManagerAddress) as vault owner first.`);
+    this.name = "CCManagerNotConfiguredError";
+  }
+};
+var EscrowNotConfiguredError = class extends MoreVaultsError {
+  constructor(vault) {
+    super(`[MoreVaults] Escrow not configured for vault ${vault}. The registry must have an escrow set for this vault.`);
+    this.name = "EscrowNotConfiguredError";
+  }
+};
+var NotHubVaultError = class extends MoreVaultsError {
+  constructor(vault) {
+    super(`[MoreVaults] Vault ${vault} is not a hub vault. Async flows (D4/D5/R5) only work on hub vaults.`);
+    this.name = "NotHubVaultError";
+  }
+};
+var MissingEscrowAddressError = class extends MoreVaultsError {
+  constructor() {
+    super(`[MoreVaults] This flow requires an escrow address. Set VaultAddresses.escrow before calling async deposit/redeem flows.`);
+    this.name = "MissingEscrowAddressError";
+  }
+};
+async function getVaultStatus(publicClient, vault) {
+  const v = getAddress(vault);
+  const b1 = await publicClient.multicall({
+    contracts: [
+      { address: v, abi: CONFIG_ABI, functionName: "isHub" },
+      { address: v, abi: CONFIG_ABI, functionName: "paused" },
+      { address: v, abi: BRIDGE_ABI, functionName: "oraclesCrossChainAccounting" },
+      { address: v, abi: CONFIG_ABI, functionName: "getCrossChainAccountingManager" },
+      { address: v, abi: CONFIG_ABI, functionName: "getEscrow" },
+      { address: v, abi: CONFIG_ABI, functionName: "getWithdrawalQueueStatus" },
+      { address: v, abi: CONFIG_ABI, functionName: "getWithdrawalTimelock" },
+      { address: v, abi: CONFIG_ABI, functionName: "maxDeposit", args: [zeroAddress] },
+      { address: v, abi: VAULT_ABI, functionName: "asset" },
+      { address: v, abi: VAULT_ABI, functionName: "totalAssets" },
+      { address: v, abi: VAULT_ABI, functionName: "totalSupply" },
+      { address: v, abi: METADATA_ABI, functionName: "decimals" }
+    ],
+    allowFailure: true
+  });
+  const isHub = b1[0].status === "success" ? b1[0].result : false;
+  const isPaused = b1[1].status === "success" ? b1[1].result : false;
+  const oraclesEnabled = b1[2].status === "success" ? b1[2].result : false;
+  const ccManager = b1[3].status === "success" ? b1[3].result : zeroAddress;
+  const escrow = b1[4].status === "success" ? b1[4].result : zeroAddress;
+  const withdrawalQueueEnabled = b1[5].status === "success" ? b1[5].result : false;
+  const withdrawalTimelockSeconds = b1[6].status === "success" ? b1[6].result : 0n;
+  const maxDepositRaw = b1[7].status === "success" ? b1[7].result : null;
+  const underlying = b1[8].status === "success" ? b1[8].result : zeroAddress;
+  const totalAssets = b1[9].status === "success" ? b1[9].result : 0n;
+  const totalSupply = b1[10].status === "success" ? b1[10].result : 0n;
+  const decimals = b1[11].status === "success" ? Number(b1[11].result) : 18;
+  const oneShare = 10n ** BigInt(decimals);
+  const b2 = await publicClient.multicall({
+    contracts: [
+      { address: getAddress(underlying), abi: ERC20_ABI, functionName: "balanceOf", args: [v] },
+      { address: v, abi: VAULT_ABI, functionName: "convertToAssets", args: [oneShare] }
+    ],
+    allowFailure: true
+  });
+  const hubLiquidBalance = b2[0].status === "success" ? b2[0].result : 0n;
+  const sharePrice = b2[1].status === "success" ? b2[1].result : 0n;
+  const spokesDeployedBalance = totalAssets > hubLiquidBalance ? totalAssets - hubLiquidBalance : 0n;
+  const MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+  const depositAccessRestricted = maxDepositRaw === null;
+  const effectiveCapacity = depositAccessRestricted ? MAX_UINT256 : maxDepositRaw;
+  let mode;
+  if (isPaused) {
+    mode = "paused";
+  } else if (effectiveCapacity === 0n) {
+    mode = "full";
+  } else if (!isHub) {
+    mode = "local";
+  } else if (oraclesEnabled) {
+    mode = "cross-chain-oracle";
+  } else {
+    mode = "cross-chain-async";
+  }
+  let recommendedDepositFlow;
+  let recommendedRedeemFlow;
+  if (mode === "paused" || mode === "full") {
+    recommendedDepositFlow = "none";
+    recommendedRedeemFlow = mode === "paused" ? "none" : "redeemShares";
+  } else if (mode === "cross-chain-async") {
+    recommendedDepositFlow = "depositAsync";
+    recommendedRedeemFlow = "redeemAsync";
+  } else {
+    recommendedDepositFlow = "depositSimple";
+    recommendedRedeemFlow = "redeemShares";
+  }
+  const maxImmediateRedeemAssets = isHub && !oraclesEnabled ? hubLiquidBalance : totalAssets;
+  const issues = [];
+  if (isPaused) {
+    issues.push("Vault is paused \u2014 no deposits or redeems are possible.");
+  }
+  if (effectiveCapacity === 0n && !isPaused) {
+    issues.push("Deposit capacity is full \u2014 increase depositCapacity via setDepositCapacity().");
+  }
+  if (depositAccessRestricted) {
+    issues.push("Deposit access is restricted (whitelist or other access control). Only approved addresses can deposit.");
+  }
+  if (isHub && !oraclesEnabled && ccManager === zeroAddress) {
+    issues.push(
+      "CCManager not configured \u2014 async flows will revert. Call setCrossChainAccountingManager(address) as vault owner."
+    );
+  }
+  if (isHub && !oraclesEnabled && escrow === zeroAddress) {
+    issues.push(
+      "Escrow not configured in registry \u2014 async flows will revert. Set the escrow via the MoreVaultsRegistry."
+    );
+  }
+  if (isHub) {
+    if (hubLiquidBalance === 0n) {
+      issues.push(
+        `Hub has no liquid assets (hubLiquidBalance = 0). All redeems will be auto-refunded until the curator repatriates funds from spokes via executeBridging().`
+      );
+    } else if (totalAssets > 0n && hubLiquidBalance * 10n < totalAssets) {
+      const pct = Number(hubLiquidBalance * 10000n / totalAssets) / 100;
+      issues.push(
+        `Low hub liquidity: ${hubLiquidBalance} units liquid on hub (${pct.toFixed(1)}% of TVL). Redeems above ${hubLiquidBalance} underlying units will be auto-refunded. Curator must call executeBridging() to repatriate from spokes.`
+      );
+    }
+    if (spokesDeployedBalance > 0n) {
+      const pct = (Number(spokesDeployedBalance) / Number(totalAssets || 1n) * 100).toFixed(1);
+      issues.push(
+        `${spokesDeployedBalance} units (~${pct}% of TVL) are deployed on spoke chains earning yield. These are NOT immediately redeemable \u2014 they require a curator repatriation (executeBridging) before users can withdraw them.`
+      );
+    }
+  }
+  return {
+    mode,
+    recommendedDepositFlow,
+    recommendedRedeemFlow,
+    isHub,
+    isPaused,
+    oracleAccountingEnabled: oraclesEnabled,
+    ccManager,
+    escrow,
+    withdrawalQueueEnabled,
+    withdrawalTimelockSeconds: BigInt(withdrawalTimelockSeconds),
+    remainingDepositCapacity: effectiveCapacity,
+    depositAccessRestricted,
+    underlying,
+    totalAssets,
+    totalSupply,
+    decimals,
+    sharePrice,
+    hubLiquidBalance,
+    spokesDeployedBalance,
+    maxImmediateRedeemAssets,
+    issues
+  };
+}
+async function ensureAllowance(walletClient, publicClient, token, spender, amount) {
+  const account = walletClient.account;
+  const allowance = await publicClient.readContract({
+    address: getAddress(token),
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [account.address, getAddress(spender)]
+  });
+  if (allowance < amount) {
+    const hash = await walletClient.writeContract({
+      address: getAddress(token),
+      abi: ERC20_ABI,
+      functionName: "approve",
+      args: [getAddress(spender), amount],
+      account,
+      chain: walletClient.chain
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+  }
+}
+async function quoteLzFee(publicClient, vault, extraOptions = "0x") {
+  return publicClient.readContract({
+    address: getAddress(vault),
+    abi: BRIDGE_ABI,
+    functionName: "quoteAccountingFee",
+    args: [extraOptions]
+  });
+}
+async function isAsyncMode(publicClient, vault) {
+  const v = getAddress(vault);
+  const isHub = await publicClient.readContract({
+    address: v,
+    abi: CONFIG_ABI,
+    functionName: "isHub"
+  });
+  if (!isHub) return false;
+  const oraclesEnabled = await publicClient.readContract({
+    address: v,
+    abi: BRIDGE_ABI,
+    functionName: "oraclesCrossChainAccounting"
+  });
+  return !oraclesEnabled;
+}
+async function getAsyncRequestStatus(publicClient, vault, guid) {
+  const info = await publicClient.readContract({
+    address: getAddress(vault),
+    abi: BRIDGE_ABI,
+    functionName: "getRequestInfo",
+    args: [guid]
+  });
+  const finalizationResult = await publicClient.readContract({
+    address: getAddress(vault),
+    abi: BRIDGE_ABI,
+    functionName: "getFinalizationResult",
+    args: [guid]
+  });
+  return {
+    fulfilled: info.fulfilled,
+    finalized: info.finalized,
+    result: finalizationResult
+  };
+}
+async function preflightAsync(publicClient, vault, escrow) {
+  const v = getAddress(vault);
+  const [ccManager, registeredEscrow, isHub, oraclesEnabled, isPaused] = await Promise.all([
+    publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "getCrossChainAccountingManager"
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "getEscrow"
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "isHub"
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: BRIDGE_ABI,
+      functionName: "oraclesCrossChainAccounting"
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "paused"
+    })
+  ]);
+  if (ccManager === zeroAddress) {
+    throw new Error(
+      `[MoreVaults] CCManager not configured on vault ${vault}. Call setCrossChainAccountingManager(ccManagerAddress) as vault owner first.`
+    );
+  }
+  if (registeredEscrow === 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(publicClient, vault, shares) {
+  const v = getAddress(vault);
+  const underlying = await publicClient.readContract({
+    address: v,
+    abi: VAULT_ABI,
+    functionName: "asset"
+  });
+  const [hubLiquid, assetsNeeded] = await Promise.all([
+    publicClient.readContract({
+      address: getAddress(underlying),
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [v]
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: VAULT_ABI,
+      functionName: "convertToAssets",
+      args: [shares]
+    })
+  ]);
+  if (hubLiquid < assetsNeeded) {
+    throw new Error(
+      `[MoreVaults] Insufficient hub liquidity for redeem.
+  Hub liquid balance : ${hubLiquid}
+  Estimated required : ${assetsNeeded}
+Submitting this redeem will waste the LayerZero fee \u2014 the request will be auto-refunded.
+Ask the vault curator to repatriate liquidity from spoke chains first.`
+    );
+  }
+}
+async function preflightSync(publicClient, vault) {
+  const v = getAddress(vault);
+  const [isPaused, depositCapResult] = await Promise.all([
+    publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "paused"
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "maxDeposit",
+      args: [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/viem/depositFlows.ts
+async function depositSimple(walletClient, publicClient, addresses, assets, receiver) {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  await preflightSync(publicClient, vault);
+  const underlying = await publicClient.readContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "asset"
+  });
+  await ensureAllowance(walletClient, publicClient, underlying, vault, assets);
+  const { result: shares } = await publicClient.simulateContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "deposit",
+    args: [assets, getAddress(receiver)],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "deposit",
+    args: [assets, getAddress(receiver)],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, shares };
+}
+async function depositMultiAsset(walletClient, publicClient, addresses, tokens, amounts, receiver, minShares) {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  for (let i = 0; i < tokens.length; i++) {
+    await ensureAllowance(walletClient, publicClient, tokens[i], vault, amounts[i]);
+  }
+  const { result: shares } = await publicClient.simulateContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "deposit",
+    args: [tokens, amounts, getAddress(receiver), minShares],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "deposit",
+    args: [tokens, amounts, getAddress(receiver), minShares],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, shares };
+}
+async function depositAsync(walletClient, publicClient, addresses, assets, receiver, lzFee, extraOptions = "0x") {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = getAddress(addresses.escrow);
+  await preflightAsync(publicClient, vault);
+  const underlying = await publicClient.readContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "asset"
+  });
+  await ensureAllowance(walletClient, publicClient, underlying, escrow, assets);
+  const actionCallData = encodeAbiParameters(
+    [{ type: "uint256", name: "assets" }, { type: "address", name: "receiver" }],
+    [assets, getAddress(receiver)]
+  );
+  const { result: guid } = await publicClient.simulateContract({
+    address: vault,
+    abi: BRIDGE_ABI,
+    functionName: "initVaultActionRequest",
+    args: [ActionType.DEPOSIT, actionCallData, 0n, extraOptions],
+    value: lzFee,
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: BRIDGE_ABI,
+    functionName: "initVaultActionRequest",
+    args: [ActionType.DEPOSIT, actionCallData, 0n, extraOptions],
+    value: lzFee,
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, guid };
+}
+async function mintAsync(walletClient, publicClient, addresses, shares, maxAssets, receiver, lzFee, extraOptions = "0x") {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = getAddress(addresses.escrow);
+  await preflightAsync(publicClient, vault);
+  const underlying = await publicClient.readContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "asset"
+  });
+  await ensureAllowance(walletClient, publicClient, underlying, escrow, maxAssets);
+  const actionCallData = encodeAbiParameters(
+    [{ type: "uint256", name: "shares" }, { type: "address", name: "receiver" }],
+    [shares, getAddress(receiver)]
+  );
+  const { result: guid } = await publicClient.simulateContract({
+    address: vault,
+    abi: BRIDGE_ABI,
+    functionName: "initVaultActionRequest",
+    args: [ActionType.MINT, actionCallData, maxAssets, extraOptions],
+    value: lzFee,
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: BRIDGE_ABI,
+    functionName: "initVaultActionRequest",
+    args: [ActionType.MINT, actionCallData, maxAssets, extraOptions],
+    value: lzFee,
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, guid };
+}
+async function smartDeposit(walletClient, publicClient, addresses, assets, receiver, extraOptions = "0x") {
+  const vault = getAddress(addresses.vault);
+  const status = await getVaultStatus(publicClient, 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(publicClient, vault, extraOptions);
+    return depositAsync(walletClient, publicClient, addresses, assets, receiver, lzFee, extraOptions);
+  }
+  return depositSimple(walletClient, publicClient, addresses, assets, receiver);
+}
+async function depositFromSpoke(walletClient, publicClient, spokeOFT, hubEid, spokeEid, amount, receiver, lzFee, minMsgValue = 0n, minSharesOut = 0n, minAmountLD, extraOptions = "0x") {
+  const account = walletClient.account;
+  const oft = getAddress(spokeOFT);
+  await ensureAllowance(walletClient, publicClient, oft, oft, amount);
+  const receiverBytes32 = pad(getAddress(receiver), { size: 32 });
+  const hopSendParam = {
+    dstEid: spokeEid,
+    to: receiverBytes32,
+    amountLD: 0n,
+    minAmountLD: minSharesOut,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const composeMsgBytes = encodeAbiParameters(
+    [
+      {
+        type: "tuple",
+        name: "hopSendParam",
+        components: [
+          { type: "uint32", name: "dstEid" },
+          { type: "bytes32", name: "to" },
+          { type: "uint256", name: "amountLD" },
+          { type: "uint256", name: "minAmountLD" },
+          { type: "bytes", name: "extraOptions" },
+          { type: "bytes", name: "composeMsg" },
+          { type: "bytes", name: "oftCmd" }
+        ]
+      },
+      { type: "uint256", name: "minMsgValue" }
+    ],
+    [hopSendParam, minMsgValue]
+  );
+  const sendParam = {
+    dstEid: hubEid,
+    to: receiverBytes32,
+    amountLD: amount,
+    minAmountLD: minAmountLD ?? amount,
+    extraOptions,
+    composeMsg: composeMsgBytes,
+    oftCmd: "0x"
+  };
+  const fee = {
+    nativeFee: lzFee,
+    lzTokenFee: 0n
+  };
+  const txHash = await walletClient.writeContract({
+    address: oft,
+    abi: OFT_ABI,
+    functionName: "send",
+    args: [sendParam, fee, account.address],
+    value: lzFee,
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash };
+}
+async function quoteDepositFromSpokeFee(publicClient, spokeOFT, hubEid, spokeEid, amount, receiver, minMsgValue = 0n, minSharesOut = 0n, minAmountLD, extraOptions = "0x") {
+  const oft = getAddress(spokeOFT);
+  const receiverBytes32 = pad(getAddress(receiver), { size: 32 });
+  const hopSendParam = {
+    dstEid: spokeEid,
+    to: receiverBytes32,
+    amountLD: 0n,
+    minAmountLD: minSharesOut,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const composeMsgBytes = encodeAbiParameters(
+    [
+      {
+        type: "tuple",
+        name: "hopSendParam",
+        components: [
+          { type: "uint32", name: "dstEid" },
+          { type: "bytes32", name: "to" },
+          { type: "uint256", name: "amountLD" },
+          { type: "uint256", name: "minAmountLD" },
+          { type: "bytes", name: "extraOptions" },
+          { type: "bytes", name: "composeMsg" },
+          { type: "bytes", name: "oftCmd" }
+        ]
+      },
+      { type: "uint256", name: "minMsgValue" }
+    ],
+    [hopSendParam, minMsgValue]
+  );
+  const sendParam = {
+    dstEid: hubEid,
+    to: receiverBytes32,
+    amountLD: amount,
+    minAmountLD: minAmountLD ?? amount,
+    extraOptions,
+    composeMsg: composeMsgBytes,
+    oftCmd: "0x"
+  };
+  const fee = await publicClient.readContract({
+    address: oft,
+    abi: OFT_ABI,
+    functionName: "quoteSend",
+    args: [sendParam, false]
+  });
+  return fee.nativeFee;
+}
+async function redeemShares(walletClient, publicClient, addresses, shares, receiver, owner) {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  const { result: assets } = await publicClient.simulateContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "redeem",
+    args: [shares, getAddress(receiver), getAddress(owner)],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "redeem",
+    args: [shares, getAddress(receiver), getAddress(owner)],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, assets };
+}
+async function withdrawAssets(walletClient, publicClient, addresses, assets, receiver, owner) {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  const { result: sharesBurned } = await publicClient.simulateContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "withdraw",
+    args: [assets, getAddress(receiver), getAddress(owner)],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "withdraw",
+    args: [assets, getAddress(receiver), getAddress(owner)],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, assets };
+}
+async function requestRedeem(walletClient, publicClient, addresses, shares, owner) {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  await publicClient.simulateContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "requestRedeem",
+    args: [shares, getAddress(owner)],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "requestRedeem",
+    args: [shares, getAddress(owner)],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash };
+}
+async function getWithdrawalRequest(publicClient, vault, owner) {
+  const [shares, timelockEndsAt] = await publicClient.readContract({
+    address: getAddress(vault),
+    abi: VAULT_ABI,
+    functionName: "getWithdrawalRequest",
+    args: [getAddress(owner)]
+  });
+  if (shares === 0n) return null;
+  return { shares, timelockEndsAt };
+}
+async function redeemAsync(walletClient, publicClient, addresses, shares, receiver, owner, lzFee, extraOptions = "0x") {
+  const account = walletClient.account;
+  const vault = getAddress(addresses.vault);
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = getAddress(addresses.escrow);
+  await preflightAsync(publicClient, vault);
+  await preflightRedeemLiquidity(publicClient, vault, shares);
+  await ensureAllowance(walletClient, publicClient, vault, escrow, shares);
+  const actionCallData = encodeAbiParameters(
+    [{ type: "uint256", name: "shares" }, { type: "address", name: "receiver" }, { type: "address", name: "owner" }],
+    [shares, getAddress(receiver), getAddress(owner)]
+  );
+  const { result: guid } = await publicClient.simulateContract({
+    address: vault,
+    abi: BRIDGE_ABI,
+    functionName: "initVaultActionRequest",
+    args: [ActionType.REDEEM, actionCallData, 0n, extraOptions],
+    value: lzFee,
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: BRIDGE_ABI,
+    functionName: "initVaultActionRequest",
+    args: [ActionType.REDEEM, actionCallData, 0n, extraOptions],
+    value: lzFee,
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, guid };
+}
+async function bridgeSharesToHub(walletClient, publicClient, shareOFT, hubChainEid, shares, receiver, lzFee) {
+  const account = walletClient.account;
+  const oft = getAddress(shareOFT);
+  await ensureAllowance(walletClient, publicClient, oft, oft, shares);
+  const toBytes32 = pad(getAddress(receiver), { size: 32 });
+  const sendParam = {
+    dstEid: hubChainEid,
+    to: toBytes32,
+    amountLD: shares,
+    minAmountLD: shares,
+    // shares should bridge 1:1
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const fee = {
+    nativeFee: lzFee,
+    lzTokenFee: 0n
+  };
+  const txHash = await walletClient.writeContract({
+    address: oft,
+    abi: OFT_ABI,
+    functionName: "send",
+    args: [sendParam, fee, account.address],
+    value: lzFee,
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash };
+}
+async function getUserPosition(publicClient, vault, user) {
+  const v = getAddress(vault);
+  const u = getAddress(user);
+  const [sharesResult, decimalsResult, withdrawalRequestResult] = await publicClient.multicall({
+    contracts: [
+      { address: v, abi: VAULT_ABI, functionName: "balanceOf", args: [u] },
+      { address: v, abi: METADATA_ABI, functionName: "decimals" },
+      { address: v, abi: VAULT_ABI, functionName: "getWithdrawalRequest", args: [u] }
+    ],
+    allowFailure: false
+  });
+  const block = await publicClient.getBlock();
+  const shares = sharesResult;
+  const decimals = decimalsResult;
+  const withdrawalRequest = withdrawalRequestResult;
+  const [withdrawShares, timelockEndsAt] = withdrawalRequest;
+  const oneShare = 10n ** BigInt(decimals);
+  const [estimatedAssets, sharePrice] = await Promise.all([
+    shares === 0n ? Promise.resolve(0n) : publicClient.readContract({ address: v, abi: VAULT_ABI, functionName: "convertToAssets", args: [shares] }),
+    publicClient.readContract({ address: v, abi: VAULT_ABI, functionName: "convertToAssets", args: [oneShare] })
+  ]);
+  const currentTimestamp = block.timestamp;
+  const pendingWithdrawal = withdrawShares === 0n ? null : {
+    shares: withdrawShares,
+    timelockEndsAt,
+    canRedeemNow: timelockEndsAt === 0n || currentTimestamp >= timelockEndsAt
+  };
+  return {
+    shares,
+    estimatedAssets,
+    sharePrice,
+    decimals,
+    pendingWithdrawal
+  };
+}
+async function previewDeposit(publicClient, vault, assets) {
+  return publicClient.readContract({
+    address: getAddress(vault),
+    abi: VAULT_ABI,
+    functionName: "previewDeposit",
+    args: [assets]
+  });
+}
+async function previewRedeem(publicClient, vault, shares) {
+  return publicClient.readContract({
+    address: getAddress(vault),
+    abi: VAULT_ABI,
+    functionName: "previewRedeem",
+    args: [shares]
+  });
+}
+async function canDeposit(publicClient, vault, user) {
+  const v = getAddress(vault);
+  const isPaused = await publicClient.readContract({
+    address: v,
+    abi: CONFIG_ABI,
+    functionName: "paused"
+  });
+  if (isPaused) {
+    return { allowed: false, reason: "paused" };
+  }
+  let maxDepositAmount;
+  try {
+    maxDepositAmount = await publicClient.readContract({
+      address: v,
+      abi: CONFIG_ABI,
+      functionName: "maxDeposit",
+      args: [getAddress(user)]
+    });
+  } catch {
+    return { allowed: false, reason: "not-whitelisted" };
+  }
+  if (maxDepositAmount === 0n) {
+    return { allowed: false, reason: "capacity-full" };
+  }
+  return { allowed: true, reason: "ok" };
+}
+async function getVaultMetadata(publicClient, vault) {
+  const v = getAddress(vault);
+  const b1 = await publicClient.multicall({
+    contracts: [
+      { address: v, abi: METADATA_ABI, functionName: "name" },
+      { address: v, abi: METADATA_ABI, functionName: "symbol" },
+      { address: v, abi: METADATA_ABI, functionName: "decimals" },
+      { address: v, abi: VAULT_ABI, functionName: "asset" }
+    ],
+    allowFailure: false
+  });
+  const [name, symbol, decimals, underlying] = b1;
+  const underlyingAddr = getAddress(underlying);
+  const b2 = await publicClient.multicall({
+    contracts: [
+      { address: underlyingAddr, abi: METADATA_ABI, functionName: "symbol" },
+      { address: underlyingAddr, abi: METADATA_ABI, functionName: "decimals" }
+    ],
+    allowFailure: false
+  });
+  const [underlyingSymbol, underlyingDecimals] = b2;
+  return {
+    name,
+    symbol,
+    decimals,
+    underlying: underlyingAddr,
+    underlyingSymbol,
+    underlyingDecimals
+  };
+}
+async function getAsyncRequestStatusLabel(publicClient, vault, guid) {
+  const v = getAddress(vault);
+  const [info, finalizationResult] = await Promise.all([
+    publicClient.readContract({
+      address: v,
+      abi: BRIDGE_ABI,
+      functionName: "getRequestInfo",
+      args: [guid]
+    }),
+    publicClient.readContract({
+      address: v,
+      abi: BRIDGE_ABI,
+      functionName: "getFinalizationResult",
+      args: [guid]
+    })
+  ]);
+  if (info.refunded) {
+    return {
+      status: "refunded",
+      label: "Request refunded \u2014 tokens returned to initiator",
+      result: 0n
+    };
+  }
+  if (info.finalized) {
+    return {
+      status: "completed",
+      label: "Completed",
+      result: finalizationResult
+    };
+  }
+  if (info.fulfilled) {
+    return {
+      status: "ready-to-execute",
+      label: "Oracle responded \u2014 ready to execute",
+      result: 0n
+    };
+  }
+  return {
+    status: "pending",
+    label: "Waiting for cross-chain oracle response...",
+    result: 0n
+  };
+}
+async function getUserBalances(publicClient, vault, user) {
+  const v = getAddress(vault);
+  const u = getAddress(user);
+  const [shareBalance, , underlying] = await publicClient.multicall({
+    contracts: [
+      { address: v, abi: VAULT_ABI, functionName: "balanceOf", args: [u] },
+      { address: v, abi: METADATA_ABI, functionName: "decimals" },
+      { address: v, abi: VAULT_ABI, functionName: "asset" }
+    ],
+    allowFailure: false
+  });
+  const underlyingAddr = getAddress(underlying);
+  const [underlyingBalance, estimatedAssets] = await Promise.all([
+    publicClient.readContract({
+      address: underlyingAddr,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [u]
+    }),
+    shareBalance === 0n ? Promise.resolve(0n) : publicClient.readContract({
+      address: v,
+      abi: VAULT_ABI,
+      functionName: "convertToAssets",
+      args: [shareBalance]
+    })
+  ]);
+  return {
+    shareBalance,
+    underlyingBalance,
+    estimatedAssets
+  };
+}
+async function getMaxWithdrawable(publicClient, vault, user) {
+  const v = getAddress(vault);
+  const u = getAddress(user);
+  const [isHub, oraclesEnabled, userShares, underlying] = await publicClient.multicall({
+    contracts: [
+      { address: v, abi: CONFIG_ABI, functionName: "isHub" },
+      { address: v, abi: BRIDGE_ABI, functionName: "oraclesCrossChainAccounting" },
+      { address: v, abi: VAULT_ABI, functionName: "balanceOf", args: [u] },
+      { address: v, abi: VAULT_ABI, functionName: "asset" }
+    ],
+    allowFailure: false
+  });
+  if (userShares === 0n) {
+    return { shares: 0n, assets: 0n };
+  }
+  const underlyingAddr = getAddress(underlying);
+  const [estimatedAssets, hubLiquidBalance] = await Promise.all([
+    publicClient.readContract({
+      address: v,
+      abi: VAULT_ABI,
+      functionName: "convertToAssets",
+      args: [userShares]
+    }),
+    publicClient.readContract({
+      address: underlyingAddr,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [v]
+    })
+  ]);
+  let maxAssets;
+  if (isHub && !oraclesEnabled) {
+    maxAssets = estimatedAssets < hubLiquidBalance ? estimatedAssets : hubLiquidBalance;
+  } else {
+    maxAssets = estimatedAssets;
+  }
+  let maxShares;
+  if (maxAssets < estimatedAssets) {
+    maxShares = await publicClient.readContract({
+      address: v,
+      abi: VAULT_ABI,
+      functionName: "convertToShares",
+      args: [maxAssets]
+    });
+  } else {
+    maxShares = userShares;
+  }
+  return {
+    shares: maxShares,
+    assets: maxAssets
+  };
+}
+async function getVaultSummary(publicClient, vault) {
+  const [status, metadata] = await Promise.all([
+    getVaultStatus(publicClient, vault),
+    getVaultMetadata(publicClient, vault)
+  ]);
+  return { ...status, ...metadata };
+}
+
+export { ActionType, BRIDGE_ABI, CCManagerNotConfiguredError, CONFIG_ABI, CapacityFullError, ERC20_ABI, EscrowNotConfiguredError, InsufficientLiquidityError, METADATA_ABI, MissingEscrowAddressError, MoreVaultsError, NotHubVaultError, NotWhitelistedError, OFT_ABI, VAULT_ABI, VaultPausedError, bridgeSharesToHub, canDeposit, depositAsync, depositSimple as depositCrossChainOracleOn, depositFromSpoke, depositFromSpoke as depositFromSpokeAsync, depositMultiAsset, depositSimple, ensureAllowance, getAsyncRequestStatus, getAsyncRequestStatusLabel, getMaxWithdrawable, getUserBalances, getUserPosition, getVaultMetadata, getVaultStatus, getVaultSummary, getWithdrawalRequest, isAsyncMode, mintAsync, preflightAsync, preflightRedeemLiquidity, preflightSync, previewDeposit, previewRedeem, quoteDepositFromSpokeFee, quoteLzFee, redeemAsync, redeemShares, requestRedeem, smartDeposit, withdrawAssets };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map