@oydual31/more-vaults-sdk 0.2.1 → 0.2.3

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-BFI1m_zk.cjs';
+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 * as _tanstack_query_core from '@tanstack/query-core';
 import { Address } from 'viem';
 
@@ -250,14 +250,14 @@ interface UseVaultTopologyReturn {
     allChainIds: number[];
 }
 /**
- * Resolve the cross-chain topology of a vault from the current wallet chain.
+ * Resolve the cross-chain topology of a vault with automatic multi-chain discovery.
  *
- * Returns the hub chain, all spoke chains, and whether the user needs to
- * switch networks to interact with the hub.
- *
- * Since MoreVaults uses CREATE3, the vault address is the same on all chains.
+ * Uses `discoverVaultTopology` internally: if the wallet's current chain doesn't
+ * know the vault, it iterates all supported chains via public RPCs until the hub
+ * is found. Works even without a connected wallet.
  *
  * @example
+ * // Works regardless of which chain the wallet is on (or if disconnected)
  * const { topology, needsNetworkSwitch, allChainIds } = useVaultTopology('0xVAULT')
  *
  * if (needsNetworkSwitch) {
@@ -376,9 +376,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`.

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-BFI1m_zk.js';
+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 * as _tanstack_query_core from '@tanstack/query-core';
 import { Address } from 'viem';
 
@@ -250,14 +250,14 @@ interface UseVaultTopologyReturn {
     allChainIds: number[];
 }
 /**
- * Resolve the cross-chain topology of a vault from the current wallet chain.
+ * Resolve the cross-chain topology of a vault with automatic multi-chain discovery.
  *
- * Returns the hub chain, all spoke chains, and whether the user needs to
- * switch networks to interact with the hub.
- *
- * Since MoreVaults uses CREATE3, the vault address is the same on all chains.
+ * Uses `discoverVaultTopology` internally: if the wallet's current chain doesn't
+ * know the vault, it iterates all supported chains via public RPCs until the hub
+ * is found. Works even without a connected wallet.
  *
  * @example
+ * // Works regardless of which chain the wallet is on (or if disconnected)
  * const { topology, needsNetworkSwitch, allChainIds } = useVaultTopology('0xVAULT')
  *
  * if (needsNetworkSwitch) {
@@ -376,9 +376,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`.

package/dist/react/index.js

@@ -1029,84 +1029,6 @@ async function isAsyncMode(publicClient, vault) {
   });
   return !oraclesEnabled;
 }
-var OMNI_FACTORY_ADDRESS = "0x7bDB8B17604b03125eFAED33cA0c55FBf856BB0C";
-var FACTORY_ABI = [
-  {
-    name: "localEid",
-    type: "function",
-    inputs: [],
-    outputs: [{ type: "uint32" }],
-    stateMutability: "view"
-  },
-  {
-    name: "isCrossChainVault",
-    type: "function",
-    inputs: [{ name: "__eid", type: "uint32" }, { name: "_vault", type: "address" }],
-    outputs: [{ type: "bool" }],
-    stateMutability: "view"
-  },
-  {
-    name: "hubToSpokes",
-    type: "function",
-    inputs: [{ name: "__eid", type: "uint32" }, { name: "_hubVault", type: "address" }],
-    outputs: [{ name: "eids", type: "uint32[]" }, { name: "vaults", type: "address[]" }],
-    stateMutability: "view"
-  },
-  {
-    name: "spokeToHub",
-    type: "function",
-    inputs: [{ name: "__eid", type: "uint32" }, { name: "_spokeVault", type: "address" }],
-    outputs: [{ name: "eid", type: "uint32" }, { name: "vault", type: "address" }],
-    stateMutability: "view"
-  }
-];
-async function getVaultTopology(publicClient, vault, factoryAddress = OMNI_FACTORY_ADDRESS) {
-  const v = getAddress(vault);
-  const f = getAddress(factoryAddress);
-  const localEid = await publicClient.readContract({
-    address: f,
-    abi: FACTORY_ABI,
-    functionName: "localEid"
-  });
-  const isHub = await publicClient.readContract({
-    address: f,
-    abi: FACTORY_ABI,
-    functionName: "isCrossChainVault",
-    args: [localEid, v]
-  });
-  if (isHub) {
-    const [spokeEids] = await publicClient.readContract({
-      address: f,
-      abi: FACTORY_ABI,
-      functionName: "hubToSpokes",
-      args: [localEid, v]
-    });
-    const localChainId2 = EID_TO_CHAIN_ID[localEid] ?? Number(publicClient.chain?.id ?? 0);
-    const spokeChainIds = spokeEids.map((eid) => EID_TO_CHAIN_ID[eid]).filter((id) => id !== void 0);
-    return { role: "hub", hubChainId: localChainId2, spokeChainIds };
-  }
-  const [hubEid, hubVault] = await publicClient.readContract({
-    address: f,
-    abi: FACTORY_ABI,
-    functionName: "spokeToHub",
-    args: [localEid, v]
-  });
-  if (hubEid !== 0 && hubVault !== "0x0000000000000000000000000000000000000000") {
-    const hubChainId = EID_TO_CHAIN_ID[hubEid] ?? 0;
-    const spokeChainIds = [];
-    const localChainId2 = EID_TO_CHAIN_ID[localEid];
-    if (localChainId2 !== void 0) spokeChainIds.push(localChainId2);
-    return { role: "spoke", hubChainId, spokeChainIds };
-  }
-  const localChainId = EID_TO_CHAIN_ID[localEid] ?? Number(publicClient.chain?.id ?? 0);
-  return { role: "local", hubChainId: localChainId, spokeChainIds: [] };
-}
-function isOnHubChain(currentChainId, topology) {
-  return currentChainId === topology.hubChainId;
-}
-function getAllVaultChainIds(topology) {
-  return [topology.hubChainId, ...topology.spokeChainIds];
-}
 var PUBLIC_RPCS = {
   1: [
     "https://ethereum-rpc.publicnode.com",
@@ -1297,6 +1219,144 @@ async function getUserBalancesForRoutes(routes, userAddress) {
   );
 }
 
+// src/viem/topology.ts
+var OMNI_FACTORY_ADDRESS = "0x7bDB8B17604b03125eFAED33cA0c55FBf856BB0C";
+var FACTORY_ABI = [
+  {
+    name: "localEid",
+    type: "function",
+    inputs: [],
+    outputs: [{ type: "uint32" }],
+    stateMutability: "view"
+  },
+  {
+    name: "isCrossChainVault",
+    type: "function",
+    inputs: [{ name: "__eid", type: "uint32" }, { name: "_vault", type: "address" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    name: "hubToSpokes",
+    type: "function",
+    inputs: [{ name: "__eid", type: "uint32" }, { name: "_hubVault", type: "address" }],
+    outputs: [{ name: "eids", type: "uint32[]" }, { name: "vaults", type: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    name: "spokeToHub",
+    type: "function",
+    inputs: [{ name: "__eid", type: "uint32" }, { name: "_spokeVault", type: "address" }],
+    outputs: [{ name: "eid", type: "uint32" }, { name: "vault", type: "address" }],
+    stateMutability: "view"
+  }
+];
+async function getVaultTopology(publicClient, vault, factoryAddress = OMNI_FACTORY_ADDRESS) {
+  const v = getAddress(vault);
+  const f = getAddress(factoryAddress);
+  const localEid = await publicClient.readContract({
+    address: f,
+    abi: FACTORY_ABI,
+    functionName: "localEid"
+  });
+  const isHub = await publicClient.readContract({
+    address: f,
+    abi: FACTORY_ABI,
+    functionName: "isCrossChainVault",
+    args: [localEid, v]
+  });
+  if (isHub) {
+    const [spokeEids] = await publicClient.readContract({
+      address: f,
+      abi: FACTORY_ABI,
+      functionName: "hubToSpokes",
+      args: [localEid, v]
+    });
+    const localChainId2 = EID_TO_CHAIN_ID[localEid] ?? Number(publicClient.chain?.id ?? 0);
+    const spokeChainIds = spokeEids.map((eid) => EID_TO_CHAIN_ID[eid]).filter((id) => id !== void 0);
+    return { role: "hub", hubChainId: localChainId2, spokeChainIds };
+  }
+  const [hubEid, hubVault] = await publicClient.readContract({
+    address: f,
+    abi: FACTORY_ABI,
+    functionName: "spokeToHub",
+    args: [localEid, v]
+  });
+  if (hubEid !== 0 && hubVault !== "0x0000000000000000000000000000000000000000") {
+    const hubChainId = EID_TO_CHAIN_ID[hubEid] ?? 0;
+    const spokeChainIds = [];
+    const localChainId2 = EID_TO_CHAIN_ID[localEid];
+    if (localChainId2 !== void 0) spokeChainIds.push(localChainId2);
+    return { role: "spoke", hubChainId, spokeChainIds };
+  }
+  const localChainId = EID_TO_CHAIN_ID[localEid] ?? Number(publicClient.chain?.id ?? 0);
+  return { role: "local", hubChainId: localChainId, spokeChainIds: [] };
+}
+async function getFullVaultTopology(hubChainClient, vault, factoryAddress = OMNI_FACTORY_ADDRESS) {
+  const topo = await getVaultTopology(hubChainClient, vault, factoryAddress);
+  if (topo.role !== "hub") {
+    throw new Error(
+      `getFullVaultTopology: client must be connected to the hub chain (${topo.hubChainId}), but got role="${topo.role}". Connect to chainId ${topo.hubChainId} instead.`
+    );
+  }
+  return topo;
+}
+var DISCOVERY_CHAIN_IDS = Object.values(CHAIN_IDS).filter(
+  (id) => id !== 545
+  // exclude testnet
+);
+async function discoverVaultTopology(vault, publicClient, factoryAddress = OMNI_FACTORY_ADDRESS) {
+  const v = getAddress(vault);
+  let triedChainId;
+  if (publicClient) {
+    try {
+      const topo = await getVaultTopology(publicClient, v, factoryAddress);
+      if (topo.role !== "local") {
+        if (topo.role === "spoke") {
+          const hubClient = createChainClient(topo.hubChainId);
+          if (hubClient) {
+            try {
+              return await getFullVaultTopology(hubClient, v, factoryAddress);
+            } catch {
+            }
+          }
+        }
+        return topo;
+      }
+      triedChainId = publicClient.chain?.id;
+    } catch {
+    }
+  }
+  for (const chainId of DISCOVERY_CHAIN_IDS) {
+    if (chainId === triedChainId) continue;
+    const client = createChainClient(chainId);
+    if (!client) continue;
+    try {
+      const topo = await getVaultTopology(client, v, factoryAddress);
+      if (topo.role === "hub") return topo;
+      if (topo.role === "spoke") {
+        const hubClient = createChainClient(topo.hubChainId);
+        if (hubClient) {
+          try {
+            return await getFullVaultTopology(hubClient, v, factoryAddress);
+          } catch {
+            return topo;
+          }
+        }
+        return topo;
+      }
+    } catch {
+    }
+  }
+  return { role: "local", hubChainId: 0, spokeChainIds: [] };
+}
+function isOnHubChain(currentChainId, topology) {
+  return currentChainId === topology.hubChainId;
+}
+function getAllVaultChainIds(topology) {
+  return [topology.hubChainId, ...topology.spokeChainIds];
+}
+
 // src/viem/preflight.ts
 async function preflightAsync(publicClient, vault, escrow) {
   const v = getAddress(vault);
@@ -1785,9 +1845,14 @@ function useVaultTopology(vault, factoryAddress = OMNI_FACTORY_ADDRESS) {
   const currentChainId = useChainId();
   const publicClient = usePublicClient();
   const { data: topology, isLoading } = useQuery({
-    queryKey: ["vaultTopology", vault, currentChainId, factoryAddress],
-    queryFn: () => getVaultTopology(asSdkClient(publicClient), vault, factoryAddress),
-    enabled: !!vault && !!publicClient,
+    // Key does NOT include currentChainId — topology is chain-independent
+    queryKey: ["vaultTopology", vault, factoryAddress],
+    queryFn: () => discoverVaultTopology(
+      vault,
+      publicClient ? asSdkClient(publicClient) : null,
+      factoryAddress
+    ),
+    enabled: !!vault,
     staleTime: 5 * 60 * 1e3
     // topology rarely changes — 5 min cache
   });
@@ -1972,9 +2037,12 @@ function useRedeemShares(vault, chainId) {
   };
 }
 function useVaultDistribution(vault) {
-  const chainId = useChainId();
-  const publicClient = usePublicClient();
-  const { topology } = useVaultTopology(vault);
+  const { data: topology } = useQuery({
+    queryKey: ["vaultTopology", vault],
+    queryFn: () => discoverVaultTopology(vault),
+    enabled: !!vault,
+    staleTime: 5 * 60 * 1e3
+  });
   const spokeClients = useMemo(() => {
     if (!topology) return {};
     const clients = {};
@@ -1985,13 +2053,13 @@ function useVaultDistribution(vault) {
     return clients;
   }, [topology]);
   const { data: distribution, isLoading } = 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 };