@oydual31/more-vaults-sdk 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oydual31/more-vaults-sdk",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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/react/useVaultDistribution.ts

@@ -1,12 +1,11 @@
 import { useMemo } from 'react'
 import { useQuery } from '@tanstack/react-query'
-import { useChainId, usePublicClient } from 'wagmi'
 import type { Address, PublicClient } from 'viem'
-import { asSdkClient } from '../viem/wagmiCompat.js'
 import { getVaultDistribution } from '../viem/distribution.js'
 import type { VaultDistribution } from '../viem/distribution.js'
 import { createChainClient } from '../viem/spokeRoutes.js'
-import { useVaultTopology } from './useVaultTopology.js'
+import { discoverVaultTopology } from '../viem/topology.js'
+import type { VaultTopology } from '../viem/topology.js'
 
 export type { VaultDistribution }
 
@@ -18,9 +17,9 @@ interface UseVaultDistributionReturn {
 /**
  * Read the full cross-chain capital distribution of a vault.
  *
- * Uses the connected wallet's chain as the hub client (via wagmi),
- * discovers spoke chains via topology, and creates ephemeral public
- * clients with fallback RPCs for spoke reads (all supported chains covered).
+ * Discovers the vault topology automatically via `discoverVaultTopology`
+ * (works without a connected wallet), then creates hub and spoke clients
+ * via public RPCs.
  *
  * Spoke reads that fail (bad RPC, timeout) degrade gracefully —
  * those spokes will appear with `isReachable: false`.
@@ -37,13 +36,15 @@ interface UseVaultDistributionReturn {
 export function useVaultDistribution(
   vault: Address | undefined,
 ): UseVaultDistributionReturn {
-  const chainId = useChainId()
-  const publicClient = usePublicClient()
-  const { topology } = useVaultTopology(vault)
+  // Step 1: discover topology (wallet-independent)
+  const { data: topology } = useQuery<VaultTopology>({
+    queryKey: ['vaultTopology', vault],
+    queryFn: () => discoverVaultTopology(vault!),
+    enabled: !!vault,
+    staleTime: 5 * 60 * 1000,
+  })
 
-  // Build spoke clients using the shared fallback-RPC factory from spokeRoutes.
-  // Covers all supported chains (Eth, Arb, Op, BSC, Sonic, Flow) with multiple
-  // fallback endpoints each — spokes without a known RPC degrade to isReachable: false.
+  // Build spoke clients from topology
   const spokeClients = useMemo((): Record<number, PublicClient> => {
     if (!topology) return {}
     const clients: Record<number, PublicClient> = {}
@@ -54,15 +55,15 @@ export function useVaultDistribution(
     return clients
   }, [topology])
 
+  // Step 2: fetch distribution using hub-chain client (not wallet client)
   const { data: distribution, isLoading } = useQuery<VaultDistribution>({
-    queryKey: ['vaultDistribution', vault, chainId],
-    queryFn: () =>
-      getVaultDistribution(
-        asSdkClient(publicClient),
-        vault!,
-        spokeClients,
-      ),
-    enabled: !!vault && !!publicClient,
+    queryKey: ['vaultDistribution', vault, topology?.hubChainId],
+    queryFn: () => {
+      const hubClient = createChainClient(topology!.hubChainId)
+      if (!hubClient) throw new Error(`No public RPC for hub chainId ${topology!.hubChainId}`)
+      return getVaultDistribution(hubClient as PublicClient, vault!, spokeClients)
+    },
+    enabled: !!vault && !!topology && topology.role !== 'local',
     staleTime: 30_000,
   })
 

package/src/viem/index.ts

@@ -101,6 +101,7 @@ export {
   getUserBalances,
   getMaxWithdrawable,
   getVaultSummary,
+  getUserPositionMultiChain,
 } from './userHelpers'
 export type {
   UserPosition,
@@ -112,6 +113,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,
+  }
+}