@oydual31/more-vaults-sdk 0.2.3 → 0.2.5

package/package.json

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

package/src/react/index.ts

@@ -11,6 +11,9 @@ export type { VaultMetadata } from './useVaultMetadata.js'
 export { useUserPosition } from './useUserPosition.js'
 export type { UserPosition } from './useUserPosition.js'
 
+export { useUserPositionMultiChain } from './useUserPositionMultiChain.js'
+export type { MultiChainUserPosition } from './useUserPositionMultiChain.js'
+
 export { useLzFee } from './useLzFee.js'
 
 export { useAsyncRequestStatus } from './useAsyncRequestStatus.js'

package/src/react/useUserPositionMultiChain.ts

@@ -0,0 +1,33 @@
+import { useQuery } from '@tanstack/react-query'
+import { getUserPositionMultiChain } from '../viem/userHelpers.js'
+import type { MultiChainUserPosition } from '../viem/userHelpers.js'
+
+export type { MultiChainUserPosition }
+
+/**
+ * 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.
+ * Works without a connected wallet (uses public RPCs).
+ *
+ * @example
+ * const { data: position } = useUserPositionMultiChain('0xVAULT', '0xUSER')
+ * // position.hubShares      — shares on hub (Base)
+ * // position.spokeShares    — { 1: 500n, 42161: 0n } per spoke
+ * // position.totalShares    — hub + all spokes
+ * // position.estimatedAssets — convertToAssets(totalShares)
+ * // position.pendingWithdrawal — async withdrawal if any
+ */
+export function useUserPositionMultiChain(
+  vault: `0x${string}` | undefined,
+  user: `0x${string}` | undefined,
+) {
+  return useQuery<MultiChainUserPosition>({
+    queryKey: ['userPositionMultiChain', vault, user],
+    queryFn: () => getUserPositionMultiChain(vault!, user!),
+    enabled: !!vault && !!user,
+    refetchInterval: 30_000,
+    staleTime: 15_000,
+  })
+}

package/src/viem/index.ts

@@ -83,9 +83,10 @@ export {
   quoteLzFee,
   isAsyncMode,
   getAsyncRequestStatus,
+  waitForAsyncRequest,
   getVaultStatus,
 } from './utils'
-export type { VaultStatus, VaultMode } from './utils'
+export type { VaultStatus, VaultMode, AsyncRequestFinalResult } from './utils'
 
 // --- Pre-flight validation ---
 export { preflightSync, preflightAsync, preflightRedeemLiquidity, preflightSpokeDeposit, preflightSpokeRedeem } from './preflight'
