@deserialize/multi-vm-wallet 1.5.35 → 1.6.1

package/utils/savings/savings-operations.ts

@@ -44,7 +44,7 @@ import { EVMDeriveChildPrivateKey, mnemonicToSeed } from "../walletBip32";
 export interface TransferFromPocketOptions {
     /** Wallet index in derivation path (default: 0) */
     walletIndex?: number;
-    /** Account/pocket index to transfer from (1-based, 0 is main wallet) */
+    /** Pocket index to transfer from (0-based) */
     accountIndex: number;
     /** Destination address */
     to: string;
@@ -76,7 +76,7 @@ export interface TransferTokenFromPocketOptions extends Omit<TransferFromPocketO
 export interface GetPocketBalanceOptions {
     /** Wallet index in derivation path (default: 0) */
     walletIndex?: number;
-    /** Account/pocket index (1-based, 0 is main wallet) */
+    /** Pocket index (0-based) */
     accountIndex: number;
 }
 
@@ -129,7 +129,7 @@ export class SavingsOperations {
      * Derives a savings pocket wallet from mnemonic
      *
      * @param mnemonic - BIP-39 mnemonic phrase
-     * @param accountIndex - Account/pocket index (1-based, 0 is main wallet)
+     * @param accountIndex - Pocket index (0-based)
      * @param walletIndex - Wallet index (default: 0)
      * @param provider - RPC provider to connect wallet to
      * @returns Derived wallet, address, and cleanup function
@@ -137,7 +137,7 @@ export class SavingsOperations {
      * @remarks
      * IMPORTANT: Always call cleanup() when done with the wallet to zero out private key
      *
-     * Derivation path: m/44'/60'/{accountIndex}'/0/{walletIndex}'
+     * Derivation path: m/44'/60'/{accountIndex + 1}'/0/{walletIndex}'
      *
      * @throws Error if validation fails
      *
@@ -154,9 +154,10 @@ export class SavingsOperations {
         SavingsValidation.validateAccountIndex(accountIndex);
         SavingsValidation.validateWalletIndex(walletIndex);
 
-        // Derive pocket private key
+        // Derive pocket private key (account 0 is main wallet, so pockets start at +1)
+        const pocketIndex = accountIndex + 1;
         const seed = mnemonicToSeed(mnemonic);
-        const { privateKey } = EVMDeriveChildPrivateKey(seed, walletIndex, `m/44'/60'/${accountIndex}'/`);
+        const { privateKey } = EVMDeriveChildPrivateKey(seed, walletIndex, `m/44'/60'/${pocketIndex}'/0/`);
 
         // Create wallet
         const wallet = new Wallet(privateKey, provider);
@@ -473,7 +474,7 @@ export class SavingsOperations {
      * Get the address of a savings pocket without storing credentials
      *
      * @param mnemonic - BIP-39 mnemonic phrase
-     * @param accountIndex - Account/pocket index
+     * @param accountIndex - Pocket index (0-based)
      * @param walletIndex - Wallet index (default: 0)
      * @returns Pocket address
      *
@@ -495,9 +496,10 @@ export class SavingsOperations {
         SavingsValidation.validateAccountIndex(accountIndex);
         SavingsValidation.validateWalletIndex(walletIndex);
 
-        // Derive address
+        // Derive address (account 0 is main wallet, so pockets start at +1)
+        const pocketIndex = accountIndex + 1;
         const seed = mnemonicToSeed(mnemonic);
-        const { privateKey } = EVMDeriveChildPrivateKey(seed, walletIndex, `m/44'/60'/${accountIndex}'/`);
+        const { privateKey } = EVMDeriveChildPrivateKey(seed, walletIndex, `m/44'/60'/${pocketIndex}'/0/`);
         const wallet = new Wallet(privateKey);
         const address = wallet.address;
 

package/utils/savings/svm-savings.ts

@@ -98,6 +98,13 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
         this._client = undefined;
     }
 
+    private toSafeNumberAmount(amount: bigint, label: string): number {
+        if (amount > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new Error(`${label} exceeds Number.MAX_SAFE_INTEGER and cannot be represented safely: ${amount}`);
+        }
+        return Number(amount);
+    }
+
     /**
      * Derive a savings pocket at the specified account index
      *
@@ -110,9 +117,10 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
 
         // Add 1 to preserve index 0 for main wallet
         const pocketIndex = accountIndex + 1;
-        const derivationPath = `${this.derivationPathBase}${pocketIndex}'/0/${this.walletIndex}`;
+        const derivationPathBase = `${this.derivationPathBase}${pocketIndex}'/0/`;
+        const derivationPath = `${derivationPathBase}${this.walletIndex}'`;
         const seed = mnemonicToSeed(this.mnemonic);
-        const keypair = SVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPath);
+        const keypair = SVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPathBase);
 
         const pocket: Pocket<PublicKey> = {
             privateKey: keypair,
@@ -132,9 +140,10 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
      */
     getMainWallet() {
         this.checkNotDisposed();
-        const derivationPath = `${this.derivationPathBase}0'/0/${this.walletIndex}`;
+        const derivationPathBase = `${this.derivationPathBase}0'/0/`;
+        const derivationPath = `${derivationPathBase}${this.walletIndex}'`;
         const seed = mnemonicToSeed(this.mnemonic);
-        const keypair = SVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPath);
+        const keypair = SVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPathBase);
 
         return {
             privateKey: keypair,
@@ -262,7 +271,7 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
         const tx = await getTransferNativeTransaction(
             mainWallet,
             pocket.address,
-            Number(amount),
+            this.toSafeNumberAmount(amount, 'Native transfer amount'),
             this.client
         );
 
@@ -297,7 +306,7 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
             mainWallet,
             pocket.address,
             tokenInfo as any,  // TokenInfo type
-            Number(amount),
+            this.toSafeNumberAmount(amount, 'Token transfer amount'),
             this.client
         );
 
@@ -365,7 +374,7 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
             const tx = await getTransferNativeTransaction(
                 pocket.privateKey,
                 mainWalletAddress,
-                Number(amount),
+                this.toSafeNumberAmount(amount, 'Native withdrawal amount'),
                 this.client
             );
             const hash = await signAndSendTransaction(tx, this.client, pocket.privateKey);
@@ -376,7 +385,7 @@ export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Key
             pocket.privateKey,
             mainWalletAddress,
             token as any,  // TokenInfo type
-            Number(amount),
+            this.toSafeNumberAmount(amount, 'Token withdrawal amount'),
             this.client
         );
 

package/utils/test.ts

@@ -399,7 +399,7 @@ const testAddressClass = async () => {
     const evmAddressClass = new EVMChainAddress(evmChainConfig, "0xC9C1D854b82BA9b4FB6f6D58E9EF3d1fAEd601AA", 0)
     const res = await evmAddressClass.getNativeBalance()
     console.log('res: ', res);
-
+SVMVM.generateMnemonicFromPrivateKey
     // const svmAddressClass = new SVMChainAddress( )
 }
 testAddressClass()

package/utils/types.ts

@@ -25,7 +25,8 @@ export interface ChainWalletConfig {
 }
 
 export interface ChainSavingConfig {
-    tokens: string[]; // List of token addresses to track for savings
+    supported: boolean; // Whether savings tracking is supported on this chain
+    tokens: TokenInfo[]; // List of token addresses to track for savings
 
 }
 

package/utils/utils.ts

@@ -1,7 +1,13 @@
-import { EVMVM, getNativeBalance } from "./evm";
+import { EVMVM } from "./evm";
 import { SVMVM } from "./svm";
 import { ChainWalletConfig, vmTypes } from "./types";
 import { sha256 } from "@noble/hashes/sha2";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { createPublicClientFromChainConfig, discoverTokens as discoverEvmTokens, getNativeBalance as getEvmNativeBalance, getTokenBalance as getEvmTokenBalance } from "./evm/utils";
+import { discoverTokens as discoverSvmTokens, getSvmNativeBalance } from "./svm/utils";
+import { Hex } from "viem";
+import BN from "bn.js";
+import { fetchPrices } from "./price";
 
 
 export const getPrivateKeyFromAnother = (privateKey: any, fromVm: vmTypes, toVm: vmTypes) => {
@@ -20,8 +26,248 @@ export const getPrivateKeyFromAnother = (privateKey: any, fromVm: vmTypes, toVm:
 }
 
 
-//TODO: 
+export interface AddressPortfolioItem {
+    tokenAddress: string | "native";
+    symbol: string;
+    decimals: number;
+    balanceRaw: string;
+    balanceFormatted: number;
+    priceUsd: number | null;
+    valueUsd: number | null;
+}
+
+export interface AddressPortfolioResult {
+    address: string;
+    vmType: vmTypes;
+    chainId: number;
+    items: AddressPortfolioItem[];
+    totals: {
+        valueUsd: number;
+        pricedItems: number;
+        unpricedItems: number;
+    };
+}
+
+export interface AddressPortfolioParams {
+    chain: ChainWalletConfig;
+    address: string;
+    vmType?: vmTypes;
+    includeNative?: boolean;
+    tokenAddresses?: string[];
+}
+
+const EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+
+export const detectVmTypeFromAddress = (address: string): vmTypes => {
+    if (EVM_ADDRESS_REGEX.test(address)) {
+        return "EVM";
+    }
+
+    try {
+        new PublicKey(address);
+        return "SVM";
+    } catch {
+        throw new Error(`Could not infer VM type from address: ${address}`);
+    }
+};
+
+const normalizePriceMap = (prices: Array<{ tokenAddress: string; price: number }>) => {
+    const priceMap = new Map<string, number>();
+    for (const item of prices) {
+        if (!item?.tokenAddress || typeof item.price !== "number") continue;
+        priceMap.set(item.tokenAddress.toLowerCase(), item.price);
+    }
+    return priceMap;
+};
+
+const enrichWithUsdValues = (
+    items: Omit<AddressPortfolioItem, "priceUsd" | "valueUsd">[],
+    priceMap: Map<string, number>
+): AddressPortfolioResult["items"] => {
+    return items.map((item) => {
+        const key = String(item.tokenAddress).toLowerCase();
+        const priceUsd = priceMap.get(key) ?? null;
+        const valueUsd = priceUsd === null ? null : item.balanceFormatted * priceUsd;
+
+        return {
+            ...item,
+            priceUsd,
+            valueUsd,
+        };
+    });
+};
+
+const buildTotals = (items: AddressPortfolioItem[]) => {
+    let valueUsd = 0;
+    let pricedItems = 0;
+    let unpricedItems = 0;
+
+    for (const item of items) {
+        if (item.valueUsd === null) {
+            unpricedItems += 1;
+            continue;
+        }
+        pricedItems += 1;
+        valueUsd += item.valueUsd;
+    }
+
+    return { valueUsd, pricedItems, unpricedItems };
+};
+
+export const getAddressPortfolioValue = async (params: AddressPortfolioParams): Promise<AddressPortfolioResult> => {
+    const { chain, address, includeNative = true, tokenAddresses } = params;
+    const vmType = params.vmType ?? detectVmTypeFromAddress(address);
+
+    if (vmType === "EVM" && !EVM_ADDRESS_REGEX.test(address)) {
+        throw new Error(`Invalid EVM address: ${address}`);
+    }
+    if (vmType === "SVM") {
+        // Throws if invalid
+        new PublicKey(address);
+    }
+
+    if (vmType === "EVM") {
+        const client = createPublicClientFromChainConfig(chain);
+
+        const items: Omit<AddressPortfolioItem, "priceUsd" | "valueUsd">[] = [];
+        const priceTargets = new Set<string>();
+
+        if (includeNative) {
+            const nativeBalance = await getEvmNativeBalance(address as Hex, client);
+            const nativeRaw = nativeBalance.balance.toString();
+            items.push({
+                tokenAddress: "native",
+                symbol: chain.nativeToken.symbol,
+                decimals: chain.nativeToken.decimals,
+                balanceRaw: nativeRaw,
+                balanceFormatted: nativeBalance.formatted,
+            });
+            priceTargets.add("native");
+        }
+
+        if (tokenAddresses && tokenAddresses.length > 0) {
+            const tokenResults = await Promise.all(
+                tokenAddresses.map(async (tokenAddress) => {
+                    const balance = await getEvmTokenBalance(tokenAddress as Hex, address as Hex, client);
+                    const raw = balance.balance.toString();
+                    return {
+                        tokenAddress,
+                        symbol: tokenAddress,
+                        decimals: balance.decimal,
+                        balanceRaw: raw,
+                        balanceFormatted: balance.formatted,
+                    };
+                })
+            );
+            for (const token of tokenResults) {
+                items.push(token);
+                priceTargets.add(token.tokenAddress);
+            }
+        } else {
+            const discovered = await discoverEvmTokens(address, chain);
+            for (const token of discovered) {
+                const raw = String(token.balance);
+                const decimals = token.decimals ?? 0;
+                const rawBn = new BN(raw);
+                const divisor = Math.pow(10, decimals);
+                const formatted = divisor === 0 ? 0 : Number(rawBn.toString()) / divisor;
+
+                items.push({
+                    tokenAddress: token.address,
+                    symbol: token.symbol,
+                    decimals,
+                    balanceRaw: raw,
+                    balanceFormatted: formatted,
+                });
+                priceTargets.add(token.address);
+            }
+        }
+
+        const priceResult = await fetchPrices({
+            vm: "EVM",
+            chainId: chain.chainId,
+            tokenAddresses: Array.from(priceTargets),
+        });
+        const priceMap = normalizePriceMap(priceResult.data?.prices ?? []);
+        const enrichedItems = enrichWithUsdValues(items, priceMap);
+
+        return {
+            address,
+            vmType,
+            chainId: chain.chainId,
+            items: enrichedItems,
+            totals: buildTotals(enrichedItems),
+        };
+    }
+
+    const svmAddress = new PublicKey(address);
+    const connection = new Connection(chain.rpcUrl);
+    const items: Omit<AddressPortfolioItem, "priceUsd" | "valueUsd">[] = [];
+    const priceTargets = new Set<string>();
+
+    if (includeNative) {
+        const nativeBalance = await getSvmNativeBalance(svmAddress, connection);
+        items.push({
+            tokenAddress: "native",
+            symbol: chain.nativeToken.symbol,
+            decimals: chain.nativeToken.decimals,
+            balanceRaw: nativeBalance.balance.toString(),
+            balanceFormatted: nativeBalance.formatted,
+        });
+        priceTargets.add("native");
+    }
+
+    if (tokenAddresses && tokenAddresses.length > 0) {
+        const tokenResults = await Promise.all(
+            tokenAddresses.map(async (tokenAddress) => {
+                const pubkey = new PublicKey(tokenAddress);
+                const tokenBalance = await SVMVM.getTokenBalance(svmAddress, pubkey, connection);
+                return {
+                    tokenAddress,
+                    symbol: tokenAddress,
+                    decimals: tokenBalance.decimal,
+                    balanceRaw: tokenBalance.balance.toString(),
+                    balanceFormatted: tokenBalance.formatted,
+                };
+            })
+        );
+        for (const token of tokenResults) {
+            items.push(token);
+            priceTargets.add(token.tokenAddress);
+        }
+    } else {
+        const discovered = await discoverSvmTokens(svmAddress, connection);
+        for (const token of discovered) {
+            const raw = String(token.balance);
+            const decimals = token.decimals ?? 0;
+            const rawBn = new BN(raw);
+            const divisor = Math.pow(10, decimals);
+            const formatted = divisor === 0 ? 0 : Number(rawBn.toString()) / divisor;
+
+            items.push({
+                tokenAddress: token.address,
+                symbol: token.symbol,
+                decimals,
+                balanceRaw: raw,
+                balanceFormatted: formatted,
+            });
+            priceTargets.add(token.address);
+        }
+    }
 
-// create a unified evm svm balan e querying function
-//create a chain wallet class that takes address and chain config and probably vm
+    const priceResult = await fetchPrices({
+        vm: "SVM",
+        chainId: chain.chainId,
+        tokenAddresses: Array.from(priceTargets),
+    });
+    const priceMap = normalizePriceMap(priceResult.data?.prices ?? []);
+    const enrichedItems = enrichWithUsdValues(items, priceMap);
 
+    return {
+        address,
+        vmType,
+        chainId: chain.chainId,
+        items: enrichedItems,
+        totals: buildTotals(enrichedItems),
+    };
+};

package/utils/walletBip32.ts

@@ -137,7 +137,10 @@ export function EVMDeriveChildPrivateKey(seed: string, index: number, derivation
     VMValidation.validateIndex(index, 'Wallet index');
     // VMValidation.validateDerivationPath(derivationPath + index + "'", 'EVM');
 
-    const path = `${derivationPath}${index}'`;
+    // MetaMask-compatible EVM path uses unhardened address index:
+    // m/44'/60'/account'/change/address_index
+    // If a full path is passed (no trailing slash), use it as-is.
+    const path = derivationPath.endsWith("/") ? `${derivationPath}${index}` : derivationPath;
     const scureNode = HDKey.fromMasterSeed(Buffer.from(seed, "hex"));
     const child = scureNode.derive(path);
 
@@ -218,4 +221,4 @@ function hardenedDerivation(
         key: hmacResult.slice(0, 32),      // Left 32 bytes
         chainCode: hmacResult.slice(32, 64) // Right 32 bytes
     };
-}
+}