@oydual31/more-vaults-sdk 0.3.3 → 0.4.1

package/src/ethers/index.ts

@@ -15,6 +15,18 @@ export type {
   Signer,
   Provider,
   ContractTransactionReceipt,
+  // Curator types
+  SwapParams,
+  BatchSwapParams,
+  BridgeParams,
+  PendingAction,
+  SubmitActionsResult,
+  CuratorAction,
+  CuratorVaultStatus,
+  AssetInfo,
+  VaultAnalysis,
+  AssetBalance,
+  VaultAssetBreakdown,
 } from "./types";
 export { ActionType } from "./types";
 
@@ -27,6 +39,16 @@ export {
   OFT_ABI,
   METADATA_ABI,
   LZ_ENDPOINT_ABI,
+  // Curator ABIs
+  MULTICALL_ABI,
+  DEX_ABI,
+  BRIDGE_FACET_ABI,
+  ERC7540_FACET_ABI,
+  ERC4626_FACET_ABI,
+  CURATOR_CONFIG_ABI,
+  LZ_ADAPTER_ABI,
+  VAULT_ANALYSIS_ABI,
+  REGISTRY_ABI,
 } from "./abis";
 
 // --- Errors ---
@@ -60,6 +82,7 @@ export {
   quoteDepositFromSpokeFee,
   quoteComposeFee,
   executeCompose,
+  waitForCompose,
 } from "./crossChainFlows";
 
 // --- Redeem flows ---
@@ -72,7 +95,10 @@ export {
   smartRedeem,
   bridgeSharesToHub,
   bridgeAssetsToSpoke,
+  resolveRedeemAddresses,
+  quoteShareBridgeFee,
 } from "./redeemFlows";
