@oydual31/more-vaults-sdk 0.1.2 → 0.1.3

package/dist/react/index.cjs

@@ -0,0 +1,1108 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var wagmi = require('wagmi');
+var viem = require('viem');
+var react = require('react');
+
+// src/react/useVaultStatus.ts
+
+// 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" }
+];
+
+// src/viem/types.ts
+var ActionType = {
+  DEPOSIT: 0,
+  REDEEM: 3};
+
+// src/viem/errors.ts
+var MoreVaultsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MoreVaultsError";
+  }
+};
+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";
+  }
+};
+var WrongChainError = class extends MoreVaultsError {
+  constructor(currentChainId, expectedChainId) {
+    super(
+      `Wrong network: wallet is on chain ${currentChainId}, but the vault hub requires chain ${expectedChainId}. Switch networks before proceeding.`
+    );
+    this.name = "WrongChainError";
+  }
+};
+async function getVaultStatus(publicClient, vault) {
+  const v = viem.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: [viem.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 : viem.zeroAddress;
+  const escrow = b1[4].status === "success" ? b1[4].result : viem.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 : viem.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: viem.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 === viem.zeroAddress) {
+    issues.push(
+      "CCManager not configured \u2014 async flows will revert. Call setCrossChainAccountingManager(address) as vault owner."
+    );
+  }
+  if (isHub && !oraclesEnabled && escrow === viem.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: viem.getAddress(token),
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [account.address, viem.getAddress(spender)]
+  });
+  if (allowance < amount) {
+    const hash = await walletClient.writeContract({
+      address: viem.getAddress(token),
+      abi: ERC20_ABI,
+      functionName: "approve",
+      args: [viem.getAddress(spender), amount],
+      account,
+      chain: walletClient.chain
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+  }
+}
+async function quoteLzFee(publicClient, vault, extraOptions = "0x") {
+  return publicClient.readContract({
+    address: viem.getAddress(vault),
+    abi: BRIDGE_ABI,
+    functionName: "quoteAccountingFee",
+    args: [extraOptions]
+  });
+}
+async function preflightAsync(publicClient, vault, escrow) {
+  const v = viem.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 === viem.zeroAddress) {
+    throw new Error(
+      `[MoreVaults] CCManager not configured on vault ${vault}. Call setCrossChainAccountingManager(ccManagerAddress) as vault owner first.`
+    );
+  }
+  if (registeredEscrow === viem.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 = viem.getAddress(vault);
+  const underlying = await publicClient.readContract({
+    address: v,
+    abi: VAULT_ABI,
+    functionName: "asset"
+  });
+  const [hubLiquid, assetsNeeded] = await Promise.all([
+    publicClient.readContract({
+      address: viem.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 = viem.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: [viem.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/chainValidation.ts
+function validateWalletChain(walletClient, hubChainId) {
+  if (!hubChainId) return;
+  const current = walletClient.chain?.id;
+  if (current !== void 0 && current !== hubChainId) {
+    throw new WrongChainError(current, hubChainId);
+  }
+}
+
+// src/viem/depositFlows.ts
+async function depositSimple(walletClient, publicClient, addresses, assets, receiver) {
+  const account = walletClient.account;
+  const vault = viem.getAddress(addresses.vault);
+  validateWalletChain(walletClient, addresses.hubChainId);
+  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, viem.getAddress(receiver)],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "deposit",
+    args: [assets, viem.getAddress(receiver)],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, shares };
+}
+async function depositAsync(walletClient, publicClient, addresses, assets, receiver, lzFee, extraOptions = "0x") {
+  const account = walletClient.account;
+  const vault = viem.getAddress(addresses.vault);
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = viem.getAddress(addresses.escrow);
+  validateWalletChain(walletClient, addresses.hubChainId);
+  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 = viem.encodeAbiParameters(
+    [{ type: "uint256", name: "assets" }, { type: "address", name: "receiver" }],
+    [assets, viem.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 redeemShares(walletClient, publicClient, addresses, shares, receiver, owner) {
+  const account = walletClient.account;
+  const vault = viem.getAddress(addresses.vault);
+  validateWalletChain(walletClient, addresses.hubChainId);
+  const { result: assets } = await publicClient.simulateContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "redeem",
+    args: [shares, viem.getAddress(receiver), viem.getAddress(owner)],
+    account: account.address
+  });
+  const txHash = await walletClient.writeContract({
+    address: vault,
+    abi: VAULT_ABI,
+    functionName: "redeem",
+    args: [shares, viem.getAddress(receiver), viem.getAddress(owner)],
+    account,
+    chain: walletClient.chain
+  });
+  return { txHash, assets };
+}
+async function redeemAsync(walletClient, publicClient, addresses, shares, receiver, owner, lzFee, extraOptions = "0x") {
+  const account = walletClient.account;
+  const vault = viem.getAddress(addresses.vault);
+  if (!addresses.escrow) throw new MissingEscrowAddressError();
+  const escrow = viem.getAddress(addresses.escrow);
+  validateWalletChain(walletClient, addresses.hubChainId);
+  await preflightAsync(publicClient, vault);
+  await preflightRedeemLiquidity(publicClient, vault, shares);
+  await ensureAllowance(walletClient, publicClient, vault, escrow, shares);
+  const actionCallData = viem.encodeAbiParameters(
+    [{ type: "uint256", name: "shares" }, { type: "address", name: "receiver" }, { type: "address", name: "owner" }],
+    [shares, viem.getAddress(receiver), viem.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 getUserPosition(publicClient, vault, user) {
+  const v = viem.getAddress(vault);
+  const u = viem.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 getVaultMetadata(publicClient, vault) {
+  const v = viem.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 = viem.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 = viem.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
+  };
+}
+
+// src/viem/wagmiCompat.ts
+function asSdkClient(client) {
+  if (!client) throw new Error("[MoreVaults] No public client available. Make sure wagmi is configured correctly.");
+  return client;
+}
+
+// src/react/useVaultStatus.ts
+function useVaultStatus(vault, chainId, options) {
+  const publicClient = wagmi.usePublicClient({ chainId });
+  return reactQuery.useQuery({
+    queryKey: ["vaultStatus", vault, chainId],
+    queryFn: () => getVaultStatus(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useVaultMetadata(vault, chainId) {
+  const publicClient = wagmi.usePublicClient({ chainId });
+  return reactQuery.useQuery({
+    queryKey: ["vaultMetadata", vault, chainId],
+    queryFn: () => getVaultMetadata(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    // Metadata (name, symbol, underlying) changes very rarely — 5 min stale time
+    staleTime: 5 * 6e4,
+    refetchInterval: 5 * 6e4
+  });
+}
+function useUserPosition(vault, user, chainId) {
+  const publicClient = wagmi.usePublicClient({ chainId });
+  return reactQuery.useQuery({
+    queryKey: ["userPosition", vault, user, chainId],
+    queryFn: () => getUserPosition(asSdkClient(publicClient), vault, user),
+    enabled: !!vault && !!user && !!publicClient,
+    refetchInterval: 15e3,
+    staleTime: 1e4
+  });
+}
+function useLzFee(vault, chainId) {
+  const publicClient = wagmi.usePublicClient({ chainId });
+  const query = reactQuery.useQuery({
+    queryKey: ["lzFee", vault, chainId],
+    queryFn: () => quoteLzFee(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: 6e4,
+    staleTime: 3e4
+  });
+  return {
+    ...query,
+    fee: query.data,
+    feeWithBuffer: query.data ? query.data * 101n / 100n : void 0
+  };
+}
+function useAsyncRequestStatus(vault, guid, chainId) {
+  const publicClient = wagmi.usePublicClient({ chainId });
+  return reactQuery.useQuery({
+    queryKey: ["asyncRequestStatus", vault, guid, chainId],
+    queryFn: () => getAsyncRequestStatusLabel(asSdkClient(publicClient), vault, guid),
+    enabled: !!vault && !!guid && !!publicClient,
+    refetchInterval: (query) => {
+      const status = query.state.data?.status;
+      if (status === "completed" || status === "refunded") return false;
+      return 1e4;
+    }
+  });
+}
+function useOmniDeposit(vault, hubChainId) {
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: hubChainId });
+  const publicClient = wagmi.usePublicClient({ chainId: hubChainId });
+  const currentChainId = wagmi.useChainId();
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [txHash, setTxHash] = react.useState();
+  const [guid, setGuid] = react.useState();
+  const [error, setError] = react.useState();
+  const { feeWithBuffer } = useLzFee(vault, hubChainId);
+  const { data: requestStatus } = useAsyncRequestStatus(vault, guid, hubChainId);
+  const wrongChain = currentChainId !== hubChainId;
+  const deposit = react.useCallback(
+    async (amountInWei, receiver) => {
+      if (!vault || !walletClient || !publicClient || !feeWithBuffer) return;
+      setIsLoading(true);
+      setError(void 0);
+      try {
+        const pc = asSdkClient(publicClient);
+        const status = await getVaultStatus(pc, vault);
+        const result = await depositAsync(
+          walletClient,
+          pc,
+          { vault, escrow: status.escrow, hubChainId },
+          amountInWei,
+          receiver,
+          feeWithBuffer
+        );
+        setTxHash(result.txHash);
+        setGuid(result.guid);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [vault, walletClient, publicClient, feeWithBuffer, hubChainId]
+  );
+  const reset = react.useCallback(() => {
+    setTxHash(void 0);
+    setGuid(void 0);
+    setError(void 0);
+    setIsLoading(false);
+  }, []);
+  return { deposit, isLoading, txHash, guid, requestStatus, wrongChain, error, reset };
+}
+function useOmniRedeem(vault, hubChainId) {
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: hubChainId });
+  const publicClient = wagmi.usePublicClient({ chainId: hubChainId });
+  const currentChainId = wagmi.useChainId();
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [txHash, setTxHash] = react.useState();
+  const [guid, setGuid] = react.useState();
+  const [error, setError] = react.useState();
+  const { feeWithBuffer } = useLzFee(vault, hubChainId);
+  const { data: requestStatus } = useAsyncRequestStatus(vault, guid, hubChainId);
+  const wrongChain = currentChainId !== hubChainId;
+  const redeem = react.useCallback(
+    async (sharesInWei, receiver, owner) => {
+      if (!vault || !walletClient || !publicClient || !feeWithBuffer) return;
+      setIsLoading(true);
+      setError(void 0);
+      try {
+        const pc = asSdkClient(publicClient);
+        const status = await getVaultStatus(pc, vault);
+        const result = await redeemAsync(
+          walletClient,
+          pc,
+          { vault, escrow: status.escrow, hubChainId },
+          sharesInWei,
+          receiver,
+          owner,
+          feeWithBuffer
+        );
+        setTxHash(result.txHash);
+        setGuid(result.guid);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [vault, walletClient, publicClient, feeWithBuffer, hubChainId]
+  );
+  const reset = react.useCallback(() => {
+    setTxHash(void 0);
+    setGuid(void 0);
+    setError(void 0);
+    setIsLoading(false);
+  }, []);
+  return { redeem, isLoading, txHash, guid, requestStatus, wrongChain, error, reset };
+}
+function useDepositSimple(vault, chainId) {
+  const { data: walletClient } = wagmi.useWalletClient({ chainId });
+  const publicClient = wagmi.usePublicClient({ chainId });
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [result, setResult] = react.useState();
+  const [error, setError] = react.useState();
+  const deposit = react.useCallback(
+    async (amountInWei, receiver) => {
+      if (!vault || !walletClient || !publicClient) return;
+      setIsLoading(true);
+      setError(void 0);
+      try {
+        const res = await depositSimple(
+          walletClient,
+          asSdkClient(publicClient),
+          { vault, hubChainId: chainId },
+          amountInWei,
+          receiver
+        );
+        setResult(res);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [vault, walletClient, publicClient, chainId]
+  );
+  const reset = react.useCallback(() => {
+    setResult(void 0);
+    setError(void 0);
+    setIsLoading(false);
+  }, []);
+  return {
+    deposit,
+    isLoading,
+    txHash: result?.txHash,
+    shares: result?.shares,
+    error,
+    reset
+  };
+}
+function useRedeemShares(vault, chainId) {
+  const { data: walletClient } = wagmi.useWalletClient({ chainId });
+  const publicClient = wagmi.usePublicClient({ chainId });
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [result, setResult] = react.useState();
+  const [error, setError] = react.useState();
+  const redeem = react.useCallback(
+    async (sharesInWei, receiver, owner) => {
+      if (!vault || !walletClient || !publicClient) return;
+      setIsLoading(true);
+      setError(void 0);
+      try {
+        const res = await redeemShares(
+          walletClient,
+          asSdkClient(publicClient),
+          { vault, hubChainId: chainId },
+          sharesInWei,
+          receiver,
+          owner
+        );
+        setResult(res);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [vault, walletClient, publicClient, chainId]
+  );
+  const reset = react.useCallback(() => {
+    setResult(void 0);
+    setError(void 0);
+    setIsLoading(false);
+  }, []);
+  return {
+    redeem,
+    isLoading,
+    txHash: result?.txHash,
+    assets: result?.assets,
+    error,
+    reset
+  };
+}
+
+// src/react/useSmartDeposit.ts
+function useSmartDeposit(vault, hubChainId) {
+  const { data: status } = useVaultStatus(vault, hubChainId);
+  const omni = useOmniDeposit(vault, hubChainId);
+  const simple = useDepositSimple(vault, hubChainId);
+  const isAsync = status?.mode === "cross-chain-async";
+  const deposit = isAsync ? omni.deposit : simple.deposit;
+  return {
+    deposit,
+    isLoading: isAsync ? omni.isLoading : simple.isLoading,
+    txHash: isAsync ? omni.txHash : simple.txHash,
+    shares: isAsync ? void 0 : simple.shares,
+    guid: isAsync ? omni.guid : void 0,
+    requestStatus: isAsync ? omni.requestStatus : void 0,
+    wrongChain: isAsync ? omni.wrongChain : false,
+    vaultMode: status?.mode,
+    error: isAsync ? omni.error : simple.error,
+    reset: isAsync ? omni.reset : simple.reset
+  };
+}
+
+exports.useAsyncRequestStatus = useAsyncRequestStatus;
+exports.useDepositSimple = useDepositSimple;
+exports.useLzFee = useLzFee;
+exports.useOmniDeposit = useOmniDeposit;
+exports.useOmniRedeem = useOmniRedeem;
+exports.useRedeemShares = useRedeemShares;
+exports.useSmartDeposit = useSmartDeposit;
+exports.useUserPosition = useUserPosition;
+exports.useVaultMetadata = useVaultMetadata;
+exports.useVaultStatus = useVaultStatus;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map