@oydual31/more-vaults-sdk 0.2.2 → 0.2.4

package/dist/react/index.cjs

@@ -1741,6 +1741,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 = viem.getAddress(vault);
+  const u = viem.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 = viem.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) {
@@ -1815,6 +1924,15 @@ function useUserPosition(vault, user, chainId) {
     staleTime: 1e4
   });
 }
+function useUserPositionMultiChain(vault, user) {
+  return reactQuery.useQuery({
+    queryKey: ["userPositionMultiChain", vault, user],
+    queryFn: () => getUserPositionMultiChain(vault, user),
+    enabled: !!vault && !!user,
+    refetchInterval: 3e4,
+    staleTime: 15e3
+  });
+}
 function useLzFee(vault, chainId) {
   const publicClient = wagmi.usePublicClient({ chainId });
   const query = reactQuery.useQuery({
@@ -2039,9 +2157,12 @@ function useRedeemShares(vault, chainId) {
   };
 }
 function useVaultDistribution(vault) {
-  const chainId = wagmi.useChainId();
-  const publicClient = wagmi.usePublicClient();
-  const { topology } = useVaultTopology(vault);
+  const { data: topology } = reactQuery.useQuery({
+    queryKey: ["vaultTopology", vault],
+    queryFn: () => discoverVaultTopology(vault),
+    enabled: !!vault,
+    staleTime: 5 * 60 * 1e3
+  });
   const spokeClients = react.useMemo(() => {
     if (!topology) return {};
     const clients = {};
@@ -2052,13 +2173,13 @@ function useVaultDistribution(vault) {
     return clients;
   }, [topology]);
   const { data: distribution, isLoading } = reactQuery.useQuery({
-    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, vault, spokeClients);
+    },
+    enabled: !!vault && !!topology && topology.role !== "local",
     staleTime: 3e4
   });
   return { distribution, isLoading };
@@ -2145,6 +2266,7 @@ exports.useRedeemShares = useRedeemShares;
 exports.useSmartDeposit = useSmartDeposit;
 exports.useSmartRedeem = useSmartRedeem;
 exports.useUserPosition = useUserPosition;
+exports.useUserPositionMultiChain = useUserPositionMultiChain;
 exports.useVaultDistribution = useVaultDistribution;
 exports.useVaultMetadata = useVaultMetadata;
 exports.useVaultStatus = useVaultStatus;