@deserialize/multi-vm-wallet 1.4.2 → 1.5.0

package/utils/svm/svm.ts

@@ -2,7 +2,8 @@ import { Connection, Keypair, PublicKey, Transaction, VersionedTransaction } fro
 import { SVMDeriveChildPrivateKey } from "../walletBip32";
 import { VM } from "../vm";
 import { ChainWallet } from "../IChainWallet";
-import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT } from "../types";
+import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT, DiscoveredWallet, WalletDiscoveryOptions, WalletDiscoveryResult, PocketDiscoveryOptions } from "../types";
+import { VMValidation, sanitizeError, logSafeError } from "../vm-validation";
 import {
     getSvmNativeBalance,
     getTokenBalance,
@@ -70,15 +71,24 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
 
 
     generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath = this.derivationPath) {
-        let _seed: string
+        // Validate inputs
+        VMValidation.validateIndex(index, 'Wallet index');
+        VMValidation.validateDerivationPath(derivationPath + index + "'", 'SVM');
+
+        let _seed: string;
 
         if (seed) {
-            _seed = seed
+            VMValidation.validateSeed(seed);
+            _seed = seed;
         } else if (mnemonic) {
-            _seed = VM.mnemonicToSeed(mnemonic)
+            VMValidation.validateMnemonic(mnemonic);
+            _seed = VM.mnemonicToSeed(mnemonic);
         } else {
-            _seed = this.seed
+            // Check if VM has been disposed
+            this.checkNotDisposed();
+            _seed = this.seed;
         }
+
         const privateKey = SVMDeriveChildPrivateKey(_seed, index, derivationPath);
         return { privateKey, index };
     }
@@ -89,6 +99,467 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
         const seed = VM.mnemonicToSeed(mnemonic)
         return new SVMVM(seed)
     }
