@deserialize/multi-vm-wallet 1.5.11 → 1.5.21

package/utils/savings/svm-savings.ts

@@ -0,0 +1,394 @@
+/**
+ * SVM (Solana) Savings Manager
+ *
+ * Manages savings pockets on Solana blockchain
+ * Uses BIP-44 coin type 501 (different addresses from EVM)
+ */
+
+import { SavingsManager, Pocket } from "./savings-manager";
+import { Connection, PublicKey, Keypair, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
+import { SVMDeriveChildPrivateKey, mnemonicToSeed } from "../walletBip32";
+import { Balance, TransactionResult } from "../types";
+import {
+    getSvmNativeBalance,
+    getTokenBalance as getSvmTokenBalance,
+    signAndSendTransaction,
+    getTransferNativeTransaction,
+    getTransferTokenTransaction
+} from "../svm";
+import { SavingsValidation } from "./validation";
+import BN from "bn.js";
+
+/**
+ * Solana Savings Manager
+ *
+ * Provides savings pocket functionality for Solana blockchain.
+ * Uses BIP-44 derivation path: m/44'/501'/{pocketIndex}'/0/{walletIndex}
+ *
+ * @example
+ * ```typescript
+ * const manager = new SVMSavingsManager(
+ *   mnemonic,
+ *   'https://api.mainnet-beta.solana.com',
+ *   0  // wallet index
+ * );
+ *
+ * // Get pocket
+ * const pocket = manager.getPocket(0);
+ * console.log(pocket.address.toBase58()); // Solana address
+ *
+ * // Get balances
+ * const balances = await manager.getPocketBalance(0, [usdcMint]);
+ * ```
+ */
+export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Keypair> {
+    coinType = 501;
+    derivationPathBase = "m/44'/501'/";
+
+    private rpcUrl: string;
+    private _client?: Connection;
+
+    /**
+     * Create a new SVMSavingsManager
+     *
+     * @param mnemonic - BIP-39 mnemonic phrase
+     * @param rpcUrl - Solana RPC endpoint URL
+     * @param walletIndex - Wallet index in derivation path (default: 0)
+     */
+    constructor(
+        mnemonic: string,
+        rpcUrl: string,
+        walletIndex: number = 0
+    ) {
+        super(mnemonic, walletIndex);
+
+        if (!rpcUrl || typeof rpcUrl !== 'string') {
+            throw new Error('RPC URL must be a non-empty string');
+        }
+
+        this.rpcUrl = rpcUrl;
+    }
+
+    /**
+     * Get or create the RPC client on-demand
+     *
+     * Lazy initialization allows the client to be garbage collected between operations.
+     */
+    get client(): Connection {
+        if (!this._client) {
+            this._client = this.createClient(this.rpcUrl);
+        }
+        return this._client;
+    }
+
+    /**
+     * Create a Connection to Solana
+     *
+     * @param rpcUrl - RPC endpoint URL
+     * @returns Connection instance
+     */
+    createClient(rpcUrl: string): Connection {
+        return new Connection(rpcUrl, 'confirmed');
+    }
+
+    /**
+     * Clear the cached RPC client
+     */
+    clearClient(): void {
+        this._client = undefined;
+    }
+
+    /**
+     * Derive a savings pocket at the specified account index
+     *
+     * @param accountIndex - Account index (0-based)
+     * @returns Pocket object with privateKey (Keypair), address (PublicKey), derivationPath, and index
+     */
+    derivePocket(accountIndex: number): Pocket<PublicKey> {
+        this.checkNotDisposed();
+        SavingsValidation.validateAccountIndex(accountIndex);
+
+        // Add 1 to preserve index 0 for main wallet
+        const pocketIndex = accountIndex + 1;
+        const derivationPath = `${this.derivationPathBase}${pocketIndex}'/0/${this.walletIndex}`;
+        const seed = mnemonicToSeed(this.mnemonic);
+        const keypair = SVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPath);
+
+        const pocket: Pocket<PublicKey> = {
+            privateKey: keypair,
+            address: keypair.publicKey,
+            derivationPath,
+            index: pocketIndex
+        };
+
+        this.pockets.set(accountIndex, pocket);
+        return pocket;
+    }
+
+    /**
+     * Get the main wallet credentials
+     *
+     * @returns Main wallet object with privateKey (Keypair), address (PublicKey), and derivationPath
+     */
+    getMainWallet() {
+        this.checkNotDisposed();
+        const derivationPath = `${this.derivationPathBase}0'/0/${this.walletIndex}`;
+        const seed = mnemonicToSeed(this.mnemonic);
+        const keypair = SVMDeriveChildPrivateKey(seed, this.walletIndex, derivationPath);
+
+        return {
+            privateKey: keypair,
+            address: keypair.publicKey,
+            derivationPath
+        };
+    }
+
+    /**
+     * Get the main wallet address
+     *
+     * @returns Main wallet PublicKey
+     */
+    getMainWalletAddress(): PublicKey {
+        return this.getMainWallet().address;
+    }
+
+    /**
+     * Get token balances for a specific pocket
+     *
+     * @param pocketIndex - Pocket index to check
+     * @param tokens - Array of SPL token mint addresses
+     * @returns Array of balance objects
+     */
+    async getPocketBalance(pocketIndex: number, tokens: string[]): Promise<{
+        address: PublicKey | 'native';
+        balance: Balance;
+    }[]> {
+        SavingsValidation.validateAccountIndex(pocketIndex);
+
+        if (!Array.isArray(tokens)) {
+            throw new Error('Tokens must be an array');
+        }
+
+        const pocket = this.getPocket(pocketIndex);
+        const balances: { address: PublicKey | 'native'; balance: Balance }[] = [];
+
+        // Get native SOL balance
+        const nativeBalance = await getSvmNativeBalance(pocket.address, this.client);
+        balances.push({ address: 'native', balance: nativeBalance });
+
+        // Get SPL token balances
+        await Promise.all(tokens.map(async (token) => {
+            try {
+                const tokenPubkey = new PublicKey(token);
+                const tokenBalanceData = await getSvmTokenBalance(pocket.address, tokenPubkey, this.client);
+
+                // Handle the case where getTokenBalance returns 0 or TokenAmount
+                if (tokenBalanceData === 0) {
+                    balances.push({
+                        address: tokenPubkey,
+                        balance: { balance: new BN(0), formatted: 0, decimal: 0 }
+                    });
+                } else {
+                    const balance: Balance = {
+                        balance: new BN(tokenBalanceData.amount),
+                        formatted: tokenBalanceData.uiAmount || 0,
+                        decimal: tokenBalanceData.decimals
+                    };
+                    balances.push({ address: tokenPubkey, balance });
+                }
+            } catch (error) {
+                // Token account might not exist, push zero balance
+                balances.push({
+                    address: new PublicKey(token),
+                    balance: { balance: new BN(0), formatted: 0, decimal: 0 }
+                });
+            }
+        }));
+
+        return balances;
+    }
+
+    /**
+     * Get balances for multiple pockets
+     *
+     * @param tokens - Array of token mint addresses
+     * @param pockets - Array of pocket indices
+     * @returns Array of balance arrays per pocket
+     */
+    async getTotalTokenBalanceOfAllPockets(
+        tokens: string[],
+        pockets: number[]
+    ): Promise<Array<{ address: PublicKey | 'native'; balance: Balance; }[]>> {
+        if (!Array.isArray(tokens) || tokens.length === 0) {
+            throw new Error('Tokens array must be non-empty');
+        }
+        if (!Array.isArray(pockets) || pockets.length === 0) {
+            throw new Error('Pockets array must be non-empty');
+        }
+
+        // Validate all pocket indices
+        pockets.forEach((pocket) => {
+            SavingsValidation.validateAccountIndex(pocket);
+        });
+
+        // Fetch balances for all pockets in parallel
+        const allBalances = await Promise.all(
+            pockets.map((p: number) => this.getPocketBalance(p, tokens))
+        );
+
+        return allBalances;
+    }
+
+    /**
+     * Transfer SOL from main wallet to a pocket
+     *
+     * @param mainWallet - Keypair for the main wallet
+     * @param pocketIndex - Destination pocket index
+     * @param amount - Amount to transfer in lamports
+     * @returns Transaction result
+     */
+    async transferToPocket(
+        mainWallet: Keypair,
+        pocketIndex: number,
+        amount: bigint
+    ): Promise<TransactionResult> {
+        SavingsValidation.validateAccountIndex(pocketIndex);
+
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+
+        const pocket = this.getPocket(pocketIndex);
+        const tx = await getTransferNativeTransaction(
+            mainWallet,
+            pocket.address,
+            Number(amount),
+            this.client
+        );
+
+        const hash = await signAndSendTransaction(tx, this.client, mainWallet);
+        return { success: true, hash };
+    }
+
+    /**
+     * Transfer SPL tokens from main wallet to a pocket
+     *
+     * @param mainWallet - Keypair for the main wallet
+     * @param tokenInfo - SPL token information (address, decimals, etc.)
+     * @param pocketIndex - Destination pocket index
+     * @param amount - Amount to transfer (in token base units)
+     * @returns Transaction result
+     */
+    async transferTokenToPocket(
+        mainWallet: Keypair,
+        tokenInfo: { address: string; decimals: number },
+        pocketIndex: number,
+        amount: bigint
+    ): Promise<TransactionResult> {
+        SavingsValidation.validateAccountIndex(pocketIndex);
+
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+
+        const pocket = this.getPocket(pocketIndex);
+
+        const tx = await getTransferTokenTransaction(
+            mainWallet,
+            pocket.address,
+            tokenInfo as any,  // TokenInfo type
+            Number(amount),
+            this.client
+        );
+
+        const hash = await signAndSendTransaction(tx, this.client, mainWallet);
+        return { success: true, hash };
+    }
+
+    /**
+     * Get Keypair from pocket (for signing transactions)
+     *
+     * @param pocketIndex - Pocket index
+     * @returns Keypair instance
+     */
+    accountFromPocketId(pocketIndex: number): Keypair {
+        const pocket = this.getPocket(pocketIndex);
+        return pocket.privateKey;
+    }
+
+    /**
+     * Verify that a stored pocket address matches the derived address
+     *
+     * @param accountIndex - Pocket index
+     * @param storedAddress - Address to verify (base58 string)
+     * @returns true if addresses match
+     */
+    verifyPocketAddress(accountIndex: number, storedAddress: string): boolean {
+        SavingsValidation.validateAccountIndex(accountIndex);
+
+        if (!storedAddress || typeof storedAddress !== 'string') {
+            throw new Error('Stored address must be a non-empty string');
+        }
+
+        try {
+            const pocket = this.getPocket(accountIndex);
+            const storedPubkey = new PublicKey(storedAddress);
+            return pocket.address.equals(storedPubkey);
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Send tokens from a pocket back to the main wallet
+     *
+     * @param pocketIndex - Source pocket index
+     * @param amount - Amount to send (in base units)
+     * @param token - Token info object or "native" for SOL
+     * @returns Transaction result
+     */
+    async sendToMainWallet(
+        pocketIndex: number,
+        amount: bigint,
+        token: { address: string; decimals: number } | "native"
+    ): Promise<TransactionResult> {
+        SavingsValidation.validateAccountIndex(pocketIndex);
+
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+
+        const pocket = this.getPocket(pocketIndex);
+        const mainWalletAddress = this.getMainWalletAddress();
+
+        if (token === "native") {
+            const tx = await getTransferNativeTransaction(
+                pocket.privateKey,
+                mainWalletAddress,
+                Number(amount),
+                this.client
+            );
+            const hash = await signAndSendTransaction(tx, this.client, pocket.privateKey);
+            return { success: true, hash };
+        }
+
+        const tx = await getTransferTokenTransaction(
+            pocket.privateKey,
+            mainWalletAddress,
+            token as any,  // TokenInfo type
+            Number(amount),
+            this.client
+        );
+
+        const hash = await signAndSendTransaction(tx, this.client, pocket.privateKey);
+        return { success: true, hash };
+    }
+
+    /**
+     * Dispose and clear all resources
+     */
+    dispose(): void {
+        super.dispose();
+        this.clearClient();
+    }
+}

package/utils/svm/index.ts

@@ -1 +1,2 @@
-export * from "./svm"
+export * from "./svm"
+export * from "./utils"

package/utils/test.ts

@@ -22,7 +22,7 @@ import { entryPoint07Address } from "viem/account-abstraction";
 import { KERNEL_V3_3, KernelVersionToAddressesMap } from '@zerodev/sdk/constants';
 import { deserializeSessionKey } from "./evm/aa-service";
 import { toSpendingLimitHook } from "@zerodev/hooks"
-import { SavingsManager } from "./savings";
+import { EVMSavingsManager, SVMSavingsManager, MultiChainSavingsManager } from "./savings";
 // const mnemonic = GenerateNewMnemonic()
 
 
@@ -212,27 +212,186 @@ const testPrice = async () => {
     walletA.getPrices(['0x98d0baa52b2D063E780DE12F615f963Fe8537553']).then(console.log)
 }
 
+// ============================================
+// EVM Savings Pocket Test
+// ============================================
 const testSavingsPocket = async () => {
+    console.log('\n========== EVM Savings Test ==========');
+    const mnemonic = EVMVM.generateMnemonicFromPrivateKey(evmPrivateKeyExposed)
+    console.log('Mnemonic:', mnemonic);
+
+    // Using new EVMSavingsManager (multi-chain compatible)
+    const savingsManager = new EVMSavingsManager(mnemonic, evmChainConfig, wallet.index)
 
+    const pocket0 = savingsManager.getPocket(0)
+    console.log('\nPocket 0 Info:');
+    console.log('  Address:', pocket0.address);
+    console.log('  Derivation path:', pocket0.derivationPath);
+    console.log('  Index:', pocket0.index);
+
+    // Uncomment to test transfer
+    // const deposited = await savingsManager.transferToPocket(walletA.wallet, 0, "0.00001")
+    // console.log('deposited: ', deposited);
 
+    // Get balance (updated API: getPocketBalance(pocketIndex, tokens[]))
+    const balance = await savingsManager.getPocketBalance(0, [])
+    console.log('\nPocket 0 Balance:');
+    console.log('  Native balance:', balance[0].balance.formatted, 'ETH');
+
+    // Get multiple pockets
+    const pocket1 = savingsManager.getPocket(1)
+    const pocket2 = savingsManager.getPocket(2)
+    console.log('\nAdditional Pockets:');
+    console.log('  Pocket 1:', pocket1.address);
+    console.log('  Pocket 2:', pocket2.address);
+
+    // Cleanup
+    savingsManager.dispose();
+    console.log('\n✅ EVM Savings Test Complete\n');
+}
+
+// ============================================
+// SVM (Solana) Savings Pocket Test
+// ============================================
+const testSavingsPocketSVM = async () => {
+    console.log('\n========== SVM (Solana) Savings Test ==========');
     const mnemonic = EVMVM.generateMnemonicFromPrivateKey(evmPrivateKeyExposed)
-    console.log('mnemonic: ', mnemonic);
+    console.log('Mnemonic:', mnemonic);
 
-    const savingsManager = new SavingsManager(mnemonic, evmChainConfig, wallet.index)
+    // Using SVMSavingsManager for Solana
+    const savingsManager = new SVMSavingsManager(
+        mnemonic,
+        chainConfig.rpcUrl,
+        0  // wallet index
+    )
 
     const pocket0 = savingsManager.getPocket(0)
+    console.log('\nPocket 0 Info:');
+    console.log('  Address:', pocket0.address.toBase58());
+    console.log('  Derivation path:', pocket0.derivationPath);
+    console.log('  Index:', pocket0.index);
+
+    // Get balance
+    const balance = await savingsManager.getPocketBalance(0, [])
+    console.log('\nPocket 0 Balance:');
+    console.log('  Native balance:', balance[0].balance.formatted, 'SOL');
+
+    // Get multiple pockets
+    const pocket1 = savingsManager.getPocket(1)
+    const pocket2 = savingsManager.getPocket(2)
+    console.log('\nAdditional Pockets:');
+    console.log('  Pocket 1:', pocket1.address.toBase58());
+    console.log('  Pocket 2:', pocket2.address.toBase58());
+
+    // Note: Solana addresses are DIFFERENT from EVM addresses!
+    console.log('\n💡 Note: Solana uses coin type 501, so addresses differ from EVM');
+
+    // Cleanup
+    savingsManager.dispose();
+    console.log('\n✅ SVM Savings Test Complete\n');
+}
 
-    // const deposited = await savingsManager.transferToPocket(walletA.wallet, pocket0.index, "0.00001")
-
-    const balance = await savingsManager.getPocketTokenBalance([], 0)
-    console.log('balance: ', balance);
+// ============================================
+// Multi-Chain Savings Test
+// ============================================
+const testSavingsPocketMultiChain = async () => {
+    console.log('\n========== Multi-Chain Savings Test ==========');
+    const mnemonic = EVMVM.generateMnemonicFromPrivateKey(evmPrivateKeyExposed)
+    console.log('Mnemonic:', mnemonic);
 
-    // console.log('deposited: ', deposited);
+    // Create multi-chain manager with EVM and Solana
+    const multiChainManager = new MultiChainSavingsManager(
+        mnemonic,
+        [
+            {
+                id: 'base',
+                type: 'EVM',
+                config: evmChainConfig
+            },
+            {
+                id: 'ethereum',
+                type: 'EVM',
+                config: {
+                    chainId: 1,
+                    name: 'Ethereum',
+                    rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/demo',
+                    explorerUrl: 'https://etherscan.io',
+                    nativeToken: { name: 'Ethereum', symbol: 'ETH', decimals: 18 },
+                    confirmationNo: 1,
+                    vmType: 'EVM'
+                }
+            },
+            {
+                id: 'solana',
+                type: 'SVM',
+                config: {
+                    rpcUrl: chainConfig.rpcUrl
+                }
+            }
+        ],
+        0  // wallet index
+    );
+
+    console.log('\nAvailable chains:', multiChainManager.getChains());
+    console.log('EVM chains:', multiChainManager.getEVMChains());
+    console.log('SVM chains:', multiChainManager.getSVMChains());
+
+    // Get pocket 0 address on different chains
+    console.log('\nPocket 0 Addresses Across Chains:');
+    const baseAddress = multiChainManager.getPocketAddress('base', 0);
+    const ethAddress = multiChainManager.getPocketAddress('ethereum', 0);
+    const solAddress = multiChainManager.getPocketAddress('solana', 0);
+
+    console.log('  Base:', baseAddress);
+    console.log('  Ethereum:', ethAddress);
+    console.log('  Solana:', solAddress);
+
+    // Verify EVM chains share addresses
+    console.log('\n🔍 EVM Address Check:');
+    console.log('  Base === Ethereum?', baseAddress === ethAddress, '✅');
+    console.log('  Base === Solana?', baseAddress === solAddress, '❌ (different chain type)');
+
+    // Get balances across chains
+    console.log('\n📊 Getting balances across all chains...');
+    try {
+        const balances = await multiChainManager.getPocketBalanceAcrossChains(
+            0,  // pocket index
+            new Map([
+                ['base', []],     // No tokens, just native
+                ['ethereum', []],
+                ['solana', []]
+            ])
+        );
+
+        console.log('\nBalances for Pocket 0:');
+        balances.forEach(chainBalance => {
+            console.log(`\n  ${chainBalance.chainId.toUpperCase()} (${chainBalance.chainType}):`);
+            console.log(`    Address: ${chainBalance.address}`);
+            chainBalance.balances.forEach(bal => {
+                const tokenName = bal.token === 'native' ? 'Native' : bal.token;
+                console.log(`    ${tokenName}: ${bal.balance.formatted}`);
+            });
+        });
+    } catch (error) {
+        console.log('  ⚠️ Balance fetch error (expected for demo RPCs):', (error as Error).message);
+    }
 
+    // Get specific chain managers for advanced operations
+    console.log('\n🔧 Advanced: Direct chain manager access');
+    const baseManager = multiChainManager.getEVMManager('base');
+    const solanaManager = multiChainManager.getSVMManager('solana');
+    console.log('  Base manager type:', baseManager.constructor.name);
+    console.log('  Solana manager type:', solanaManager.constructor.name);
 
+    // Cleanup
+    multiChainManager.dispose();
+    console.log('\n✅ Multi-Chain Savings Test Complete\n');
 }
 
+// Uncomment to run tests
 // testSavingsPocket()
+// testSavingsPocketSVM()
+// testSavingsPocketMultiChain()
 
 // testPrice()