@oydual31/more-vaults-sdk 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oydual31/more-vaults-sdk",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "TypeScript SDK for MoreVaults protocol — viem/wagmi and ethers.js",
   "type": "module",
   "exports": {

package/src/ethers/chains.ts

@@ -37,3 +37,22 @@ export const CHAIN_ID_TO_EID: Record<number, number> = {
   [CHAIN_IDS.base]: LZ_EIDS.base,
   [CHAIN_IDS.ethereum]: LZ_EIDS.ethereum,
 };
+
+/**
+ * Recommended timeouts for cross-chain operations (milliseconds).
+ * UIs should show a progress indicator and NOT timeout before these values.
+ */
+export const LZ_TIMEOUTS = {
+  /** Poll interval between balance/event checks */
+  POLL_INTERVAL: 30_000,
+  /** Standard OFT bridge (shares or assets, non-Stargate) */
+  OFT_BRIDGE: 900_000,          // 15 min
+  /** Stargate bridge (USDC, USDT, WETH) — slower due to pool mechanics */
+  STARGATE_BRIDGE: 1_800_000,   // 30 min
+  /** LZ Read callback (async vault actions) */
+  LZ_READ_CALLBACK: 900_000,   // 15 min
+  /** Compose delivery to hub (deposit from spoke) */
+  COMPOSE_DELIVERY: 2_700_000,  // 45 min
+  /** Full spoke→hub→spoke redeem (all steps combined) */
+  FULL_SPOKE_REDEEM: 3_600_000, // 60 min
+} as const;

package/src/ethers/index.ts

@@ -2,7 +2,7 @@
 // Barrel export for all flows and utilities.
 
 // --- Chain constants ---
-export { CHAIN_IDS, LZ_EIDS, EID_TO_CHAIN_ID, CHAIN_ID_TO_EID } from "./chains";
+export { CHAIN_IDS, LZ_EIDS, EID_TO_CHAIN_ID, CHAIN_ID_TO_EID, LZ_TIMEOUTS } from "./chains";
 
 // --- Types ---
 export type {
@@ -69,7 +69,9 @@ export {
   requestRedeem,
   getWithdrawalRequest,
   redeemAsync,
+  smartRedeem,
   bridgeSharesToHub,
+  bridgeAssetsToSpoke,
 } from "./redeemFlows";
 
 // --- Utilities ---

package/src/ethers/redeemFlows.ts

@@ -15,6 +15,7 @@ import type { ContractTransactionReceipt } from "ethers";
 import { preflightAsync, preflightRedeemLiquidity } from "./preflight";
 import { EscrowNotConfiguredError } from "./errors";
 import { validateWalletChain } from "./chainValidation";
+import { getVaultStatus, quoteLzFee } from "./utils";
 
 /**
  * Ensure `spender` has at least `amount` allowance from `owner`.
@@ -298,3 +299,111 @@ export async function bridgeSharesToHub(
 
   return { receipt };
 }
+
+// ---------------------------------------------------------------------------
+// Smart redeem -- auto-detect vault type
+// ---------------------------------------------------------------------------
+
+/**
+ * Smart redeem — auto-selects the correct flow based on vault configuration.
+ *
+ * Detects the vault mode and dispatches to:
+ * - Sync vaults (local / cross-chain-oracle): `redeemShares`
+ * - Async vaults (cross-chain, oracle OFF): `redeemAsync` (quotes LZ fee automatically)
+ *
+ * @param signer         Wallet signer with account attached
+ * @param addresses      Vault address set (`escrow` required for async vaults)
+ * @param shares         Amount of shares to redeem
+ * @param receiver       Address that will receive the underlying assets
+ * @param owner          Owner of the shares being redeemed
+ * @param extraOptions   Optional LZ extra options (only used for async vaults)
+ * @returns              RedeemResult or AsyncRequestResult depending on vault mode
+ */
+export async function smartRedeem(
+  signer: Signer,
+  addresses: VaultAddresses,
+  shares: bigint,
+  receiver: string,
+  owner: string,
+  extraOptions: string = "0x"
+): Promise<RedeemResult | AsyncRequestResult> {
+  const provider = signer.provider!;
+  const vault = addresses.vault;
+  const status = await getVaultStatus(provider, vault);
+
+  if (status.mode === "paused") {
+    throw new Error(`[MoreVaults] Vault ${vault} is paused. Cannot redeem.`);
+  }
+
+  if (status.recommendedDepositFlow === "depositAsync") {
+    // Async vault — use redeemAsync
+    const lzFee = await quoteLzFee(provider, vault, extraOptions);
+    return redeemAsync(signer, addresses, shares, receiver, owner, lzFee, extraOptions);
+  }
+
+  // Sync vault — direct redeem
+  return redeemShares(signer, addresses, shares, receiver, owner);
+}
+
+// ---------------------------------------------------------------------------
+// R7 -- Bridge assets from hub back to spoke
+// ---------------------------------------------------------------------------
+
+/**
+ * Bridge underlying assets from hub back to spoke chain via OFT.
+ *
+ * Step 3 of the full spoke redeem flow:
+ *   1. bridgeSharesToHub() — shares spoke->hub
+ *   2. smartRedeem() — redeem on hub
+ *   3. bridgeAssetsToSpoke() — assets hub->spoke
+ *
+ * @param signer         Wallet signer on the HUB chain
+ * @param assetOFT       OFT address for the underlying asset on hub
+ * @param spokeChainEid  LayerZero EID for the spoke (destination) chain
+ * @param amount         Amount of underlying assets to bridge
+ * @param receiver       Receiver address on the spoke chain
+ * @param lzFee          OFT send fee (quote via OFT.quoteSend)
+ * @param isStargate     Whether this is a Stargate OFT (uses TAXI mode)
+ * @returns              Transaction receipt
+ */
+export async function bridgeAssetsToSpoke(
+  signer: Signer,
+  assetOFT: string,
+  spokeChainEid: number,
+  amount: bigint,
+  receiver: string,
+  lzFee: bigint,
+  isStargate: boolean = true
+): Promise<{ receipt: ContractTransactionReceipt }> {
+  const oft = new Contract(assetOFT, OFT_ABI, signer);
+
+  // Read underlying token and approve
+  const token: string = await oft.token();
+  if (token.toLowerCase() !== assetOFT.toLowerCase()) {
+    await ensureAllowance(signer, token, assetOFT, amount);
+  } else {
+    await ensureAllowance(signer, assetOFT, assetOFT, amount);
+  }
+
+  const refundAddress = await signer.getAddress();
+  const toBytes32 = zeroPadValue(receiver, 32);
+
+  const sendParam = {
+    dstEid: spokeChainEid,
+    to: toBytes32,
+    amountLD: amount,
+    minAmountLD: amount * 99n / 100n, // 1% slippage for Stargate
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: isStargate ? "0x01" : "0x",
+  };
+
+  const msgFee = { nativeFee: lzFee, lzTokenFee: 0n };
+
+  const tx = await oft.send(sendParam, msgFee, refundAddress, {
+    value: lzFee,
+  });
+  const receipt = await tx.wait();
+
+  return { receipt };
+}

package/src/react/index.ts

@@ -30,6 +30,7 @@ export { useVaultDistribution } from './useVaultDistribution.js'
 
 // --- Smart (auto-routing) hooks ---
 export { useSmartDeposit } from './useSmartDeposit.js'
+export { useSmartRedeem } from './useSmartRedeem.js'
 
 // --- Inbound Routes ---
 export { useInboundRoutes, getRouteTokenDecimals } from './useInboundRoutes.js'

package/src/react/useSmartRedeem.ts

@@ -0,0 +1,70 @@
+import type { AsyncRequestStatusInfo } from '../viem/index.js'
+import { useVaultStatus } from './useVaultStatus.js'
+import { useOmniRedeem } from './useOmniRedeem.js'
+import { useRedeemShares } from './useRedeemShares.js'
+
+interface UseSmartRedeemReturn {
+  /**
+   * Execute redeem using the correct flow for this vault's mode.
+   * For async vaults: wraps redeemAsync (R5) — returns guid for tracking.
+   * For local/oracle vaults: wraps redeemShares (R1) — returns assets.
+   */
+  redeem: (sharesInWei: bigint, receiver: `0x${string}`, owner: `0x${string}`) => Promise<void>
+  isLoading: boolean
+  txHash: `0x${string}` | undefined
+  /** Assets received (available for R1 vaults after confirmation, undefined for R5). */
+  assets: bigint | undefined
+  /** GUID for cross-chain tracking (R5 vaults only). */
+  guid: `0x${string}` | undefined
+  /** Cross-chain request status (R5 vaults only). */
+  requestStatus: AsyncRequestStatusInfo | undefined
+  /** true when the wallet is connected to the wrong chain (R5 vaults only). */
+  wrongChain: boolean
+  /** Vault mode loaded from getVaultStatus. undefined while loading. */
+  vaultMode: 'local' | 'cross-chain-oracle' | 'cross-chain-async' | 'paused' | 'full' | undefined
+  error: Error | undefined
+  reset: () => void
+}
+
+/**
+ * Auto-selects the correct redeem flow based on vault mode.
+ * Best for frontends that support multiple vault types.
+ *
+ * Internally uses useVaultStatus to detect the mode, then delegates to:
+ * - useOmniRedeem (R5) for 'cross-chain-async' vaults
+ * - useRedeemShares (R1) for 'local' and 'cross-chain-oracle' vaults
+ *
+ * @example
+ * const { redeem, isLoading, guid, requestStatus, vaultMode } = useSmartRedeem('0xVAULT', 8453)
+ *
+ * if (vaultMode === 'paused') return <PausedBadge />
+ *
+ * await redeem(sharesInWei, userAddress, userAddress)
+ * // For async vaults: poll requestStatus until 'completed'
+ * // For sync vaults: txHash + assets are available immediately
+ */
+export function useSmartRedeem(
+  vault: `0x${string}` | undefined,
+  hubChainId: number,
+): UseSmartRedeemReturn {
+  const { data: status } = useVaultStatus(vault, hubChainId)
+  const omni = useOmniRedeem(vault, hubChainId)
+  const simple = useRedeemShares(vault, hubChainId)
+
+  const isAsync = status?.mode === 'cross-chain-async'
+
+  const redeem = isAsync ? omni.redeem : simple.redeem
+
+  return {
+    redeem,
+    isLoading: isAsync ? omni.isLoading : simple.isLoading,
+    txHash: isAsync ? omni.txHash : simple.txHash,
+    assets: isAsync ? undefined : simple.assets,
+    guid: isAsync ? omni.guid : undefined,
+    requestStatus: isAsync ? omni.requestStatus : undefined,
+    wrongChain: isAsync ? omni.wrongChain : false,
+    vaultMode: status?.mode,
+    error: isAsync ? omni.error : simple.error,
+    reset: isAsync ? omni.reset : simple.reset,
+  }
+}