+
+    /**
+     * Derive a savings account using BIP-44 account index
+     *
+     * Main wallet uses: m/44'/501'/0'/0' (account index 0)
+     * Savings accounts use: m/44'/501'/N'/0' (account index N)
+     *
+     * @param accountIndex - The BIP-44 account index (1 for first savings, 2 for second, etc.)
+     * @returns Object containing privateKey, address, and derivation path
+     */
+    deriveSavingsAccount(accountIndex: number): { privateKey: Keypair; address: PublicKey; derivationPath: string } {
+        const derivationPath = `m/44'/501'/${accountIndex}'/0'`;
+        const keypair = SVMDeriveChildPrivateKey(this.seed, 0, `m/44'/501'/${accountIndex}'/`);
+
+        return {
+            privateKey: keypair,
+            address: keypair.publicKey,
+            derivationPath
+        };
+    }
+
+    /**
+     * Discover wallets with native SOL balances using BIP-44 derivation
+     *
+     * Scans wallet indices to find wallets containing native SOL tokens.
+     * Follows BIP-44 gap limit standard: stops after 20 consecutive empty wallets.
+     *
+     * @param connection - Solana Connection instance
+     * @param options - Discovery options (gap limit, parallel checking, callbacks, etc.)
+     * @returns Discovery result with found wallets and statistics
+     *
+     * @example
+     * ```typescript
+     * const vm = new SVMVM(seed);
+     * const connection = new Connection('https://api.mainnet-beta.solana.com');
+     *
+     * // Sequential checking (safer for rate limits)
+     * const result = await vm.discoverWallets(connection, {
+     *   gapLimit: 20,
+     *   onProgress: (current, total, found) => console.log(`Checked ${current}/${total}, found ${found}`),
+     *   onDiscovered: (wallet) => console.log(`Found wallet at index ${wallet.index}`)
+     * });
+     *
+     * // Parallel checking (faster but more aggressive)
+     * const result = await vm.discoverWallets(connection, {
+     *   checkInParallel: true,
+     *   batchSize: 10,
+     *   gapLimit: 20
+     * });
+     * ```
+     */
+    async discoverWallets(
+        connection: Connection,
+        options?: WalletDiscoveryOptions
+    ): Promise<WalletDiscoveryResult> {
+        const startTime = Date.now();
+
+        // Default options - parallel checking for speed
+        const {
+            startIndex = 0,
+            maxIndex = 100,
+            gapLimit = 20,
+            minBalance = BigInt(0),
+            includeZeroBalance = false,
+            includePrivateKeys = false,
+            checkInParallel = true,   // Default to parallel for speed
+            batchSize = 10,            // Larger batch for better performance
+            checkDelay = checkInParallel ? 200 : 50,
+            onProgress,
+            onDiscovered
+        } = options || {};
+
+        const discovered: DiscoveredWallet[] = [];
+        let consecutiveEmpty = 0;
+        let scannedIndices = 0;
+        let stoppedByGapLimit = false;
+
+        if (checkInParallel) {
+            // Parallel checking with batches
+            for (let i = startIndex; i <= maxIndex; i += batchSize) {
+                const batchEnd = Math.min(i + batchSize, maxIndex + 1);
+                const batchPromises: Promise<DiscoveredWallet | null>[] = [];
+
+                // Create batch of parallel checks
+                for (let j = i; j < batchEnd; j++) {
+                    batchPromises.push(this.checkWalletBalance(j, connection));
+                }
+
+                // Wait for batch to complete
+                const batchResults = await Promise.all(batchPromises);
+
+                // Process results
+                for (let k = 0; k < batchResults.length; k++) {
+                    const index = i + k;
+                    const wallet = batchResults[k];
+                    scannedIndices++;
+
+                    if (wallet) {
+                        const hasBalance = wallet.nativeBalance.amount > minBalance;
+
+                        if (hasBalance || includeZeroBalance) {
+                            if (!includePrivateKeys) {
+                                delete wallet.privateKey;
+                            }
+                            discovered.push(wallet);
+                            consecutiveEmpty = 0;
+
+                            onDiscovered?.(wallet);
+                        } else {
+                            consecutiveEmpty++;
+                        }
+                    } else {
+                        consecutiveEmpty++;
+                    }
+
+                    onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+
+                    // Check gap limit
+                    if (consecutiveEmpty >= gapLimit) {
+                        stoppedByGapLimit = true;
+                        break;
+                    }
+                }
+
+                if (stoppedByGapLimit) {
+                    break;
+                }
+
+                // Delay between batches
+                if (batchEnd <= maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        } else {
+            // Sequential checking
+            for (let i = startIndex; i <= maxIndex; i++) {
+                const wallet = await this.checkWalletBalance(i, connection);
+                scannedIndices++;
+
+                if (wallet) {
+                    const hasBalance = wallet.nativeBalance.amount > minBalance;
+
+                    if (hasBalance || includeZeroBalance) {
+                        if (!includePrivateKeys) {
+                            delete wallet.privateKey;
+                        }
+                        discovered.push(wallet);
+                        consecutiveEmpty = 0;
+
+                        onDiscovered?.(wallet);
+                    } else {
+                        consecutiveEmpty++;
+                    }
+                } else {
+                    consecutiveEmpty++;
+                }
+
+                onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+
+                // Check gap limit
+                if (consecutiveEmpty >= gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+
+                // Delay between checks
+                if (i < maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        }
+
+        // Calculate total balance
+        const totalBalance = discovered.reduce((sum, wallet) => sum + wallet.nativeBalance.amount, BigInt(0));
+
+        const duration = Date.now() - startTime;
+
+        return {
+            discovered,
+            scannedIndices,
+            highestIndex: startIndex + scannedIndices - 1,
+            totalBalance,
+            stoppedByGapLimit,
+            duration
+        };
+    }
+
+    /**
+     * Check balance for a specific wallet index with retry logic
+     * @private
+     */
+    private async checkWalletBalance(
+        index: number,
+        connection: Connection,
+        maxRetries: number = 3
+    ): Promise<DiscoveredWallet | null> {
+        const derivationPath = `m/44'/501'/${index}'/0'`;
+
+        // Derive wallet using hardened derivation (required for Solana)
+        const keypair = SVMDeriveChildPrivateKey(this.seed, 0, `m/44'/501'/${index}'/`);
+        const address = keypair.publicKey;
+
+        // Retry logic with exponential backoff
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Get balance in lamports
+                const balanceLamports = await connection.getBalance(address);
+
+                // Convert lamports to SOL (9 decimals)
+                const balanceSOL = balanceLamports / 1_000_000_000;
+
+                return {
+                    index,
+                    address: address.toString(),
+                    derivationPath,
+                    nativeBalance: {
+                        amount: BigInt(balanceLamports),
+                        formatted: balanceSOL,
+                        symbol: 'SOL'
+                    },
+                    privateKey: base58.encode(keypair.secretKey)
+                };
+            } catch (error) {
+                if (attempt === maxRetries - 1) {
+                    console.error(`Failed to check balance for index ${index} after ${maxRetries} attempts:`, error);
+                    return null;
+                }
+
+                // Exponential backoff: 1s, 2s, 4s
+                const backoffMs = 1000 * Math.pow(2, attempt);
+                await this.sleep(backoffMs);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Sleep helper for rate limiting
+     * @private
+     */
+    private sleep(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * Discover savings pockets with native SOL balances using BIP-44 derivation
+     *
+     * Scans pocket account indices to find pockets containing native SOL.
+     * Pockets use derivation path: m/44'/501'/{accountIndex+1}'/0' (all hardened for Solana)
+     *
+     * @param connection - Solana Connection instance
+     * @param options - Discovery options (gap limit, parallel checking, walletIndex, callbacks, etc.)
+     * @returns Discovery result with found pockets and statistics
+     *
+     * @example
+     * ```typescript
+     * const vm = new SVMVM(seed);
+     * const connection = new Connection('https://api.mainnet-beta.solana.com');
+     *
+     * // Discover pockets for wallet index 0
+     * const result = await vm.discoverPockets(connection, {
+     *   walletIndex: 0,
+     *   gapLimit: 20,
+     *   onDiscovered: (pocket) => console.log(`Found pocket at account ${pocket.index}`)
+     * });
+     *
+     * console.log(`Found ${result.discovered.length} pockets with SOL`);
+     * ```
+     */
+    async discoverPockets(
+        connection: Connection,
+        options?: PocketDiscoveryOptions
+    ): Promise<WalletDiscoveryResult> {
+        const startTime = Date.now();
+
+        // Default options - parallel checking for speed
+        const {
+            startIndex = 0,
+            maxIndex = 100,
+            gapLimit = 20,
+            minBalance = BigInt(0),
+            includeZeroBalance = false,
+            includePrivateKeys = false,
+            checkInParallel = true,
+            batchSize = 10,
+            checkDelay = checkInParallel ? 200 : 50,
+            onProgress,
+            onDiscovered,
+            walletIndex = 0,
+        } = options || {};
+
+        const discovered: DiscoveredWallet[] = [];
+        let consecutiveEmpty = 0;
+        let scannedIndices = 0;
+        let stoppedByGapLimit = false;
+
+        if (checkInParallel) {
+            // Parallel checking with batches
+            for (let i = startIndex; i <= maxIndex; i += batchSize) {
+                const batchEnd = Math.min(i + batchSize, maxIndex + 1);
+                const batchPromises: Promise<DiscoveredWallet | null>[] = [];
+
+                // Create batch of parallel checks
+                for (let j = i; j < batchEnd; j++) {
+                    batchPromises.push(this.checkPocketBalance(j, walletIndex, connection));
+                }
+
+                // Wait for batch to complete
+                const batchResults = await Promise.all(batchPromises);
+
+                // Process results
+                for (let k = 0; k < batchResults.length; k++) {
+                    const index = i + k;
+                    const pocket = batchResults[k];
+                    scannedIndices++;
+
+                    if (pocket) {
+                        const hasBalance = pocket.nativeBalance.amount > minBalance;
+
+                        if (hasBalance || includeZeroBalance) {
+                            if (!includePrivateKeys) {
+                                delete pocket.privateKey;
+                            }
+                            discovered.push(pocket);
+                            consecutiveEmpty = 0;
+
+                            onDiscovered?.(pocket);
+                        } else {
+                            consecutiveEmpty++;
+                        }
+                    } else {
+                        consecutiveEmpty++;
+                    }
+
+                    onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+
+                    // Check gap limit
+                    if (consecutiveEmpty >= gapLimit) {
+                        stoppedByGapLimit = true;
+                        break;
+                    }
+                }
+
+                if (stoppedByGapLimit) {
+                    break;
+                }
+
+                // Delay between batches
+                if (batchEnd <= maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        } else {
+            // Sequential checking
+            for (let i = startIndex; i <= maxIndex; i++) {
+                const pocket = await this.checkPocketBalance(i, walletIndex, connection);
+                scannedIndices++;
+
+                if (pocket) {
+                    const hasBalance = pocket.nativeBalance.amount > minBalance;
+
+                    if (hasBalance || includeZeroBalance) {
+                        if (!includePrivateKeys) {
+                            delete pocket.privateKey;
+                        }
+                        discovered.push(pocket);
+                        consecutiveEmpty = 0;
+
+                        onDiscovered?.(pocket);
+                    } else {
+                        consecutiveEmpty++;
+                    }
+                } else {
+                    consecutiveEmpty++;
+                }
+
+                onProgress?.(scannedIndices, maxIndex - startIndex + 1, discovered.length);
+
+                // Check gap limit
+                if (consecutiveEmpty >= gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+
+                // Delay between checks
+                if (i < maxIndex) {
+                    await this.sleep(checkDelay);
+                }
+            }
+        }
+
+        // Calculate total balance
+        const totalBalance = discovered.reduce((sum, pocket) => sum + pocket.nativeBalance.amount, BigInt(0));
+
+        const duration = Date.now() - startTime;
+
+        return {
+            discovered,
+            scannedIndices,
+            highestIndex: startIndex + scannedIndices - 1,
+            totalBalance,
+            stoppedByGapLimit,
+            duration
+        };
+    }
+
+    /**
+     * Check balance for a specific pocket at account index
+     * @private
+     */
+    private async checkPocketBalance(
+        accountIndex: number,
+        walletIndex: number,
+        connection: Connection,
+        maxRetries: number = 3
+    ): Promise<DiscoveredWallet | null> {
+        // Pocket derivation: m/44'/501'/{accountIndex+1}'/0' (all hardened for Solana)
+        const pocketIndex = accountIndex + 1;
+        const derivationPath = `m/44'/501'/${pocketIndex}'/0'`;
+
+        // Derive wallet using hardened derivation (required for Solana)
+        // Note: For pockets, we use pocketIndex for account and walletIndex is not used in derivation
+        // This matches the EVM pocket pattern but adapted for Solana's all-hardened requirement
+        const keypair = SVMDeriveChildPrivateKey(this.seed, 0, `m/44'/501'/${pocketIndex}'/`);
+        const address = keypair.publicKey;
+
+        // Retry logic with exponential backoff
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Get balance in lamports
+                const balanceLamports = await connection.getBalance(address);
+
+                // Convert lamports to SOL (9 decimals)
+                const balanceSOL = balanceLamports / 1_000_000_000;
+
+                return {
+                    index: accountIndex,
+                    address: address.toString(),
+                    derivationPath,
+                    nativeBalance: {
+                        amount: BigInt(balanceLamports),
+                        formatted: balanceSOL,
+                        symbol: 'SOL'
+                    },
+                    privateKey: base58.encode(keypair.secretKey)
+                };
+            } catch (error) {
+                if (attempt === maxRetries - 1) {
+                    console.error(`Failed to check pocket at account ${accountIndex} after ${maxRetries} attempts:`, error);
+                    return null;
+                }
+
+                // Exponential backoff: 1s, 2s, 4s
+                const backoffMs = 1000 * Math.pow(2, attempt);
+                await this.sleep(backoffMs);
+            }
+        }
+
+        return null;
+    }
 }
 
 export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {

package/utils/test.ts

@@ -34,8 +34,8 @@ const pKey = ""
 // const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
 // const x = testUserKeyPair instanceof Keypair;
 
-const evmPrivKey = ""
-const evmPrivateKeyExposed = ""
+const evmPrivKey = "0xcd90354282b35344616d6b53684684bef6e8673ed601d562a5866dc67fafd1ef"
+const evmPrivateKeyExposed = "0xcd90354282b35344616d6b53684684bef6e8673ed601d562a5866dc67fafd1ef"
 // const vm = new SVMVM(seed)