@@ -101,6 +102,7 @@ export {
   getUserBalances,
   getMaxWithdrawable,
   getVaultSummary,
+  getUserPositionMultiChain,
 } from './userHelpers'
 export type {
   UserPosition,
@@ -112,6 +114,7 @@ export type {
   UserBalances,
   MaxWithdrawable,
   VaultSummary,
+  MultiChainUserPosition,
 } from './userHelpers'
 
 // --- Topology ---

package/src/viem/userHelpers.ts

@@ -1,8 +1,11 @@
 import { type Address, type PublicClient, getAddress } from 'viem'
-import { BRIDGE_ABI, CONFIG_ABI, ERC20_ABI, VAULT_ABI, METADATA_ABI } from './abis'
+import { BRIDGE_ABI, CONFIG_ABI, ERC20_ABI, VAULT_ABI, METADATA_ABI, OFT_ABI } from './abis'
 import type { CrossChainRequestInfo } from './types'
 import { getVaultStatus } from './utils'
 import type { VaultStatus } from './utils'
+import { discoverVaultTopology, OMNI_FACTORY_ADDRESS } from './topology'
+import { createChainClient } from './spokeRoutes'
+import { CHAIN_ID_TO_EID } from './chains'
 
 // ─────────────────────────────────────────────────────────────────────────────
 
@@ -498,3 +501,183 @@ export async function getVaultSummary(
   ])
   return { ...status, ...metadata }
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+const FACTORY_COMPOSER_ABI = [
+  {
+    type: 'function' as const,
+    name: 'vaultComposer',
+    inputs: [{ name: '_vault', type: 'address' }],
+    outputs: [{ name: '', type: 'address' }],
+    stateMutability: 'view' as const,
+  },
+] as const
+
+const COMPOSER_SHARE_OFT_ABI = [
+  {
+    type: 'function' as const,
+    name: 'SHARE_OFT',
+    inputs: [],
+    outputs: [{ name: '', type: 'address' }],
+    stateMutability: 'view' as const,
+  },
+] as const
+
+export interface MultiChainUserPosition {
+  /** Shares held directly on the hub vault (vault.balanceOf) */
+  hubShares: bigint
+  /** Per-spoke SHARE_OFT balances: { [chainId]: bigint } */
+  spokeShares: Record<number, bigint>
+  /** hubShares + sum of all spokeShares */
+  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: Address,
+  user: Address,
+): Promise<MultiChainUserPosition> {
+  const v = getAddress(vault)
+  const u = getAddress(user)
+
+  // Step 1: discover topology
+  const topo = await discoverVaultTopology(vault)
+  const hubClient = createChainClient(topo.hubChainId)
+  if (!hubClient) throw new Error(`No public RPC for hub chainId ${topo.hubChainId}`)
+
+  // Step 2: read hub data (shares, decimals, withdrawal request)
+  const [hubShares, decimals, withdrawalRequest] = await (hubClient as 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 [withdrawShares, timelockEndsAt] = withdrawalRequest as unknown as [bigint, bigint]
+
+  // Step 3: resolve SHARE_OFT addresses for spokes (if any)
+  const spokeShares: Record<number, bigint> = {}
+
+  if (topo.spokeChainIds.length > 0) {
+    // Get hub SHARE_OFT via factory → composer → SHARE_OFT
+    let hubShareOft: Address | null = null
+    try {
+      const composerAddress = await (hubClient as PublicClient).readContract({
+        address: OMNI_FACTORY_ADDRESS,
+        abi: FACTORY_COMPOSER_ABI,
+        functionName: 'vaultComposer',
+        args: [v],
+      }) as Address
+
+      if (composerAddress !== '0x0000000000000000000000000000000000000000') {
+        hubShareOft = await (hubClient as PublicClient).readContract({
+          address: composerAddress,
+          abi: COMPOSER_SHARE_OFT_ABI,
+          functionName: 'SHARE_OFT',
+        }) as Address
+      }
+    } catch { /* no composer — skip spoke reads */ }
+
+    if (hubShareOft) {
+      // Read spoke SHARE_OFT addresses via peers() and balances in parallel
+      const spokePromises = topo.spokeChainIds.map(async (spokeChainId) => {
+        try {
+          const spokeEid = CHAIN_ID_TO_EID[spokeChainId]
+          if (!spokeEid) return { chainId: spokeChainId, balance: 0n }
+
+          // Get spoke SHARE_OFT address from hub peers()
+          const spokeOftBytes32 = await (hubClient as PublicClient).readContract({
+            address: hubShareOft!,
+            abi: OFT_ABI,
+            functionName: 'peers',
+            args: [spokeEid],
+          }) as `0x${string}`
+
+          const spokeOft = getAddress(`0x${spokeOftBytes32.slice(-40)}`) as Address
+          if (spokeOft === '0x0000000000000000000000000000000000000000') {
+            return { chainId: spokeChainId, balance: 0n }
+          }
+
+          // Read balance on spoke chain
+          const spokeClient = createChainClient(spokeChainId)
+          if (!spokeClient) return { chainId: spokeChainId, balance: 0n }
+
+          const balance = await (spokeClient as PublicClient).readContract({
+            address: spokeOft,
+            abi: ERC20_ABI,
+            functionName: 'balanceOf',
+            args: [u],
+          })
+
+          return { chainId: spokeChainId, balance }
+        } catch {
+          return { chainId: spokeChainId, balance: 0n }
+        }
+      })
+
+      const results = await Promise.all(spokePromises)
+      for (const { chainId, balance } of results) {
+        spokeShares[chainId] = balance
+      }
+    }
+  }
+
+  // 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 [estimatedAssets, sharePrice] = await Promise.all([
+    totalShares === 0n
+      ? Promise.resolve(0n)
+      : (hubClient as PublicClient).readContract({ address: v, abi: VAULT_ABI, functionName: 'convertToAssets', args: [totalShares] }),
+    (hubClient as PublicClient).readContract({ address: v, abi: VAULT_ABI, functionName: 'convertToAssets', args: [oneShare] }),
+  ])
+
+  // Step 5: pending withdrawal
+  const block = await (hubClient as PublicClient).getBlock()
+  const pendingWithdrawal = withdrawShares === 0n
+    ? null
+    : {
+        shares: withdrawShares,
+        timelockEndsAt,
+        canRedeemNow: timelockEndsAt === 0n || block.timestamp >= timelockEndsAt,
+      }
+
+  return {
+    hubShares,
+    spokeShares,
+    totalShares,
+    estimatedAssets,
+    sharePrice,
+    decimals,
+    pendingWithdrawal,
+  }
+}

