@veridex/sdk 1.0.0-beta.1 → 1.0.0-beta.4

package/dist/index.mjs

@@ -2786,7 +2786,7 @@ var DEFAULT_CONFIG2 = {
   timeoutMs: 3e4,
   maxRetries: 3
 };
-var RelayerClient = class {
+var RelayerClient = class _RelayerClient {
   baseUrl;
   config;
   constructor(config) {
@@ -3010,12 +3010,17 @@ var RelayerClient = class {
   // ========================================================================
   // Internal Helpers
   // ========================================================================
+  /**
+   * SDK version for telemetry
+   */
+  static SDK_VERSION = "1.0.0-beta.1";
   /**
    * Make an HTTP request to the relayer
    */
   async fetch(path, options = {}) {
     const headers = {
       "Content-Type": "application/json",
+      "User-Agent": `@veridex/sdk/${_RelayerClient.SDK_VERSION}`,
       ...options.headers || {}
     };
     if (this.config.apiKey) {
@@ -3847,27 +3852,41 @@ var AptosClient = class {
       targetChain
     };
   }
+  /**
+   * Get vault address from on-chain VaultRegistry.
+   * Queries the get_vault_address view function which looks up the vault in the registry.
+   */
   async getVaultAddress(userKeyHash) {
     try {
-      const vaultAddress = this.computeVaultAddressFromHash(userKeyHash);
-      const account = await this.client.getAccount(vaultAddress);
-      if (account) {
+      const keyHashBytes = this.hexToBytes(userKeyHash.replace("0x", "").padStart(64, "0"));
+      const payload = {
+        function: `${this.moduleAddress}::veridex_spoke::get_vault_address`,
+        type_arguments: [],
+        arguments: [Array.from(keyHashBytes)]
+      };
+      const response = await this.client.view(payload);
+      if (response && response.length > 0) {
+        const vaultAddress = response[0];
         return vaultAddress;
       }
       return null;
     } catch (error) {
-      if (error?.status === 404) {
+      if (error?.message?.includes("E_VAULT_NOT_FOUND") || error?.message?.includes("error code 6") || error?.status === 404) {
         return null;
       }
-      console.error("Error getting vault address:", error);
+      console.error("Error getting vault address from registry:", error);
       return null;
     }
   }
   /**
-   * Compute vault address using resource account derivation
-   * On Aptos, vaults are derived from the module address + user key hash
+   * @deprecated Use getVaultAddress() instead - this method uses incorrect address derivation.
+   * On Aptos, vaults are created as named objects by the relayer, not resource accounts.
+   * The vault address depends on which relayer created it, so must be queried on-chain.
    */
   computeVaultAddress(userKeyHash) {
+    console.warn(
+      "computeVaultAddress() is deprecated for Aptos. Use getVaultAddress() to query the on-chain VaultRegistry instead."
+    );
     return this.computeVaultAddressFromHash(userKeyHash);
   }
   computeVaultAddressFromHash(userKeyHash) {
@@ -9067,6 +9086,93 @@ var VeridexSDK = class {
   getVaultAddressForKeyHash(keyHash) {
     return this.chain.computeVaultAddress(keyHash);
   }
+  /**
+   * Get the vault address for a specific chain
+   * Each EVM chain has its own factory contract, so vault addresses are chain-specific.
+   * 
+   * @param wormholeChainId - The Wormhole chain ID
+   * @param keyHash - Optional key hash (defaults to current credential)
+   * @returns The deterministic vault address for that chain, or null if chain not supported
+   */
+  getVaultAddressForChain(wormholeChainId, keyHash) {
+    const hash = keyHash ?? this.passkey.getCredential()?.keyHash;
+    if (!hash) {
+      throw new Error("No credential set and no keyHash provided");
+    }
+    const credential = { keyHash: hash };
+    const derived = this.chainDetector.deriveVaultAddress(credential, wormholeChainId);
+    return derived?.address ?? null;
+  }
+  /**
+   * Get vault balances for a specific chain
+   * Unlike getVaultBalances() which uses the hub chain, this fetches for any EVM chain.
+   * 
+   * @param wormholeChainId - The Wormhole chain ID
+   * @param includeZeroBalances - Whether to include tokens with 0 balance
+   * @returns PortfolioBalance with all token balances for that chain
+   */
+  async getVaultBalancesForChain(wormholeChainId, includeZeroBalances = false) {
+    const credential = this.passkey.getCredential();
+    if (!credential) {
+      throw new Error("No credential set");
+    }
+    const vaultAddress = this.getVaultAddressForChain(wormholeChainId, credential.keyHash);
+    if (!vaultAddress) {
+      throw new Error(`Cannot derive vault address for chain ${wormholeChainId}`);
+    }
+    const chainConfig = this.chainDetector.getChainConfig(wormholeChainId);
+    if (!chainConfig) {
+      throw new Error(`Unknown chain ${wormholeChainId}`);
+    }
+    if (this.queryApiKey) {
+      try {
+        const tokenList = getAllTokens(wormholeChainId);
+        const erc20Tokens = tokenList.filter((t) => !isNativeToken(t.address)).map((t) => t.address);
+        const rpcUrl = this.chainRpcUrls?.[wormholeChainId] ?? chainConfig.rpcUrl;
+        const result = await queryPortfolio(credential.keyHash, this.queryApiKey, {
+          network: this.testnet ? "testnet" : "mainnet",
+          vaultAddresses: { [wormholeChainId]: vaultAddress },
+          evmTokenAddresses: { [wormholeChainId]: erc20Tokens },
+          rpcUrls: { [wormholeChainId]: rpcUrl },
+          maxAge: 60,
+          timeout: this.testnet ? 15e3 : 1e4,
+          maxAttempts: this.testnet ? 3 : 2
+        });
+        const chain = result.chains.find((c) => c.wormholeChainId === wormholeChainId);
+        if (chain && !chain.error) {
+          const byAssetId = new Map(chain.balances.map((b) => [b.assetId.toLowerCase(), b]));
+          const tokens = tokenList.map((t) => {
+            if (isNativeToken(t.address)) {
+              return null;
+            }
+            const found = byAssetId.get(t.address.toLowerCase());
+            const amount = found?.amount ?? 0n;
+            const formatted = ethers15.formatUnits(amount, t.decimals);
+            return {
+              token: t,
+              balance: amount,
+              formatted,
+              usdValue: found?.usdValue
+            };
+          }).filter((t) => !!t);
+          const native = await this.balance.getNativeBalance(wormholeChainId, vaultAddress);
+          const merged = [native, ...tokens];
+          const filtered = includeZeroBalances ? merged : merged.filter((t) => t.balance > 0n);
+          const totalUsdValue = filtered.reduce((sum, t) => sum + (t.usdValue ?? 0), 0);
+          return {
+            wormholeChainId,
+            chainName: chainConfig.name,
+            address: vaultAddress,
+            tokens: filtered,
+            totalUsdValue: totalUsdValue || void 0,
+            lastUpdated: Date.now()
+          };
+        }
+      } catch {
+      }
+    }
+    return await this.balance.getPortfolioBalance(wormholeChainId, vaultAddress, includeZeroBalances);
+  }
   /**
    * Get unified identity with addresses across chains
    *