+export type { SpokeRedeemRoute } from "./redeemFlows";
 
 // --- Utilities ---
 export {
@@ -81,11 +107,18 @@ export {
   isAsyncMode,
   getAsyncRequestStatus,
   getVaultStatus,
+  detectStargateOft,
 } from "./utils";
 export type { VaultStatus, VaultMode } from "./utils";
 
 // --- Pre-flight validation ---
-export { preflightSync, preflightAsync, preflightRedeemLiquidity } from "./preflight";
+export {
+  preflightSync,
+  preflightAsync,
+  preflightRedeemLiquidity,
+  preflightSpokeDeposit,
+  preflightSpokeRedeem,
+} from "./preflight";
 
 // --- User Helpers ---
 export {
@@ -98,6 +131,7 @@ export {
   getUserBalances,
   getMaxWithdrawable,
   getVaultSummary,
+  getUserPositionMultiChain,
 } from "./userHelpers";
 export type {
   UserPosition,
@@ -109,7 +143,68 @@ export type {
   UserBalances,
   MaxWithdrawable,
   VaultSummary,
+  MultiChainUserPosition,
 } from "./userHelpers";
 
+// --- Curator status reads ---
+export {
+  getCuratorVaultStatus,
+  getPendingActions,
+  isCurator,
+  getVaultAnalysis,
+  checkProtocolWhitelist,
+  getVaultAssetBreakdown,
+} from "./curatorStatus";
+
+// --- Curator multicall writes ---
+export {
+  encodeCuratorAction,
+  buildCuratorBatch,
+  submitActions,
+  executeActions,
+  vetoActions,
+} from "./curatorMulticall";
+
+// --- Curator swap helpers ---
+export {
+  buildUniswapV3Swap,
+  encodeUniswapV3SwapCalldata,
+} from "./curatorSwaps";
+
+// --- Topology ---
+export {
+  getVaultTopology,
+  getFullVaultTopology,
+  discoverVaultTopology,
+  isOnHubChain,
+  getAllVaultChainIds,
+  OMNI_FACTORY_ADDRESS,
+} from "./topology";
+export type { VaultTopology } from "./topology";
+
+// --- Distribution ---
+export {
+  getVaultDistribution,
+  getVaultDistributionWithTopology,
+} from "./distribution";
+export type { VaultDistribution, SpokeBalance } from "./distribution";
+
+// --- Spoke routes ---
+export {
+  getInboundRoutes,
+  getUserBalancesForRoutes,
+  getOutboundRoutes,
+  quoteRouteDepositFee,
+  NATIVE_SYMBOL,
+} from "./spokeRoutes";
+export type {
+  InboundRoute,
+  InboundRouteWithBalance,
+  OutboundRoute,
+} from "./spokeRoutes";
+
+// --- Chains ---
+export { UNISWAP_V3_ROUTERS, OFT_ROUTES } from "./chains";
+
 // --- wagmi / ethers adapter compatibility ---
 export { asSdkSigner } from "./wagmiCompat";

package/src/ethers/preflight.ts

@@ -8,8 +8,11 @@
 
 import { Contract, ZeroAddress } from "ethers";
 import type { Provider } from "ethers";
-import { CONFIG_ABI, BRIDGE_ABI, VAULT_ABI, ERC20_ABI } from "./abis";
+import { CONFIG_ABI, BRIDGE_ABI, VAULT_ABI, ERC20_ABI, OFT_ABI } from "./abis";
 import { InsufficientLiquidityError } from "./errors";
+import { detectStargateOft } from "./utils";
+import { EID_TO_CHAIN_ID, createChainProvider } from "./chains";
+import { quoteComposeFee } from "./crossChainFlows";
 
 /**
  * Pre-flight checks for async cross-chain flows (D4 / D5 / R5).
@@ -164,3 +167,224 @@ export async function preflightSync(
     );
   }
 }
+
+/**
+ * Pre-flight checks for spoke-to-hub deposits (D6 / D7 via OFT Compose).
+ *
+ * Validates that:
+ * 1. User has enough tokens on the spoke chain to deposit.
+ * 2. User has enough native gas on the spoke chain for TX1 (OFT.send).
+ * 3. For Stargate OFTs (2-TX flow): user has enough ETH on the hub chain for TX2.
+ *
+ * @param spokeProvider  Read-only provider on the SPOKE chain
+ * @param vault          Vault address
+ * @param spokeOFT       OFT contract address on the spoke chain
+ * @param hubEid         LZ EID for the hub chain
+ * @param spokeEid       LZ EID for the spoke chain
+ * @param amount         Amount of tokens to deposit
+ * @param userAddress    User's wallet address
+ * @param lzFee          LZ fee for TX1 (from quoteDepositFromSpokeFee)
+ * @returns              Object with validated balances for UI display
+ */
+export async function preflightSpokeDeposit(
+  spokeProvider: Provider,
+  vault: string,
+  spokeOFT: string,
+  hubEid: number,
+  spokeEid: number,
+  amount: bigint,
+  userAddress: string,
+  lzFee: bigint,
+): Promise<{
+  spokeTokenBalance: bigint
+  spokeNativeBalance: bigint
+  hubNativeBalance: bigint
+  estimatedComposeFee: bigint
+  isStargate: boolean
+}> {
+  // Read the underlying token address from the OFT
+  const OFT_TOKEN_ABI = ["function token() view returns (address)"] as const;
+  const oftContract = new Contract(spokeOFT, OFT_TOKEN_ABI, spokeProvider);
+  const spokeToken: string = await oftContract.token();
+
+  // Check token balance + native balance on spoke in parallel
+  const tokenContract = new Contract(spokeToken, ERC20_ABI, spokeProvider);
+  const [spokeTokenBalance, spokeNativeBalance]: [bigint, bigint] = await Promise.all([
+    tokenContract.balanceOf(userAddress),
+    spokeProvider.getBalance(userAddress),
+  ]);
+
+  // 1. Check token balance
+  if (spokeTokenBalance < amount) {
+    throw new Error(
+      `[MoreVaults] Insufficient token balance on spoke chain.\n` +
+      `  Need:  ${amount}\n` +
+      `  Have:  ${spokeTokenBalance}\n` +
+      `  Token: ${spokeToken}`,
+    );
+  }
+
+  // 2. Check native gas for TX1 (lzFee + gas buffer)
+  const gasBuffer = 500_000_000_000_000n; // 0.0005 ETH
+  if (spokeNativeBalance < lzFee + gasBuffer) {
+    throw new Error(
+      `[MoreVaults] Insufficient native gas on spoke chain for TX1.\n` +
+      `  Need:  ~${lzFee + gasBuffer} wei (LZ fee + gas)\n` +
+      `  Have:  ${spokeNativeBalance} wei`,
+    );
+  }
+
+  // 3. For Stargate OFTs: check ETH on hub for TX2 (compose retry)
+  const isStargate = await detectStargateOft(spokeProvider, spokeOFT);
+
+  let hubNativeBalance = 0n;
+  let estimatedComposeFee = 0n;
+
+  if (isStargate) {
+    const hubChainId = EID_TO_CHAIN_ID[hubEid];
+    const hubProvider = createChainProvider(hubChainId);
+    if (hubProvider) {
+      [hubNativeBalance, estimatedComposeFee] = await Promise.all([
+        hubProvider.getBalance(userAddress),
+        quoteComposeFee(hubProvider, vault, spokeEid, userAddress),
+      ]);
+
+      const hubGasBuffer = 300_000_000_000_000n; // 0.0003 ETH
+      const totalNeeded = estimatedComposeFee + hubGasBuffer;
+
+      if (hubNativeBalance < totalNeeded) {
+        throw new Error(
+          `[MoreVaults] Insufficient ETH on hub chain for TX2 (compose retry).\n` +
+          `  This is a Stargate 2-TX flow — TX2 requires ETH on the hub chain.\n` +
+          `  Need:  ~${totalNeeded} wei (compose fee ${estimatedComposeFee} + gas)\n` +
+          `  Have:  ${hubNativeBalance} wei\n` +
+          `  Short: ${totalNeeded - hubNativeBalance} wei\n` +
+          `  Send ETH to ${userAddress} on chainId ${hubChainId} before depositing.`,
+        );
+      }
+    }
+  }
+
+  return {
+    spokeTokenBalance,
+    spokeNativeBalance,
+    hubNativeBalance,
+    estimatedComposeFee,
+    isStargate,
+  };
+}
+
+/**
+ * Pre-flight checks for spoke→hub→spoke redeem (R6 + R1 + R7).
+ *
+ * Validates that:
+ * 1. User has shares on the spoke chain.
+ * 2. User has enough native gas on the spoke for TX1.
+ * 3. User has enough native gas on the hub for TX2 (redeem) + TX3 (asset bridge).
+ *
+ * @param route           SpokeRedeemRoute from resolveRedeemAddresses
+ * @param shares          Shares the user intends to redeem
+ * @param userAddress     User's wallet address
+ * @param shareBridgeFee  LZ fee for share bridge (TX1)
+ * @returns               Validated balances for UI display
+ */
+export async function preflightSpokeRedeem(
+  route: {
+    hubChainId: number
+    spokeChainId: number
+    hubEid: number
+    spokeEid: number
+    hubAsset: string
+    spokeShareOft: string
+    hubAssetOft: string
+    spokeAsset: string
+    isStargate: boolean
+  },
+  shares: bigint,
+  userAddress: string,
+  shareBridgeFee: bigint,
+): Promise<{
+  sharesOnSpoke: bigint
+  spokeNativeBalance: bigint
+  hubNativeBalance: bigint
+  estimatedAssetBridgeFee: bigint
+  estimatedAssetsOut: bigint
+  hubLiquidBalance: bigint
+}> {
+  const spokeProvider = createChainProvider(route.spokeChainId);
+  const hubProvider = createChainProvider(route.hubChainId);
+  if (!spokeProvider) throw new Error(`No public RPC for spoke chainId ${route.spokeChainId}`);
+  if (!hubProvider) throw new Error(`No public RPC for hub chainId ${route.hubChainId}`);
+
+  // Parallel reads: shares on spoke, native balances
+  const spokeShareContract = new Contract(route.spokeShareOft, ERC20_ABI, spokeProvider);
+  const [sharesOnSpoke, spokeNativeBalance, hubNativeBalance]: [bigint, bigint, bigint] =
+    await Promise.all([
+      spokeShareContract.balanceOf(userAddress),
+      spokeProvider.getBalance(userAddress),
+      hubProvider.getBalance(userAddress),
+    ]);
+
+  // 1. Check shares
+  if (sharesOnSpoke < shares) {
+    throw new Error(
+      `[MoreVaults] Insufficient shares on spoke chain.\n` +
+      `  Need:  ${shares}\n` +
+      `  Have:  ${sharesOnSpoke}\n` +
+      `  Token: ${route.spokeShareOft}`,
+    );
+  }
+
+  // 2. Check spoke gas for TX1
+  const spokeGasBuffer = 500_000_000_000_000n; // 0.0005 ETH
+  if (spokeNativeBalance < shareBridgeFee + spokeGasBuffer) {
+    throw new Error(
+      `[MoreVaults] Insufficient native gas on spoke for TX1 (share bridge).\n` +
+      `  Need:  ~${shareBridgeFee + spokeGasBuffer} wei (LZ fee + gas)\n` +
+      `  Have:  ${spokeNativeBalance} wei`,
+    );
+  }
+
+  // 3. Estimate asset bridge fee (TX3) and check hub gas
+  let estimatedAssetBridgeFee = 0n;
+
+  try {
+    const toBytes32 = `0x${userAddress.replace(/^0x/, '').padStart(64, '0')}`;
+    const dummyAmount = 1_000_000n; // 1 USDC for fee estimation
+    const hubOft = new Contract(route.hubAssetOft, OFT_ABI, hubProvider);
+    const feeResult = await hubOft.quoteSend({
+      dstEid: route.spokeEid,
+      to: toBytes32,
+      amountLD: dummyAmount,
+      minAmountLD: dummyAmount * 99n / 100n,
+      extraOptions: "0x",
+      composeMsg: "0x",
+      oftCmd: route.isStargate ? "0x01" : "0x",
+    }, false);
+    estimatedAssetBridgeFee = feeResult.nativeFee as bigint;
+  } catch {
+    estimatedAssetBridgeFee = 300_000_000_000_000n; // 0.0003 ETH fallback
+  }
+
+  const hubGasBuffer = 300_000_000_000_000n; // 0.0003 ETH for gas (TX2 + TX3)
+  const totalHubNeeded = estimatedAssetBridgeFee + hubGasBuffer;
+
+  if (hubNativeBalance < totalHubNeeded) {
+    throw new Error(
+      `[MoreVaults] Insufficient ETH on hub chain for TX2 (redeem) + TX3 (asset bridge).\n` +
+      `  Need:  ~${totalHubNeeded} wei (LZ fee ${estimatedAssetBridgeFee} + gas)\n` +
+      `  Have:  ${hubNativeBalance} wei\n` +
+      `  Short: ${totalHubNeeded - hubNativeBalance} wei\n` +
+      `  Send ETH to ${userAddress} on chainId ${route.hubChainId} before redeeming.`,
+    );
+  }
+
+  return {
+    sharesOnSpoke,
+    spokeNativeBalance,
+    hubNativeBalance,
+    estimatedAssetBridgeFee,
+    estimatedAssetsOut: 0n,
+    hubLiquidBalance: 0n,
+  };
+}

package/src/ethers/redeemFlows.ts

@@ -15,7 +15,9 @@ import type { ContractTransactionReceipt } from "ethers";
 import { preflightAsync, preflightRedeemLiquidity } from "./preflight";
 import { EscrowNotConfiguredError } from "./errors";
 import { validateWalletChain } from "./chainValidation";
-import { getVaultStatus, quoteLzFee } from "./utils";
+import { getVaultStatus, quoteLzFee, detectStargateOft } from "./utils";
+import { CHAIN_ID_TO_EID, OFT_ROUTES, createChainProvider } from "./chains";
+import { OMNI_FACTORY_ADDRESS } from "./topology";
 
 /**
  * Ensure `spender` has at least `amount` allowance from `owner`.
@@ -407,3 +409,160 @@ export async function bridgeAssetsToSpoke(
 
   return { receipt };
 }
+
+// ---------------------------------------------------------------------------
+// Spoke redeem helpers
+// ---------------------------------------------------------------------------
+
+/** Minimal ABIs used only within redeemFlows */
+const FACTORY_COMPOSER_ABI_RF = [
+  "function vaultComposer(address _vault) view returns (address)",
+] as const;
+
+const REDEEM_COMPOSER_ABI = [
+  "function SHARE_OFT() view returns (address)",
+] as const;
+
+const OFT_PEERS_ABI_RF = [
+  "function peers(uint32 eid) view returns (bytes32)",
+] as const;
+
+export interface SpokeRedeemRoute {
+  /** Hub chain ID */
+  hubChainId: number
+  /** Spoke chain ID */
+  spokeChainId: number
+  /** LZ EID for the hub */
+  hubEid: number
+  /** LZ EID for the spoke */
+  spokeEid: number
+  /** Vault underlying asset address on hub */
+  hubAsset: string
+  /** SHARE_OFT on spoke chain */
+  spokeShareOft: string
+  /** Asset OFT on hub for bridging back */
+  hubAssetOft: string
+  /** Underlying asset address on spoke chain */
+  spokeAsset: string
+  /** Whether the asset OFT is a Stargate pool */
+  isStargate: boolean
+  /** OFT route symbol (e.g. 'stgUSDC') */
+  symbol: string
+}
+
+/**
+ * Quote the LZ fee for bridging shares from spoke to hub via SHARE_OFT.
+ *
+ * IMPORTANT: `amountLD` must be in SHARE_OFT native decimals (e.g. 18),
+ * NOT vault decimals (e.g. 8). Use the raw `SHARE_OFT.balanceOf(user)` value.
+ *
+ * @param spokeProvider  Read-only provider on the SPOKE chain
+ * @param shareOFT       SHARE_OFT address on the spoke chain
+ * @param hubChainEid    LayerZero Endpoint ID for the hub chain
+ * @param amountLD       Shares in SHARE_OFT native decimals (raw balanceOf)
+ * @param receiver       Receiver address on the hub chain
+ * @returns              LZ native fee in wei
+ */
+export async function quoteShareBridgeFee(
+  spokeProvider: Provider,
+  shareOFT: string,
+  hubChainEid: number,
+  amountLD: bigint,
+  receiver: string,
+): Promise<bigint> {
+  const toBytes32 = zeroPadValue(receiver, 32);
+  const sendParam = {
+    dstEid: hubChainEid,
+    to: toBytes32,
+    amountLD,
+    minAmountLD: amountLD,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x",
+  };
+
+  const oft = new Contract(shareOFT, OFT_ABI, spokeProvider);
+  const fee = await oft.quoteSend(sendParam, false);
+  return fee.nativeFee as bigint;
+}
+
+/**
+ * Resolve all addresses needed for a full spoke→hub→spoke redeem flow.
+ *
+ * @param hubProvider  Read-only provider on the HUB chain
+ * @param vault        Vault address
+ * @param hubChainId   Hub chain ID
+ * @param spokeChainId Spoke chain ID where user has shares
+ * @returns            All addresses needed for bridgeSharesToHub + redeemShares + bridgeAssetsToSpoke
+ */
+export async function resolveRedeemAddresses(
+  hubProvider: Provider,
+  vault: string,
+  hubChainId: number,
+  spokeChainId: number,
+): Promise<SpokeRedeemRoute> {
+  const hubEid = CHAIN_ID_TO_EID[hubChainId];
+  const spokeEid = CHAIN_ID_TO_EID[spokeChainId];
+  if (!hubEid || !spokeEid) {
+    throw new Error(`No LZ EID for chainId ${!hubEid ? hubChainId : spokeChainId}`);
+  }
+
+  const vaultContract = new Contract(vault, VAULT_ABI, hubProvider);
+  const factory = new Contract(OMNI_FACTORY_ADDRESS, FACTORY_COMPOSER_ABI_RF, hubProvider);
+  const [hubAsset, composerAddress]: [string, string] = await Promise.all([
+    vaultContract.asset(),
+    factory.vaultComposer(vault),
+  ]);
+
+  if (composerAddress === ZeroAddress) {
+    throw new Error(`[MoreVaults] No composer registered for vault ${vault} on hub chain ${hubChainId}`);
+  }
+
+  const composer = new Contract(composerAddress, REDEEM_COMPOSER_ABI, hubProvider);
+  const hubShareOft: string = await composer.SHARE_OFT();
+
+  const hubShareOftContract = new Contract(hubShareOft, OFT_PEERS_ABI_RF, hubProvider);
+  const spokeShareOftBytes32: string = await hubShareOftContract.peers(spokeEid);
+
+  // Convert bytes32 to address (last 20 bytes = last 40 hex chars)
+  const spokeShareOft = `0x${spokeShareOftBytes32.slice(-40)}`;
+
+  let hubAssetOft: string | null = null;
+  let spokeAsset: string | null = null;
+  let symbol = '';
+
+  for (const [sym, chainMap] of Object.entries(OFT_ROUTES)) {
+    const hubEntry = (chainMap as Record<number, { oft: string; token: string }>)[hubChainId];
+    const spokeEntry = (chainMap as Record<number, { oft: string; token: string }>)[spokeChainId];
+    if (!hubEntry || !spokeEntry) continue;
+
+    if (hubEntry.token.toLowerCase() === hubAsset.toLowerCase()) {
+      hubAssetOft = hubEntry.oft;
+      spokeAsset = spokeEntry.token;
+      symbol = sym;
+      break;
+    }
+  }
+
+  if (!hubAssetOft || !spokeAsset) {
+    throw new Error(
+      `[MoreVaults] No OFT route found for vault asset ${hubAsset} ` +
+      `between hub chain ${hubChainId} and spoke chain ${spokeChainId}`,
+    );
+  }
+
+  const isStargate = await detectStargateOft(hubProvider, hubAssetOft);
+
+  return {
+    hubChainId,
+    spokeChainId,
+    hubEid,
+    spokeEid,
+    hubAsset,
+    spokeShareOft,
+    hubAssetOft,
+    spokeAsset,
+    isStargate,
+    symbol,
+  };
+}