package/src/viem/utils.ts

@@ -437,7 +437,7 @@ export async function getAsyncRequestStatus(
   publicClient: PublicClient,
   vault: Address,
   guid: `0x${string}`,
-): Promise<{ fulfilled: boolean; finalized: boolean; result: bigint }> {
+): Promise<{ fulfilled: boolean; finalized: boolean; refunded: boolean; result: bigint }> {
   const info = (await publicClient.readContract({
     address: getAddress(vault),
     abi: BRIDGE_ABI,
@@ -455,6 +455,70 @@ export async function getAsyncRequestStatus(
   return {
     fulfilled: info.fulfilled,
     finalized: info.finalized,
+    refunded: info.refunded,
     result: finalizationResult,
   }
 }
+
+export interface AsyncRequestFinalResult {
+  /** 'completed' = assets/shares received, 'refunded' = tokens returned to user */
+  status: 'completed' | 'refunded'
+  /** For deposit: shares minted. For redeem: assets returned. 0 if refunded. */
+  result: bigint
+}
+
+/**
+ * Poll an async cross-chain request until it finalizes or times out.
+ *
+ * This is the correct way to wait for smartDeposit/smartRedeem results on
+ * async vaults. Do NOT poll balance — use this instead, which reads the
+ * on-chain request state by GUID.
+ *
+ * @param publicClient  Public client on the hub chain
+ * @param vault         Vault address
+ * @param guid          GUID from smartDeposit/smartRedeem result
+ * @param pollInterval  Milliseconds between polls (default: 30_000)
+ * @param timeout       Max wait time in milliseconds (default: 900_000 = 15 min)
+ * @param onPoll        Optional callback invoked after each poll with current status
+ * @returns             Final result with status and amount
+ * @throws              Error if timeout is reached
+ *
+ * @example
+ * const depositResult = await smartDeposit(walletClient, publicClient, { vault }, amount, receiver)
+ * if ('guid' in depositResult) {
+ *   const final = await waitForAsyncRequest(publicClient, vault, depositResult.guid, 30_000, 900_000, (s) => {
+ *     console.log(`Status: fulfilled=${s.fulfilled}, finalized=${s.finalized}`)
+ *   })
+ *   console.log(`Done: ${final.status}, result: ${final.result}`)
+ * }
+ */
+export async function waitForAsyncRequest(
+  publicClient: PublicClient,
+  vault: Address,
+  guid: `0x${string}`,
+  pollInterval: number = 30_000,
+  timeout: number = 900_000,
+  onPoll?: (status: { fulfilled: boolean; finalized: boolean; refunded: boolean; result: bigint }) => void,
+): Promise<AsyncRequestFinalResult> {
+  const deadline = Date.now() + timeout
+
+  while (Date.now() < deadline) {
+    const status = await getAsyncRequestStatus(publicClient, vault, guid)
+
+    if (onPoll) onPoll(status)
+
+    if (status.finalized) {
+      return { status: 'completed', result: status.result }
+    }
+    if (status.refunded) {
+      return { status: 'refunded', result: 0n }
+    }
+
+    await new Promise(r => setTimeout(r, pollInterval))
+  }
+
+  throw new Error(
+    `[MoreVaults] Async request ${guid} did not finalize within ${timeout / 1000}s. ` +
+    `The request may still complete — check https://layerzeroscan.com/tx/${guid}`,
+  )
+}