@oydual31/more-vaults-sdk 0.3.2 → 0.4.0

package/src/ethers/userHelpers.ts

@@ -10,6 +10,8 @@ import { BRIDGE_ABI, CONFIG_ABI, ERC20_ABI, VAULT_ABI, METADATA_ABI } from "./ab
 import type { CrossChainRequestInfo } from "./types";
 import { getVaultStatus } from "./utils";
 import type { VaultStatus } from "./utils";
+import { CHAIN_ID_TO_EID, OFT_ROUTES, createChainProvider } from "./chains";
+import { discoverVaultTopology, OMNI_FACTORY_ADDRESS } from "./topology";
 
 // Multicall3 — deployed at the same address on every EVM chain
 const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
@@ -478,3 +480,194 @@ export async function getVaultSummary(
   ]);
   return { ...status, ...metadata };
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Minimal ABIs for SHARE_OFT discovery in getUserPositionMultiChain */
+const FACTORY_COMPOSER_ABI_UH = [
+  "function vaultComposer(address _vault) view returns (address)",
+] as const;
+
+const COMPOSER_SHARE_OFT_ABI_UH = [
+  "function SHARE_OFT() view returns (address)",
+] as const;
+
+const OFT_PEERS_ABI_UH = [
+  "function peers(uint32 eid) view returns (bytes32)",
+] as const;
+
+export interface MultiChainUserPosition {
+  /** Shares held directly on the hub vault (vault.balanceOf) */
+  hubShares: bigint;
+  /** Per-spoke SHARE_OFT balances normalized to vault decimals: { [chainId]: bigint } */
+  spokeShares: Record<number, bigint>;
+  /** Per-spoke SHARE_OFT raw balances in OFT native decimals: { [chainId]: bigint }
+   *  Use these for bridgeSharesToHub() and quoteShareBridgeFee() */
+  rawSpokeShares: Record<number, bigint>;
+  /** hubShares + sum of all spokeShares (in vault decimals) */
+  totalShares: bigint;
+  /** convertToAssets(totalShares) on the hub */
+  estimatedAssets: bigint;
+  /** Share price: convertToAssets(10^decimals) */
+  sharePrice: bigint;
+  /** Vault decimals */
+  decimals: number;
+  /** Pending async withdrawal request on hub, or null */
+  pendingWithdrawal: {
+    shares: bigint;
+    timelockEndsAt: bigint;
+    canRedeemNow: boolean;
+  } | null;
+}
+
+/**
+ * Read the user's position across all chains of an omni vault.
+ *
+ * Discovers topology automatically, reads hub shares + pending withdrawal,
+ * then reads SHARE_OFT balances on each spoke chain in parallel.
+ *
+ * For local (single-chain) vaults, spokeShares will be empty and this
+ * behaves identically to getUserPosition.
+ *
+ * @param vault  Vault address (same on all chains via CREATE3)
+ * @param user   User wallet address
+ * @returns      Aggregated position across all chains
+ */
+export async function getUserPositionMultiChain(
+  vault: string,
+  user: string,
+): Promise<MultiChainUserPosition> {
+  // Step 1: discover topology
+  const topo = await discoverVaultTopology(vault);
+  const hubProvider = createChainProvider(topo.hubChainId);
+  if (!hubProvider) throw new Error(`No public RPC for hub chainId ${topo.hubChainId}`);
+
+  // Step 2: read hub data (shares, decimals, withdrawal request)
+  const mc = new Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, hubProvider);
+  const vaultIface = new Interface(VAULT_ABI as unknown as string[]);
+  const decimalsIface = new 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) as Promise<{ success: boolean; returnData: string }[]>,
+    hubProvider.getBlock("latest"),
+  ]);
+
+  const hubShares = vaultIface.decodeFunctionResult("balanceOf", b1Raw[0].returnData)[0] as bigint;
+  const decimals = Number(decimalsIface.decodeFunctionResult("decimals", b1Raw[1].returnData)[0]);
+  const withdrawalResult = vaultIface.decodeFunctionResult("getWithdrawalRequest", b1Raw[2].returnData);
+  const withdrawShares = withdrawalResult[0] as bigint;
+  const timelockEndsAt = withdrawalResult[1] as bigint;
+
+  // Step 3: resolve SHARE_OFT addresses for spokes (if any)
+  const spokeShares: Record<number, bigint> = {};
+  const rawSpokeShares: Record<number, bigint> = {};
+
+  if (topo.spokeChainIds.length > 0) {
+    let hubShareOft: string | null = null;
+    try {
+      const factory = new Contract(OMNI_FACTORY_ADDRESS, FACTORY_COMPOSER_ABI_UH, hubProvider);
+      const composerAddress: string = await factory.vaultComposer(vault);
+
+      if (composerAddress !== "0x0000000000000000000000000000000000000000") {
+        const composer = new Contract(composerAddress, COMPOSER_SHARE_OFT_ABI_UH, hubProvider);
+        hubShareOft = await composer.SHARE_OFT();
+      }
+    } catch { /* no composer — skip spoke reads */ }
+
+    if (hubShareOft) {
+      const hubShareOftContract = new Contract(hubShareOft, OFT_PEERS_ABI_UH, hubProvider);
+
+      const spokePromises = topo.spokeChainIds.map(async (spokeChainId) => {
+        try {
+          const spokeEid = CHAIN_ID_TO_EID[spokeChainId];
+          if (!spokeEid) return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+
+          const spokeOftBytes32: string = await hubShareOftContract.peers(spokeEid);
+          const spokeOft = `0x${spokeOftBytes32.slice(-40)}`;
+
+          if (spokeOft === "0x0000000000000000000000000000000000000000") {
+            return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+          }
+
+          const spokeProvider = createChainProvider(spokeChainId);
+          if (!spokeProvider) return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+
+          // Read balance + decimals on spoke chain via Multicall3
+          const spokeMc = new Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, spokeProvider);
+          const erc20Iface = new Interface(ERC20_ABI as unknown as string[]);
+          const spokeDecimalsIface = new Interface(["function decimals() view returns (uint8)"]);
+
+          const spokeCalls = [
+            { target: spokeOft, allowFailure: false, callData: erc20Iface.encodeFunctionData("balanceOf", [user]) },
+            { target: spokeOft, allowFailure: false, callData: spokeDecimalsIface.encodeFunctionData("decimals") },
+          ];
+          const spokeRaw: { success: boolean; returnData: string }[] =
+            await spokeMc.aggregate3.staticCall(spokeCalls);
+
+          const rawBalance = erc20Iface.decodeFunctionResult("balanceOf", spokeRaw[0].returnData)[0] as bigint;
+          const spokeOftDecimals = Number(spokeDecimalsIface.decodeFunctionResult("decimals", spokeRaw[1].returnData)[0]);
+
+          // Normalize to vault decimals
+          let balance: bigint;
+          if (spokeOftDecimals > decimals) {
+            balance = rawBalance / (10n ** BigInt(spokeOftDecimals - decimals));
+          } else if (spokeOftDecimals < decimals) {
+            balance = rawBalance * (10n ** BigInt(decimals - spokeOftDecimals));
+          } else {
+            balance = rawBalance;
+          }
+
+          return { chainId: spokeChainId, balance, rawBalance };
+        } catch {
+          return { chainId: spokeChainId, balance: 0n, rawBalance: 0n };
+        }
+      });
+
+      const results = await Promise.all(spokePromises);
+      for (const { chainId, balance, rawBalance } of results) {
+        spokeShares[chainId] = balance;
+        rawSpokeShares[chainId] = rawBalance;
+      }
+    }
+  }
+
+  // Step 4: compute totals
+  const totalSpokeShares = Object.values(spokeShares).reduce((sum, b) => sum + b, 0n);
+  const totalShares = hubShares + totalSpokeShares;
+
+  const oneShare = 10n ** BigInt(decimals);
+  const vaultContract = new Contract(vault, VAULT_ABI, hubProvider);
+  const [estimatedAssets, sharePrice]: [bigint, bigint] = await Promise.all([
+    totalShares === 0n
+      ? Promise.resolve(0n)
+      : (vaultContract.convertToAssets(totalShares) as Promise<bigint>),
+    vaultContract.convertToAssets(oneShare) as Promise<bigint>,
+  ]);
+
+  // Step 5: pending withdrawal
+  const currentTimestamp = BigInt(block?.timestamp ?? 0);
+  const pendingWithdrawal = withdrawShares === 0n
+    ? null
+    : {
+        shares: withdrawShares,
+        timelockEndsAt,
+        canRedeemNow: timelockEndsAt === 0n || currentTimestamp >= timelockEndsAt,
+      };
+
+  return {
+    hubShares,
+    spokeShares,
+    rawSpokeShares,
+    totalShares,
+    estimatedAssets,
+    sharePrice,
+    decimals,
+    pendingWithdrawal,
+  };
+}

