@oydual31/more-vaults-sdk 0.2.3 → 0.2.5

package/dist/react/index.d.cts

@@ -1,5 +1,5 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { h as VaultStatus, f as VaultMetadata, e as UserPosition, a as AsyncRequestStatusInfo, j as VaultTopology, V as VaultDistribution, c as InboundRouteWithBalance } from '../spokeRoutes-CK5NSOOF.cjs';
+import { j as VaultStatus, h as VaultMetadata, g as UserPosition, e as MultiChainUserPosition, b as AsyncRequestStatusInfo, l as VaultTopology, V as VaultDistribution, d as InboundRouteWithBalance } from '../spokeRoutes-z7s_5ooO.cjs';
 import * as _tanstack_query_core from '@tanstack/query-core';
 import { Address } from 'viem';
 
@@ -37,6 +37,23 @@ declare function useVaultMetadata(vault: `0x${string}` | undefined, chainId: num
  */
 declare function useUserPosition(vault: `0x${string}` | undefined, user: `0x${string}` | undefined, chainId: number): _tanstack_react_query.UseQueryResult<UserPosition, Error>;
 
+/**
+ * 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
+ */
+declare function useUserPositionMultiChain(vault: `0x${string}` | undefined, user: `0x${string}` | undefined): _tanstack_react_query.UseQueryResult<MultiChainUserPosition, Error>;
+
 /**
  * Quote the LayerZero fee required for async operations (D4, D5, R5).
  * Refreshes every 60s — fees change with network congestion.
@@ -519,4 +536,4 @@ declare function getRouteTokenDecimals(symbol: string): number;
  */
 declare function useInboundRoutes(hubChainId: number | undefined, vault: Address | undefined, vaultAsset: Address | undefined, userAddress: Address | undefined): UseInboundRoutesReturn;
 
-export { AsyncRequestStatusInfo, UserPosition, VaultMetadata, VaultStatus, VaultTopology, getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };
+export { AsyncRequestStatusInfo, MultiChainUserPosition, UserPosition, VaultMetadata, VaultStatus, VaultTopology, getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useUserPositionMultiChain, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { h as VaultStatus, f as VaultMetadata, e as UserPosition, a as AsyncRequestStatusInfo, j as VaultTopology, V as VaultDistribution, c as InboundRouteWithBalance } from '../spokeRoutes-CK5NSOOF.js';
+import { j as VaultStatus, h as VaultMetadata, g as UserPosition, e as MultiChainUserPosition, b as AsyncRequestStatusInfo, l as VaultTopology, V as VaultDistribution, d as InboundRouteWithBalance } from '../spokeRoutes-z7s_5ooO.js';
 import * as _tanstack_query_core from '@tanstack/query-core';
 import { Address } from 'viem';
 
@@ -37,6 +37,23 @@ declare function useVaultMetadata(vault: `0x${string}` | undefined, chainId: num
  */
 declare function useUserPosition(vault: `0x${string}` | undefined, user: `0x${string}` | undefined, chainId: number): _tanstack_react_query.UseQueryResult<UserPosition, Error>;
 
+/**
+ * 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
+ */
+declare function useUserPositionMultiChain(vault: `0x${string}` | undefined, user: `0x${string}` | undefined): _tanstack_react_query.UseQueryResult<MultiChainUserPosition, Error>;
+
 /**
  * Quote the LayerZero fee required for async operations (D4, D5, R5).
  * Refreshes every 60s — fees change with network congestion.
@@ -519,4 +536,4 @@ declare function getRouteTokenDecimals(symbol: string): number;
  */
 declare function useInboundRoutes(hubChainId: number | undefined, vault: Address | undefined, vaultAsset: Address | undefined, userAddress: Address | undefined): UseInboundRoutesReturn;
 
-export { AsyncRequestStatusInfo, UserPosition, VaultMetadata, VaultStatus, VaultTopology, getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };
+export { AsyncRequestStatusInfo, MultiChainUserPosition, UserPosition, VaultMetadata, VaultStatus, VaultTopology, getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useUserPositionMultiChain, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };

package/dist/react/index.js

@@ -1739,6 +1739,115 @@ async function getAsyncRequestStatusLabel(publicClient, vault, guid) {
     result: 0n
   };
 }
+var FACTORY_COMPOSER_ABI = [
+  {
+    type: "function",
+    name: "vaultComposer",
+    inputs: [{ name: "_vault", type: "address" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  }
+];
+var COMPOSER_SHARE_OFT_ABI = [
+  {
+    type: "function",
+    name: "SHARE_OFT",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  }
+];
+async function getUserPositionMultiChain(vault, user) {
+  const v = getAddress(vault);
+  const u = getAddress(user);
+  const topo = await discoverVaultTopology(vault);
+  const hubClient = createChainClient(topo.hubChainId);
+  if (!hubClient) throw new Error(`No public RPC for hub chainId ${topo.hubChainId}`);
+  const [hubShares, decimals, withdrawalRequest] = await hubClient.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;
+  const spokeShares = {};
+  if (topo.spokeChainIds.length > 0) {
+    let hubShareOft = null;
+    try {
+      const composerAddress = await hubClient.readContract({
+        address: OMNI_FACTORY_ADDRESS,
+        abi: FACTORY_COMPOSER_ABI,
+        functionName: "vaultComposer",
+        args: [v]
+      });
+      if (composerAddress !== "0x0000000000000000000000000000000000000000") {
+        hubShareOft = await hubClient.readContract({
+          address: composerAddress,
+          abi: COMPOSER_SHARE_OFT_ABI,
+          functionName: "SHARE_OFT"
+        });
+      }
+    } catch {
+    }
+    if (hubShareOft) {
+      const spokePromises = topo.spokeChainIds.map(async (spokeChainId) => {
+        try {
+          const spokeEid = CHAIN_ID_TO_EID[spokeChainId];
+          if (!spokeEid) return { chainId: spokeChainId, balance: 0n };
+          const spokeOftBytes32 = await hubClient.readContract({
+            address: hubShareOft,
+            abi: OFT_ABI,
+            functionName: "peers",
+            args: [spokeEid]
+          });
+          const spokeOft = getAddress(`0x${spokeOftBytes32.slice(-40)}`);
+          if (spokeOft === "0x0000000000000000000000000000000000000000") {
+            return { chainId: spokeChainId, balance: 0n };
+          }
+          const spokeClient = createChainClient(spokeChainId);
+          if (!spokeClient) return { chainId: spokeChainId, balance: 0n };
+          const balance = await spokeClient.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;
+      }
+    }
+  }
+  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.readContract({ address: v, abi: VAULT_ABI, functionName: "convertToAssets", args: [totalShares] }),
+    hubClient.readContract({ address: v, abi: VAULT_ABI, functionName: "convertToAssets", args: [oneShare] })
+  ]);
+  const block = await hubClient.getBlock();
+  const pendingWithdrawal = withdrawShares === 0n ? null : {
+    shares: withdrawShares,
+    timelockEndsAt,
+    canRedeemNow: timelockEndsAt === 0n || block.timestamp >= timelockEndsAt
+  };
+  return {
+    hubShares,
+    spokeShares,
+    totalShares,
+    estimatedAssets,
+    sharePrice,
+    decimals,
+    pendingWithdrawal
+  };
+}
 
 // src/viem/distribution.ts
 async function getVaultDistribution(hubClient, vault, spokeClients) {
@@ -1813,6 +1922,15 @@ function useUserPosition(vault, user, chainId) {
     staleTime: 1e4
   });
 }
+function useUserPositionMultiChain(vault, user) {
+  return useQuery({
+    queryKey: ["userPositionMultiChain", vault, user],
+    queryFn: () => getUserPositionMultiChain(vault, user),
+    enabled: !!vault && !!user,
+    refetchInterval: 3e4,
+    staleTime: 15e3
+  });
+}
 function useLzFee(vault, chainId) {
   const publicClient = usePublicClient({ chainId });
   const query = useQuery({
@@ -2135,6 +2253,6 @@ function useInboundRoutes(hubChainId, vault, vaultAsset, userAddress) {
   };
 }
 
-export { getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };
+export { getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useUserPositionMultiChain, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map