@oydual31/more-vaults-sdk 0.1.0

package/dist/ethers/index.cjs

@@ -0,0 +1,973 @@
+'use strict';
+
+var ethers = require('ethers');
+
+// src/ethers/types.ts
+var ActionType = {
+  DEPOSIT: 0,
+  MINT: 1,
+  WITHDRAW: 2,
+  REDEEM: 3,
+  MULTI_ASSETS_DEPOSIT: 4,
+  ACCRUE_FEES: 5
+};
+
+// src/ethers/abis.ts
+var VAULT_ABI = [
+  // ERC4626 core
+  "function deposit(uint256 assets, address receiver) returns (uint256 shares)",
+  "function mint(uint256 shares, address receiver) returns (uint256 assets)",
+  "function withdraw(uint256 assets, address receiver, address owner) returns (uint256 shares)",
+  "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)",
+  // Multi-asset deposit
+  "function deposit(address[] tokens, uint256[] assets, address receiver, uint256 minAmountOut) payable returns (uint256 shares)",
+  // Withdrawal queue
+  "function requestRedeem(uint256 shares, address onBehalfOf)",
+  "function requestWithdraw(uint256 assets, address onBehalfOf)",
+  "function clearRequest()",
+  "function getWithdrawalRequest(address _owner) view returns (uint256 shares, uint256 timelockEndsAt)",
+  // Views
+  "function totalAssets() view returns (uint256)",
+  "function totalSupply() view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function asset() view returns (address)",
+  "function convertToShares(uint256 assets) view returns (uint256)",
+  "function convertToAssets(uint256 shares) view returns (uint256)",
+  "function previewDeposit(uint256 assets) view returns (uint256)",
+  "function previewRedeem(uint256 shares) view returns (uint256)",
+  "function paused() view returns (bool)",
+  // Events
+  "event Deposit(address indexed sender, address indexed owner, address[] tokens, uint256[] assets, uint256 shares)",
+  "event Transfer(address indexed from, address indexed to, uint256 value)",
+  "event WithdrawRequestCreated(address requester, uint256 sharesAmount, uint256 endsAt)",
+  "event WithdrawRequestFulfilled(address requester, address receiver, uint256 sharesAmount, uint256 assetAmount)"
+];
+var BRIDGE_ABI = [
+  "function initVaultActionRequest(uint8 actionType, bytes actionCallData, uint256 amountLimit, bytes extraOptions) payable returns (bytes32 guid)",
+  "function getRequestInfo(bytes32 guid) view returns (tuple(address initiator, uint64 timestamp, uint8 actionType, bytes actionCallData, bool fulfilled, bool finalized, bool refunded, uint256 totalAssets, uint256 finalizationResult, uint256 amountLimit))",
+  "function getFinalizationResult(bytes32 guid) view returns (uint256 result)",
+  "function oraclesCrossChainAccounting() view returns (bool)",
+  "function quoteAccountingFee(bytes extraOptions) view returns (uint256 nativeFee)",
+  "function accountingBridgeFacet() view returns (uint256 sum, bool isPositive)"
+];
+var CONFIG_ABI = [
+  "function getEscrow() view returns (address escrow)",
+  "function getCrossChainAccountingManager() view returns (address)",
+  "function isHub() view returns (bool)",
+  "function getWithdrawalQueueStatus() view returns (bool)",
+  "function getWithdrawalTimelock() view returns (uint64)",
+  "function getWithdrawalFee() view returns (uint96)",
+  "function getMaxWithdrawalDelay() view returns (uint32)",
+  "function getAvailableAssets() view returns (address[])",
+  "function getDepositableAssets() view returns (address[])",
+  "function depositCapacity() view returns (uint256)",
+  "function fee() view returns (uint96)",
+  "function feeRecipient() view returns (address)",
+  "function paused() view returns (bool)",
+  "function maxDeposit(address receiver) view returns (uint256)"
+];
+var METADATA_ABI = [
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)"
+];
+var ERC20_ABI = [
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)"
+];
+var OFT_ABI = [
+  "function send(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, tuple(uint256 nativeFee, uint256 lzTokenFee) fee, address refundAddress) payable returns (tuple(bytes32 guid, uint64 nonce, uint256 amountSentLD, uint256 amountReceivedLD) receipt, tuple(uint256 nativeFee, uint256 lzTokenFee) fee)",
+  "function quoteSend(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam, bool payInLzToken) view returns (tuple(uint256 nativeFee, uint256 lzTokenFee))"
+];
+
+// src/ethers/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 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 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 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(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.`
+    );
+  }
+}
+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)"
+];
+async function ensureAllowance(signer, provider, token, spender, amount) {
+  const owner = await signer.getAddress();
+  const erc20Read = new ethers.Contract(token, ERC20_ABI, provider);
+  const current = await erc20Read.allowance(owner, spender);
+  if (current < amount) {
+    const erc20Write = new ethers.Contract(token, ERC20_ABI, signer);
+    const tx = await erc20Write.approve(spender, amount);
+    await tx.wait();
+  }
+}
+async function quoteLzFee(provider, vault, extraOptions = "0x") {
+  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
+  const fee = await bridge.quoteAccountingFee(extraOptions);
+  return fee;
+}
+async function isAsyncMode(provider, vault) {
+  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) return false;
+  return !oraclesEnabled;
+}
+async function getAsyncRequestStatus(provider, vault, guid) {
+  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
+  const [info, finalizationResult] = await Promise.all([
+    bridge.getRequestInfo(guid),
+    bridge.getFinalizationResult(guid)
+  ]);
+  return {
+    fulfilled: info.fulfilled,
+    finalized: info.finalized,
+    result: finalizationResult
+  };
+}
+async function getVaultStatus(provider, vault) {
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+  const configIface = new ethers.Interface(CONFIG_ABI);
+  const bridgeIface = new ethers.Interface(BRIDGE_ABI);
+  const vaultIface = new ethers.Interface(VAULT_ABI);
+  const decimalsIface = new ethers.Interface(["function decimals() view returns (uint8)"]);
+  const b1Calls = [
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("isHub") },
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("paused") },
+    { target: vault, allowFailure: false, callData: bridgeIface.encodeFunctionData("oraclesCrossChainAccounting") },
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("getCrossChainAccountingManager") },
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("getEscrow") },
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("getWithdrawalQueueStatus") },
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("getWithdrawalTimelock") },
+    // allowFailure=true: maxDeposit reverts on whitelisted vaults with address(0)
+    { target: vault, allowFailure: true, callData: configIface.encodeFunctionData("maxDeposit", [ethers.ZeroAddress]) },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("asset") },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("totalAssets") },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("totalSupply") },
+    { target: vault, allowFailure: false, callData: decimalsIface.encodeFunctionData("decimals") }
+  ];
+  const b1 = await mc.aggregate3.staticCall(b1Calls);
+  const isHub = configIface.decodeFunctionResult("isHub", b1[0].returnData)[0];
+  const isPaused = configIface.decodeFunctionResult("paused", b1[1].returnData)[0];
+  const oraclesEnabled = bridgeIface.decodeFunctionResult("oraclesCrossChainAccounting", b1[2].returnData)[0];
+  const ccManager = configIface.decodeFunctionResult("getCrossChainAccountingManager", b1[3].returnData)[0];
+  const escrow = configIface.decodeFunctionResult("getEscrow", b1[4].returnData)[0];
+  const withdrawalQueueEnabled = configIface.decodeFunctionResult("getWithdrawalQueueStatus", b1[5].returnData)[0];
+  const withdrawalTimelockSeconds = configIface.decodeFunctionResult("getWithdrawalTimelock", b1[6].returnData)[0];
+  const maxDepositRaw = b1[7].success ? configIface.decodeFunctionResult("maxDeposit", b1[7].returnData)[0] : null;
+  const underlying = vaultIface.decodeFunctionResult("asset", b1[8].returnData)[0];
+  const totalAssets = vaultIface.decodeFunctionResult("totalAssets", b1[9].returnData)[0];
+  const totalSupply = vaultIface.decodeFunctionResult("totalSupply", b1[10].returnData)[0];
+  const decimalsRaw = decimalsIface.decodeFunctionResult("decimals", b1[11].returnData)[0];
+  const decimalsNum = Number(decimalsRaw);
+  const oneShare = 10n ** BigInt(decimalsNum);
+  const erc20Iface = new ethers.Interface(ERC20_ABI);
+  const b2Calls = [
+    { target: underlying, allowFailure: false, callData: erc20Iface.encodeFunctionData("balanceOf", [vault]) },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("convertToAssets", [oneShare]) }
+  ];
+  const b2 = await mc.aggregate3.staticCall(b2Calls);
+  const hubLiquidBalance = erc20Iface.decodeFunctionResult("balanceOf", b2[0].returnData)[0];
+  const sharePrice = vaultIface.decodeFunctionResult("convertToAssets", b2[1].returnData)[0];
+  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 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 (isHub && !oraclesEnabled && ccManager === ethers.ZeroAddress) {
+    issues.push(
+      "CCManager not configured \u2014 async flows will revert. Call setCrossChainAccountingManager(address) as vault owner."
+    );
+  }
+  if (isHub && !oraclesEnabled && escrow === ethers.ZeroAddress) {
+    issues.push(
+      "Escrow not configured in registry \u2014 async flows will revert. Set the escrow via the MoreVaultsRegistry."
+    );
+  }
+  if (depositAccessRestricted) {
+    issues.push("Deposit access is restricted (whitelist or other access control). Only approved addresses can deposit.");
+  }
+  const maxImmediateRedeemAssets = isHub && !oraclesEnabled ? hubLiquidBalance : totalAssets;
+  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 total = totalAssets;
+      issues.push(
+        `${spokesDeployedBalance} units (~${(Number(spokesDeployedBalance) / Number(total || 1n) * 100).toFixed(1)}% 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: decimalsNum,
+    sharePrice,
+    hubLiquidBalance,
+    spokesDeployedBalance,
+    maxImmediateRedeemAssets,
+    issues
+  };
+}
+
+// src/ethers/depositFlows.ts
+async function ensureAllowance2(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 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) {
+  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;
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = addresses.escrow;
+  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);
+  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;
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = addresses.escrow;
+  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);
+}
+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, 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 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: receiverBytes32,
+    amountLD: amount,
+    minAmountLD: minAmountLD ?? amount,
+    extraOptions,
+    composeMsg,
+    oftCmd: "0x"
+  };
+  const msgFee = { nativeFee: lzFee, lzTokenFee: 0n };
+  const tx = await oft.send(sendParam, msgFee, refundAddress, {
+    value: lzFee
+  });
+  const receipt = await tx.wait();
+  return { receipt };
+}
+var depositFromSpokeAsync = depositFromSpoke;
+async function quoteDepositFromSpokeFee(provider, spokeOFT, hubEid, spokeEid, amount, receiver, minMsgValue = 0n, minSharesOut = 0n, minAmountLD, extraOptions = "0x") {
+  const receiverBytes32 = ethers.zeroPadValue(receiver, 32);
+  const hopSendParam = {
+    dstEid: spokeEid,
+    to: receiverBytes32,
+    amountLD: 0n,
+    minAmountLD: minSharesOut,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const coder = ethers.AbiCoder.defaultAbiCoder();
+  const composeMsgBytes = coder.encode(
+    ["tuple(uint32,bytes32,uint256,uint256,bytes,bytes,bytes)", "uint256"],
+    [
+      [
+        hopSendParam.dstEid,
+        hopSendParam.to,
+        hopSendParam.amountLD,
+        hopSendParam.minAmountLD,
+        hopSendParam.extraOptions,
+        hopSendParam.composeMsg,
+        hopSendParam.oftCmd
+      ],
+      minMsgValue
+    ]
+  );
+  const sendParam = {
+    dstEid: hubEid,
+    to: receiverBytes32,
+    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 ensureAllowance4(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 redeemShares(signer, addresses, shares, receiver, owner) {
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const assets = await vault.redeem.staticCall(shares, receiver, owner);
+  const tx = await vault.redeem(shares, receiver, owner);
+  const receipt = await tx.wait();
+  return { receipt, assets };
+}
+async function withdrawAssets(signer, addresses, assets, receiver, owner) {
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const tx = await vault.withdraw(assets, receiver, owner);
+  const receipt = await tx.wait();
+  return { receipt, assets };
+}
+async function requestRedeem(signer, addresses, shares, owner) {
+  const vault = new ethers.Contract(addresses.vault, VAULT_ABI, signer);
+  const tx = await vault.requestRedeem(shares, owner);
+  const receipt = await tx.wait();
+  return { receipt };
+}
+async function getWithdrawalRequest(provider, vault, owner) {
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
+  const [shares, timelockEndsAt] = await vaultContract.getWithdrawalRequest(owner);
+  if (shares === 0n) {
+    return null;
+  }
+  return { shares, timelockEndsAt };
+}
+async function redeemAsync(signer, addresses, shares, receiver, owner, lzFee, extraOptions = "0x") {
+  const provider = signer.provider;
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = addresses.escrow;
+  await preflightAsync(provider, addresses.vault);
+  await preflightRedeemLiquidity(provider, addresses.vault, shares);
+  await ensureAllowance4(signer, addresses.vault, escrow, shares);
+  const coder = ethers.AbiCoder.defaultAbiCoder();
+  const actionCallData = coder.encode(
+    ["uint256", "address", "address"],
+    [shares, receiver, owner]
+  );
+  const bridge = new ethers.Contract(addresses.vault, BRIDGE_ABI, signer);
+  const guid = await bridge.initVaultActionRequest.staticCall(
+    ActionType.REDEEM,
+    actionCallData,
+    0,
+    extraOptions,
+    { value: lzFee }
+  );
+  const tx = await bridge.initVaultActionRequest(
+    ActionType.REDEEM,
+    actionCallData,
+    0,
+    // amountLimit MUST be 0 for redeems
+    extraOptions,
+    { value: lzFee }
+  );
+  const receipt = await tx.wait();
+  return { receipt, guid };
+}
+async function bridgeSharesToHub(signer, shareOFT, hubChainEid, shares, receiver, lzFee) {
+  await ensureAllowance4(signer, shareOFT, shareOFT, shares);
+  const oft = new ethers.Contract(shareOFT, OFT_ABI, signer);
+  const refundAddress = await signer.getAddress();
+  const toBytes32 = ethers.zeroPadValue(receiver, 32);
+  const sendParam = {
+    dstEid: hubChainEid,
+    to: toBytes32,
+    amountLD: shares,
+    minAmountLD: shares,
+    // no slippage on share bridging
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const msgFee = { nativeFee: lzFee, lzTokenFee: 0n };
+  const tx = await oft.send(sendParam, msgFee, refundAddress, {
+    value: lzFee
+  });
+  const receipt = await tx.wait();
+  return { receipt };
+}
+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)"
+];
+async function getUserPosition(provider, vault, user) {
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS2, MULTICALL3_ABI2, provider);
+  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),
+    provider.getBlock("latest")
+  ]);
+  const shares = vaultIface.decodeFunctionResult("balanceOf", b1Raw[0].returnData)[0];
+  const decimalsRaw = decimalsIface.decodeFunctionResult("decimals", b1Raw[1].returnData)[0];
+  const decimals = Number(decimalsRaw);
+  const withdrawalResult = vaultIface.decodeFunctionResult("getWithdrawalRequest", b1Raw[2].returnData);
+  const withdrawalRequest = [withdrawalResult[0], withdrawalResult[1]];
+  const [withdrawShares, timelockEndsAt] = withdrawalRequest;
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
+  const oneShare = 10n ** BigInt(decimals);
+  const [estimatedAssets, sharePrice] = await Promise.all([
+    shares === 0n ? Promise.resolve(0n) : vaultContract.convertToAssets(shares),
+    vaultContract.convertToAssets(oneShare)
+  ]);
+  const currentTimestamp = BigInt(block.timestamp);
+  const pendingWithdrawal = withdrawShares === 0n ? null : {
+    shares: withdrawShares,
+    timelockEndsAt,
+    canRedeemNow: timelockEndsAt === 0n || currentTimestamp >= timelockEndsAt
+  };
+  return {
+    shares,
+    estimatedAssets,
+    sharePrice,
+    decimals,
+    pendingWithdrawal
+  };
+}
+async function previewDeposit(provider, vault, assets) {
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
+  return vaultContract.previewDeposit(assets);
+}
+async function previewRedeem(provider, vault, shares) {
+  const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
+  return vaultContract.previewRedeem(shares);
+}
+async function canDeposit(provider, vault, user) {
+  const config = new ethers.Contract(vault, CONFIG_ABI, provider);
+  const isPaused = await config.paused();
+  if (isPaused) {
+    return { allowed: false, reason: "paused" };
+  }
+  let maxDepositAmount;
+  try {
+    maxDepositAmount = await config.maxDeposit(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(provider, vault) {
+  const MULTICALL3_ADDRESS3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+  const MULTICALL3_ABI3 = [
+    "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 metaIface = new ethers.Interface(METADATA_ABI);
+  const vaultIface = new ethers.Interface(VAULT_ABI);
+  const b1Calls = [
+    { target: vault, allowFailure: false, callData: metaIface.encodeFunctionData("name") },
+    { target: vault, allowFailure: false, callData: metaIface.encodeFunctionData("symbol") },
+    { target: vault, allowFailure: false, callData: metaIface.encodeFunctionData("decimals") },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("asset") }
+  ];
+  const b1 = await mc.aggregate3.staticCall(b1Calls);
+  const name = metaIface.decodeFunctionResult("name", b1[0].returnData)[0];
+  const symbol = metaIface.decodeFunctionResult("symbol", b1[1].returnData)[0];
+  const decimals = Number(metaIface.decodeFunctionResult("decimals", b1[2].returnData)[0]);
+  const underlying = vaultIface.decodeFunctionResult("asset", b1[3].returnData)[0];
+  const b2Calls = [
+    { target: underlying, allowFailure: false, callData: metaIface.encodeFunctionData("symbol") },
+    { target: underlying, allowFailure: false, callData: metaIface.encodeFunctionData("decimals") }
+  ];
+  const b2 = await mc.aggregate3.staticCall(b2Calls);
+  const underlyingSymbol = metaIface.decodeFunctionResult("symbol", b2[0].returnData)[0];
+  const underlyingDecimals = Number(metaIface.decodeFunctionResult("decimals", b2[1].returnData)[0]);
+  return {
+    name,
+    symbol,
+    decimals,
+    underlying,
+    underlyingSymbol,
+    underlyingDecimals
+  };
+}
+async function getAsyncRequestStatusLabel(provider, vault, guid) {
+  const bridge = new ethers.Contract(vault, BRIDGE_ABI, provider);
+  const [info, finalizationResult] = await Promise.all([
+    bridge.getRequestInfo(guid),
+    bridge.getFinalizationResult(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(provider, vault, user) {
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS2, MULTICALL3_ABI2, provider);
+  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("asset") }
+  ];
+  const b1 = await mc.aggregate3.staticCall(b1Calls);
+  const shareBalance = vaultIface.decodeFunctionResult("balanceOf", b1[0].returnData)[0];
+  const underlying = vaultIface.decodeFunctionResult("asset", b1[2].returnData)[0];
+  const [underlyingBalance, estimatedAssets] = await Promise.all([
+    new ethers.Contract(underlying, ERC20_ABI, provider).balanceOf(user),
+    shareBalance === 0n ? Promise.resolve(0n) : new ethers.Contract(vault, VAULT_ABI, provider).convertToAssets(shareBalance)
+  ]);
+  return {
+    shareBalance,
+    underlyingBalance,
+    estimatedAssets
+  };
+}
+async function getMaxWithdrawable(provider, vault, user) {
+  const mc = new ethers.Contract(MULTICALL3_ADDRESS2, MULTICALL3_ABI2, provider);
+  const configIface = new ethers.Interface(CONFIG_ABI);
+  const bridgeIface = new ethers.Interface(BRIDGE_ABI);
+  const vaultIface = new ethers.Interface(VAULT_ABI);
+  const erc20Iface = new ethers.Interface(ERC20_ABI);
+  const b1Calls = [
+    { target: vault, allowFailure: false, callData: configIface.encodeFunctionData("isHub") },
+    { target: vault, allowFailure: false, callData: bridgeIface.encodeFunctionData("oraclesCrossChainAccounting") },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("balanceOf", [user]) },
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("asset") }
+  ];
+  const b1 = await mc.aggregate3.staticCall(b1Calls);
+  const isHub = configIface.decodeFunctionResult("isHub", b1[0].returnData)[0];
+  const oraclesEnabled = bridgeIface.decodeFunctionResult("oraclesCrossChainAccounting", b1[1].returnData)[0];
+  const userShares = vaultIface.decodeFunctionResult("balanceOf", b1[2].returnData)[0];
+  const underlying = vaultIface.decodeFunctionResult("asset", b1[3].returnData)[0];
+  if (userShares === 0n) {
+    return { shares: 0n, assets: 0n };
+  }
+  const b2Calls = [
+    { target: vault, allowFailure: false, callData: vaultIface.encodeFunctionData("convertToAssets", [userShares]) },
+    { target: underlying, allowFailure: false, callData: erc20Iface.encodeFunctionData("balanceOf", [vault]) }
+  ];
+  const b2 = await mc.aggregate3.staticCall(b2Calls);
+  const estimatedAssets = vaultIface.decodeFunctionResult("convertToAssets", b2[0].returnData)[0];
+  const hubLiquidBalance = erc20Iface.decodeFunctionResult("balanceOf", b2[1].returnData)[0];
+  let maxAssets;
+  if (isHub && !oraclesEnabled) {
+    maxAssets = estimatedAssets < hubLiquidBalance ? estimatedAssets : hubLiquidBalance;
+  } else {
+    maxAssets = estimatedAssets;
+  }
+  let maxShares;
+  if (maxAssets < estimatedAssets) {
+    const vaultContract = new ethers.Contract(vault, VAULT_ABI, provider);
+    maxShares = await vaultContract.convertToShares(maxAssets);
+  } else {
+    maxShares = userShares;
+  }
+  return {
+    shares: maxShares,
+    assets: maxAssets
+  };
+}
+async function getVaultSummary(provider, vault) {
+  const [status, metadata] = await Promise.all([
+    getVaultStatus(provider, vault),
+    getVaultMetadata(provider, vault)
+  ]);
+  return { ...status, ...metadata };
+}
+
+exports.ActionType = ActionType;
+exports.BRIDGE_ABI = BRIDGE_ABI;
+exports.CCManagerNotConfiguredError = CCManagerNotConfiguredError;
+exports.CONFIG_ABI = CONFIG_ABI;
+exports.CapacityFullError = CapacityFullError;
+exports.ERC20_ABI = ERC20_ABI;
+exports.EscrowNotConfiguredError = EscrowNotConfiguredError;
+exports.InsufficientLiquidityError = InsufficientLiquidityError;
+exports.METADATA_ABI = METADATA_ABI;
+exports.MissingEscrowAddressError = MissingEscrowAddressError;
+exports.MoreVaultsError = MoreVaultsError;
+exports.NotHubVaultError = NotHubVaultError;
+exports.NotWhitelistedError = NotWhitelistedError;
+exports.OFT_ABI = OFT_ABI;
+exports.VAULT_ABI = VAULT_ABI;
+exports.VaultPausedError = VaultPausedError;
+exports.bridgeSharesToHub = bridgeSharesToHub;
+exports.canDeposit = canDeposit;
+exports.depositAsync = depositAsync;
+exports.depositCrossChainOracleOn = depositCrossChainOracleOn;
+exports.depositFromSpoke = depositFromSpoke;
+exports.depositFromSpokeAsync = depositFromSpokeAsync;
+exports.depositMultiAsset = depositMultiAsset;
+exports.depositSimple = depositSimple;
+exports.ensureAllowance = ensureAllowance;
+exports.getAsyncRequestStatus = getAsyncRequestStatus;
+exports.getAsyncRequestStatusLabel = getAsyncRequestStatusLabel;
+exports.getMaxWithdrawable = getMaxWithdrawable;
+exports.getUserBalances = getUserBalances;
+exports.getUserPosition = getUserPosition;
+exports.getVaultMetadata = getVaultMetadata;
+exports.getVaultStatus = getVaultStatus;
+exports.getVaultSummary = getVaultSummary;
+exports.getWithdrawalRequest = getWithdrawalRequest;
+exports.isAsyncMode = isAsyncMode;
+exports.mintAsync = mintAsync;
+exports.preflightAsync = preflightAsync;
+exports.preflightRedeemLiquidity = preflightRedeemLiquidity;
+exports.preflightSync = preflightSync;
+exports.previewDeposit = previewDeposit;
+exports.previewRedeem = previewRedeem;
+exports.quoteDepositFromSpokeFee = quoteDepositFromSpokeFee;
+exports.quoteLzFee = quoteLzFee;
+exports.redeemAsync = redeemAsync;
+exports.redeemShares = redeemShares;
+exports.requestRedeem = requestRedeem;
+exports.smartDeposit = smartDeposit;
+exports.withdrawAssets = withdrawAssets;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map