package/src/ethers/utils.ts

@@ -8,6 +8,11 @@ import { Contract, Interface, ZeroAddress } from "ethers";
 import type { Provider, Signer } from "ethers";
 import { BRIDGE_ABI, CONFIG_ABI, ERC20_ABI, VAULT_ABI } from "./abis";
 
+// Minimal ABI for Stargate type detection
+const STARGATE_TYPE_ABI = [
+  "function stargateType() view returns (uint8)",
+] as const;
+
 // Multicall3 — deployed at the same address on every EVM chain
 const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
 const MULTICALL3_ABI = [
@@ -379,3 +384,26 @@ export async function getVaultStatus(
     issues,
   };
 }
+
+/**
+ * Detect whether an OFT address is a Stargate V2 pool by calling `stargateType()`.
+ *
+ * Stargate pools implement this function (returns 0=Pool, 1=OFT).
+ * Standard OFTs revert because they don't have it.
+ *
+ * @param provider  Read-only provider on the OFT's chain
+ * @param oft       OFT contract address
+ * @returns         true if the contract is a Stargate V2 pool/OFT
+ */
+export async function detectStargateOft(
+  provider: Provider,
+  oft: string
+): Promise<boolean> {
+  try {
+    const contract = new Contract(oft, STARGATE_TYPE_ABI, provider);
+    await contract.stargateType();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/viem/crossChainFlows.ts

@@ -10,7 +10,7 @@ import {
 } from 'viem'
 import { OFT_ABI, BRIDGE_ABI, LZ_ENDPOINT_ABI } from './abis'
 import type { ComposeData, SpokeDepositResult } from './types'
-import { ensureAllowance } from './utils'
+import { ensureAllowance, detectStargateOft } from './utils'
 import { OFT_ROUTES, EID_TO_CHAIN_ID } from './chains'
 import { OMNI_FACTORY_ADDRESS } from './topology'
 import { createChainClient } from './spokeRoutes'
@@ -38,8 +38,6 @@ const COMPOSER_ABI = [
   },
 ] as const
 
-const STARGATE_ASSETS = new Set(['stgUSDC', 'USDT', 'WETH'])
-
 /**
  * Build a LZ V2 TYPE_3 executor option that forwards native ETH to the lzCompose call.
  *
@@ -61,17 +59,6 @@ function buildLzComposeOption(gas: bigint, nativeValue: bigint): `0x${string}` {
   return `0x00030300220000${gasHex}${valueHex}` as `0x${string}`
 }
 
-/** Returns true if the OFT is a Stargate V2 pool (bus/taxi architecture). */
-function isStargateOft(oft: Address): boolean {
-  for (const [symbol, chainMap] of Object.entries(OFT_ROUTES)) {
-    if (!STARGATE_ASSETS.has(symbol)) continue
-    for (const entry of Object.values(chainMap as Record<number, { oft: string; token: string }>)) {
-      if (getAddress(entry.oft) === oft) return true
-    }
-  }
-  return false
-}
-
 /**
  * Resolve the native ETH value that MoreVaultsComposer needs to receive via lzCompose.
  *
@@ -263,7 +250,7 @@ export async function depositFromSpoke(
 
   // For Stargate OFTs: extraOptions must be '0x' (rejects LZCOMPOSE type-3 options).
   // For standard OFTs: inject LZCOMPOSE option with native ETH for readFee + share send.
-  const isStargate = isStargateOft(oft)
+  const isStargate = await detectStargateOft(publicClient, oft)
   let resolvedExtraOptions: `0x${string}`
   if (extraOptions !== '0x') {
     resolvedExtraOptions = extraOptions
@@ -377,7 +364,7 @@ export async function depositFromSpoke(
   // The compose message is NOT available yet — it's emitted as ComposeSent on the hub
   // after LZ delivers the message. The user must call waitForCompose() to get it,
   // then executeCompose() to execute it.
-  const stargate = isStargateOft(getAddress(spokeOFT))
+  const stargate = isStargate
   let composeData: ComposeData | undefined
   if (stargate) {
     // Snapshot current hub block BEFORE waiting — this is exactly where we start
@@ -454,7 +441,7 @@ export async function quoteDepositFromSpokeFee(
   const composerBytes32 = pad(composerAddress, { size: 32 })
 
   // Match depositFromSpoke: resolve extraOptions the same way
-  const isStargate = isStargateOft(oft)
+  const isStargate = await detectStargateOft(publicClient, oft)
   let resolvedExtraOptions: `0x${string}`
   if (extraOptions !== '0x') {
     resolvedExtraOptions = extraOptions
@@ -560,14 +547,17 @@ export async function waitForCompose(
   const receiverNeedle = getAddress(receiver).slice(2).toLowerCase()
   const startBlock = composeData.hubBlockStart
 
-  // Known Stargate pool addresses on hub for composeQueue checks
-  const knownFromAddresses: Address[] = []
+  // Collect all OFT addresses on the hub chain, then filter to Stargate pools on-chain
   const hubChainId = composeData.hubChainId
-  for (const [symbol, chainMap] of Object.entries(OFT_ROUTES)) {
-    if (!STARGATE_ASSETS.has(symbol)) continue
+  const candidateAddresses: Address[] = []
+  for (const chainMap of Object.values(OFT_ROUTES)) {
     const entry = (chainMap as Record<number, { oft: string; token: string }>)[hubChainId]
-    if (entry) knownFromAddresses.push(getAddress(entry.oft) as Address)
+    if (entry) candidateAddresses.push(getAddress(entry.oft) as Address)
   }
+  const stargateChecks = await Promise.all(
+    candidateAddresses.map(async (addr) => ({ addr, isSg: await detectStargateOft(hubPublicClient, addr) })),
+  )
+  const knownFromAddresses = stargateChecks.filter((c) => c.isSg).map((c) => c.addr)
 
   let attempt = 0
   // Track the highest block we've already scanned to avoid re-scanning

package/src/viem/index.ts

@@ -106,6 +106,7 @@ export {
   getAsyncRequestStatus,
   waitForAsyncRequest,
   getVaultStatus,
+  detectStargateOft,
 } from './utils'
 export type { VaultStatus, VaultMode, AsyncRequestFinalResult } from './utils'
 

package/src/viem/preflight.ts

@@ -11,7 +11,8 @@ import { CONFIG_ABI, BRIDGE_ABI, VAULT_ABI, ERC20_ABI, OFT_ABI } from './abis'
 import { InsufficientLiquidityError } from './errors'
 import { quoteComposeFee } from './crossChainFlows'
 import { createChainClient } from './spokeRoutes'
-import { EID_TO_CHAIN_ID, OFT_ROUTES } from './chains'
+import { EID_TO_CHAIN_ID } from './chains'
+import { detectStargateOft } from './utils'
 
 /**
  * Pre-flight checks for async cross-chain flows (D4 / D5 / R5).
@@ -305,14 +306,7 @@ export async function preflightSpokeDeposit(
   }
 
   // 3. For Stargate OFTs: check ETH on hub for TX2 (compose retry)
-  const STARGATE_ASSETS = new Set(['stgUSDC', 'USDT', 'WETH'])
-  let isStargate = false
-  for (const [symbol, chainMap] of Object.entries(OFT_ROUTES)) {
-    if (!STARGATE_ASSETS.has(symbol)) continue
-    for (const entry of Object.values(chainMap as Record<number, { oft: string; token: string }>)) {
-      if (getAddress(entry.oft) === oft) isStargate = true
-    }
-  }
+  const isStargate = await detectStargateOft(spokePublicClient, oft)
 
   let hubNativeBalance = 0n
   let estimatedComposeFee = 0n

package/src/viem/redeemFlows.ts

@@ -15,7 +15,7 @@ import type {
   AsyncRequestResult,
 } from './types'
 import { ActionType } from './types'
-import { ensureAllowance, getVaultStatus, quoteLzFee } from './utils'
+import { ensureAllowance, getVaultStatus, quoteLzFee, detectStargateOft } from './utils'
 import { preflightAsync, preflightRedeemLiquidity } from './preflight'
 import { EscrowNotConfiguredError } from './errors'
 import { validateWalletChain } from './chainValidation'
@@ -581,8 +581,6 @@ export interface SpokeRedeemRoute {
   symbol: string
 }
 
-const STARGATE_ASSETS = new Set(['stgUSDC', 'USDT', 'WETH'])
-
 const FACTORY_COMPOSER_ABI = [
   {
     type: 'function' as const,
@@ -664,7 +662,6 @@ export async function resolveRedeemAddresses(
   // Find matching OFT route for the vault's asset on the hub chain
   let hubAssetOft: Address | null = null
   let spokeAsset: Address | null = null
-  let isStargate = false
   let symbol = ''
 
   for (const [sym, chainMap] of Object.entries(OFT_ROUTES)) {
@@ -675,7 +672,6 @@ export async function resolveRedeemAddresses(
     if (getAddress(hubEntry.token) === getAddress(hubAsset)) {
       hubAssetOft = getAddress(hubEntry.oft) as Address
       spokeAsset = getAddress(spokeEntry.token) as Address
-      isStargate = STARGATE_ASSETS.has(sym)
       symbol = sym
       break
     }
@@ -688,6 +684,9 @@ export async function resolveRedeemAddresses(
     )
   }
 
+  // On-chain detection: Stargate pools implement stargateType(), standard OFTs revert
+  const isStargate = await detectStargateOft(hubPublicClient, hubAssetOft)
+
   return {
     hubChainId,
     spokeChainId,

package/src/viem/utils.ts

@@ -522,3 +522,43 @@ export async function waitForAsyncRequest(
     `The request may still complete — check https://layerzeroscan.com/tx/${guid}`,
   )
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Stargate detection — on-chain probe
+// ─────────────────────────────────────────────────────────────────────────────
+
+const STARGATE_TYPE_ABI = [
+  {
+    type: 'function' as const,
+    name: 'stargateType' as const,
+    inputs: [] as const,
+    outputs: [{ type: 'uint8' as const }] as const,
+    stateMutability: 'view' as const,
+  },
+] as const
+
+/**
+ * Detect whether an OFT address is a Stargate V2 pool by calling `stargateType()`.
+ *
+ * Stargate pools implement this function (returns 0=Pool, 1=OFT).
+ * Standard OFTs revert because they don't have it.
+ *
+ * @param publicClient  Viem public client on the OFT's chain
+ * @param oft           OFT contract address
+ * @returns             true if the contract is a Stargate V2 pool/OFT
+ */
+export async function detectStargateOft(
+  publicClient: PublicClient,
+  oft: Address,
+): Promise<boolean> {
+  try {
+    await publicClient.readContract({
+      address: getAddress(oft),
+      abi: STARGATE_TYPE_ABI,
+      functionName: 'stargateType',
+    })
+    return true
+  } catch {
+    return false
+  }
+}