@deserialize/multi-vm-wallet 1.3.2 → 1.3.4

package/utils/evm/evm.ts

@@ -37,6 +37,18 @@ import { EVMTransactionHistoryItem, getEVMTransactionHistory } from "./transacti
 import { createPublicClient, Hex, http, PublicClient, parseEther, parseUnits, Call } from "viem";
 import { EVMSmartWallet } from "./smartWallet";
 import { SmartWalletOptions } from "./aa-service";
+import { SavingsManager } from "../savings/savings-manager";
+import { SmartSavingsManager } from "../savings/smart-savings";
+import {
+    SavingsAccount,
+    SmartSavingsAccount,
+    AddressVerificationResult,
+    SavingsAuditResult,
+    TransferToSavingsOptions,
+    WithdrawFromSavingsOptions
+} from "../savings/types";
+import { fetchPrices } from "../price";
+import { PriceResponse } from "../price.types";
 
 
 interface DebonkQuoteResponse {
@@ -76,6 +88,7 @@ interface DebonkSwapResult {
 
 
 export class EVMVM extends VM<string, string, JsonRpcProvider> {
+
     derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
 
     constructor(seed: string) {
@@ -97,6 +110,38 @@ export class EVMVM extends VM<string, string, JsonRpcProvider> {
         const privateKey = EVMDeriveChildPrivateKey(_seed, index, derivationPath).privateKey;
         return { privateKey, index };
     }
+
+    /**
+     * Derive a savings account using BIP-44 account index
+     *
+     * Uses the pattern: m/44'/60'/accountIndex'/0/0
+     * - Main wallet: m/44'/60'/0'/0/0 (account index 0)
+     * - Savings 1: m/44'/60'/1'/0/0 (account index 1)
+     * - Savings 2: m/44'/60'/2'/0/0 (account index 2)
+     *
+     * @param accountIndex - The BIP-44 account index (0 for main, 1+ for savings)
+     * @returns Object containing privateKey, address, and derivation path
+     */
+    deriveSavingsAccount(accountIndex: number): { privateKey: string; address: string; derivationPath: string } {
+        // Use fixed address index 0 for savings accounts
+        // Vary only the account index (3rd position in BIP-44)
+        const derivationPath = `m/44'/60'/${accountIndex}'/0/0`;
+
+        // Derive the full path directly (no additional index appended)
+        const result = EVMDeriveChildPrivateKey(this.seed, 0, `m/44'/60'/${accountIndex}'/0/`);
+        const privateKey = result.privateKey;
+
+        // Derive address from private key
+        const wallet = new ethers.Wallet(privateKey);
+        const address = wallet.address;
+
+        return {
+            privateKey,
+            address,
+            derivationPath
+        };
+    }
+
     static fromMnemonic(mnemonic: string): VM<string, string, JsonRpcProvider> {
         const seed = VM.mnemonicToSeed(mnemonic)
         return new EVMVM(seed)
@@ -121,6 +166,8 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
     client: PublicClient
     wallet: Wallet
     private smartWallet?: EVMSmartWallet
+    private savingsManager?: SavingsManager
+    private smartSavingsManager?: SmartSavingsManager
 
     constructor(config: ChainWalletConfig, privateKey: string, index: number) {
         super(config, privateKey, index);
@@ -372,6 +419,20 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         }
     }
 
+    async getPrices(tokenAddresses: string[]): Promise<PriceResponse> {
+        const result = await fetchPrices({
+            vm: 'EVM',
+            chainId: this.config.chainId,
+            tokenAddresses,
+        });
+
+        if (result.error) {
+            throw new Error(result.error.message);
+        }
+
+        return result.data as PriceResponse;
+    }
+
     // Updated swap method signature to match base class so created another method to use it inside swap
     async swap(
         tokenAddress: TokenInfo,
@@ -786,4 +847,260 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         const signer = this.getWallet()
         return signer.signMessage(message)
     }
+
+    // ============================================
+    // Savings Pocket Methods
+    // ============================================
+
+    /**
+     * Get or create the SavingsManager instance (lazy initialization)
+     * @private
+     */
+    private getSavingsManager(): SavingsManager {
+        if (!this.savingsManager) {
+            // Create a VM instance from the current wallet's seed
+            // We need to get the seed from the privateKey
+            // For now, we'll create an EVMVM from the wallet
+            // Note: This requires access to the seed, which we'll need to handle
+            throw new Error(
+                "SavingsManager requires access to the seed phrase. " +
+                "Please initialize the wallet with a seed phrase or mnemonic to use savings features."
+            );
+        }
+        return this.savingsManager;
+    }
+
+    /**
+     * Initialize savings functionality with a seed phrase
+     *
+     * This must be called before using any savings methods.
+     * The seed is used to derive savings accounts using BIP-44.
+     *
+     * @param seed - The wallet seed (hex string)
+     *
+     * @example
+     * const seed = VM.mnemonicToSeed(mnemonic);
+     * wallet.initializeSavings(seed);
+     */
+    initializeSavings(seed: string): void {
+        const vm = new EVMVM(seed);
+        this.savingsManager = new SavingsManager(vm);
+    }
+
+    /**
+     * Derive a new savings account from BIP-44 account index
+     *
+     * @param accountIndex - The BIP-44 account index (1+ for savings, 0 is main wallet)
+     * @returns SavingsAccount with derived address and private key
+     *
+     * @example
+     * const savingsAccount1 = wallet.deriveSavingsAccount(1); // m/44'/60'/1'/0/0
+     * const savingsAccount2 = wallet.deriveSavingsAccount(2); // m/44'/60'/2'/0/0
+     */
+    deriveSavingsAccount(accountIndex: number): SavingsAccount {
+        return this.getSavingsManager().createSavingsAccount(accountIndex);
+    }
+
+    /**
+     * Transfer native tokens to a savings account
+     *
+     * Security: Always derives the destination address from accountIndex.
+     *
+     * @param accountIndex - Savings account index to deposit to
+     * @param amount - Amount in ether units (e.g., "1.5" for 1.5 ETH)
+     * @param options - Optional security and priority settings
+     * @returns Transaction result
+     *
+     * @example
+     * const result = await wallet.transferToSavings(1, "1.5"); // Send 1.5 ETH to savings account 1
+     */
+    async transferToSavings(
+        accountIndex: number,
+        amount: string,
+        options?: TransferToSavingsOptions
+    ): Promise<TransactionResult> {
+        const manager = this.getSavingsManager();
+
+        // Build transaction using derived address
+        const amountWei = parseEther(amount);
+        const txParams = manager.buildDepositTransaction(accountIndex, amountWei, options);
+
+        // Execute using existing transferNative method
+        return await this.transferNative(txParams.to, Number(amount));
+    }
+
+    /**
+     * Withdraw native tokens from a savings account
+     *
+     * Security: Uses the derived private key for signing.
+     *
+     * @param accountIndex - Savings account index to withdraw from
+     * @param to - Destination address
+     * @param amount - Amount in ether units (e.g., "0.5" for 0.5 ETH)
+     * @param options - Optional security and priority settings
+     * @returns Transaction result
+     *
+     * @example
+     * const result = await wallet.withdrawFromSavings(1, destinationAddress, "0.5");
+     */
+    async withdrawFromSavings(
+        accountIndex: number,
+        to: string,
+        amount: string,
+        options?: WithdrawFromSavingsOptions
+    ): Promise<TransactionResult> {
+        const manager = this.getSavingsManager();
+
+        // Build withdrawal transaction
+        const amountWei = parseEther(amount);
+        const withdrawalParams = manager.buildWithdrawalTransaction(
+            accountIndex,
+            to as Hex,
+            amountWei,
+            options
+        );
+
+        // Create a temporary wallet with the savings account private key
+        const savingsWallet = new Wallet(withdrawalParams.privateKey, this.connection);
+
+        // Send transaction using the savings wallet
+        const tx = await savingsWallet.sendTransaction({
+            to: withdrawalParams.to,
+            value: withdrawalParams.value
+        });
+
+        const receipt = await tx.wait(this.config.confirmationNo || 1);
+
+        return {
+            success: receipt?.status === 1,
+            hash: receipt?.hash || tx.hash
+        };
+    }
+
+    /**
+     * Verify a stored savings address matches the derived address
+     *
+     * Security: Prevents database tampering attacks.
+     *
+     * @param accountIndex - The account index to verify
+     * @param storedAddress - The address from storage/database
+     * @returns Verification result
+     *
+     * @example
+     * const result = wallet.verifySavingsAddress(1, storedAddress);
+     * if (!result.isValid) {
+     *     console.error("Security alert: Address tampering detected!");
+     * }
+     */
+    verifySavingsAddress(accountIndex: number, storedAddress: Hex): AddressVerificationResult {
+        return this.getSavingsManager().verifySavingsAddress(accountIndex, storedAddress);
+    }
+
+    /**
+     * Audit multiple savings addresses at once
+     *
+     * @param addresses - Map of accountIndex to stored address
+     * @returns Audit result with summary and details
+     *
+     * @example
+     * const addresses = new Map([[1, "0xabc..."], [2, "0xdef..."]]);
+     * const audit = wallet.auditSavingsAddresses(addresses);
+     * console.log(`Valid: ${audit.valid}/${audit.total}`);
+     */
+    auditSavingsAddresses(addresses: Map<number, Hex>): SavingsAuditResult {
+        return this.getSavingsManager().auditSavingsAddresses(addresses);
+    }
+
+    /**
+     * Get savings account information without exposing private key
+     *
+     * @param accountIndex - The account index
+     * @returns Public account information (address and derivation path)
+     *
+     * @example
+     * const info = wallet.getSavingsAccountInfo(1);
+     * console.log(`Address: ${info.address}`);
+     * console.log(`Path: ${info.derivationPath}`); // m/44'/60'/1'/0/0
+     */
+    getSavingsAccountInfo(accountIndex: number): Omit<SavingsAccount, 'privateKey'> {
+        return this.getSavingsManager().getSavingsAccountInfo(accountIndex);
+    }
+
+    // ============================================
+    // Smart Savings Methods (EIP-7702)
+    // ============================================
+
+    /**
+     * Get or create the SmartSavingsManager instance (lazy initialization)
+     * @private
+     */
+    private getSmartSavingsManager(): SmartSavingsManager {
+        if (!this.smartSavingsManager) {
+            this.smartSavingsManager = new SmartSavingsManager(this.config);
+        }
+        return this.smartSavingsManager;
+    }
+
+    /**
+     * Upgrade a savings account to a smart account with EIP-7702 delegation
+     *
+     * This enables advanced features:
+     * - Lock modules for time-locked savings
+     * - Hooks for spend & save
+     * - Session keys for periodic savings
+     * - Sponsored transactions via paymaster
+     *
+     * @param accountIndex - The savings account index to upgrade
+     * @param options - Optional smart wallet configuration
+     * @param autoInitialize - Whether to initialize the smart wallet (default: false)
+     * @returns SmartSavingsAccount with EVMSmartWallet instance
+     *
+     * @example
+     * // Upgrade without initialization
+     * const smartSavings = await wallet.upgradeSavingsToSmartAccount(1);
+     * await smartSavings.smartWallet.initialize(); // Initialize separately
+     *
+     * @example
+     * // Upgrade and initialize in one step
+     * const smartSavings = await wallet.upgradeSavingsToSmartAccount(1, {}, true);
+     * // Ready to use immediately
+     */
+    async upgradeSavingsToSmartAccount(
+        accountIndex: number,
+        options?: SmartWalletOptions,
+        autoInitialize: boolean = false
+    ): Promise<SmartSavingsAccount> {
+        const manager = this.getSmartSavingsManager();
+
+        // First derive the basic savings account
+        const basicSavings = this.deriveSavingsAccount(accountIndex);
+
+        // Then upgrade to smart account
+        if (autoInitialize) {
+            return await manager.upgradeSavingsAndInitialize(basicSavings, options);
+        } else {
+            return await manager.upgradeSavingsToSmartAccount(basicSavings, options);
+        }
+    }
+
+    /**
+     * Check if smart savings is supported on this chain
+     *
+     * @returns true if chain supports Account Abstraction
+     *
+     * @example
+     * if (wallet.isSmartSavingsSupported()) {
+     *     const smartSavings = await wallet.upgradeSavingsToSmartAccount(1);
+     * } else {
+     *     console.log("This chain doesn't support smart savings");
+     * }
+     */
+    isSmartSavingsSupported(): boolean {
+        try {
+            const manager = this.getSmartSavingsManager();
+            return manager.canUpgradeToSmartAccount();
+        } catch (error) {
+            return false;
+        }
+    }
 }

package/utils/evm/smartWallet.ts

@@ -54,12 +54,11 @@ import type { SessionKeyPermission } from "./aa-service/lib/kernel-modules";
  * - Account recovery
  */
 export class EVMSmartWallet {
-    private aaService: AccountAbstractionService | null = null;
+    aaService: AccountAbstractionService | null = null;
     private kernelAccount: KernelAccountInstance | null = null;
     private ownerAccount: PrivateKeyAccount;
     private chain: Chain;
     private options: SmartWalletOptions;
-    private sessionAccount: any = null;
     private paymasterConfig: PaymasterConfig | null = null;
 
     constructor(
@@ -95,7 +94,7 @@ export class EVMSmartWallet {
         try {
             // Initialize AA service singleton with AA config
             this.aaService = AccountAbstractionService.getInstance({
-                bundlerProvider: 'custom',
+                bundlerProvider: 'pimlico',
                 customBundlerUrl: this.options.bundlerUrl!,
                 aaConfig: this.options.aaConfig
             });
@@ -202,35 +201,67 @@ export class EVMSmartWallet {
     async sendTransaction(
         to: Hex,
         value: bigint = 0n,
-        data: Hex = '0x'
+        data: Hex = '0x',
+        options?: { sessionAccount: Omit<KernelAccountInstance, 'owner' | 'entryPoint' | 'chain'> }
     ): Promise<SmartWalletTransactionResult> {
         if (!this.kernelAccount || !this.aaService) {
             throw new SmartWalletError('Smart wallet not initialized', 'NOT_INITIALIZED');
         }
 
         try {
-            // Use session account if available, otherwise use kernel account
-            const account = this.sessionAccount || this.kernelAccount;
-
-            const userOpHash = await this.aaService.sendTransaction({
-                account,
-                to,
-                value,
-                data
-            });
-
-            // Wait for receipt
-            const receipt = await this.aaService.waitForReceipt({
-                userOpHash,
-                chain: this.chain
-            });
-
-            return {
-                success: true,
-                userOpHash,
-                transactionHash: receipt.transactionHash
-            };
+            // Use session account if available and requested
+            if (options?.sessionAccount) {
+                // Session keys use kernel account client, not bundler client
+                const { createSessionKeyClient } = await import('./aa-service/lib/session-keys');
+
+                const kernelClient = createSessionKeyClient({
+                    account: options.sessionAccount.account,
+                    chain: this.chain,
+                    bundlerUrl: this.options.bundlerUrl!,
+                });
+
+                // Use kernel client to send transaction
+                const userOpHash = await kernelClient.sendUserOperation({
+                    callData: await options.sessionAccount.account.encodeCalls([{
+                        to,
+                        value,
+                        data
+                    }])
+                });
+
+                // Wait for receipt
+                const receipt = await kernelClient.waitForUserOperationReceipt({
+                    hash: userOpHash
+                });
+
+                return {
+                    success: true,
+                    userOpHash,
+                    transactionHash: receipt.receipt.transactionHash
+                };
+            } else {
+                // Use regular kernel account with AA service
+                const userOpHash = await this.aaService.sendTransaction({
+                    account: this.kernelAccount,
+                    to,
+                    value,
+                    data
+                });
+
+                // Wait for receipt
+                const receipt = await this.aaService.waitForReceipt({
+                    userOpHash,
+                    chain: this.chain
+                });
+
+                return {
+                    success: true,
+                    userOpHash,
+                    transactionHash: receipt.transactionHash
+                };
+            }
         } catch (error) {
+            console.log('error: ', error);
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
             return {
                 success: false,
@@ -254,7 +285,7 @@ export class EVMSmartWallet {
      *   { to: usdcAddress, value: 0n, data: transferCalldata }
      * ]);
      */
-    async sendBatchTransaction(calls: Call[]): Promise<SmartWalletTransactionResult> {
+    async sendBatchTransaction(calls: Call[], options?: { sessionAccount: KernelAccountInstance }): Promise<SmartWalletTransactionResult> {
         if (!this.kernelAccount || !this.aaService) {
             throw new SmartWalletError('Smart wallet not initialized', 'NOT_INITIALIZED');
         }
@@ -264,32 +295,65 @@ export class EVMSmartWallet {
         }
 
         try {
-            // Convert to AA service Call format
-            const aaCalls: AACall[] = calls.map(call => ({
+            // Convert to proper Call format
+            const normalizedCalls = calls.map(call => ({
                 to: call.to,
-                value: call.value,
-                data: call.data
+                value: call.value ?? 0n,
+                data: call.data ?? '0x' as Hex
             }));
 
-            // Use session account if available, otherwise use kernel account
-            const account = this.sessionAccount || this.kernelAccount;
-
-            const userOpHash = await this.aaService.sendBatchTransaction({
-                account,
-                calls: aaCalls
-            });
-
-            // Wait for receipt
-            const receipt = await this.aaService.waitForReceipt({
-                userOpHash,
-                chain: this.chain
-            });
-
-            return {
-                success: true,
-                userOpHash,
-                transactionHash: receipt.transactionHash
-            };
+            // Use session account if available
+            if (options?.sessionAccount) {
+                // Session keys use kernel account client
+                const { createSessionKeyClient } = await import('./aa-service/lib/session-keys');
+
+                const kernelClient = createSessionKeyClient({
+                    account: options.sessionAccount.account,
+                    chain: this.chain,
+                    bundlerUrl: this.options.bundlerUrl!,
+                    entryPoint: options.sessionAccount.entryPoint
+                });
+
+                // Use kernel client to send batch transaction
+                const userOpHash = await kernelClient.sendUserOperation({
+                    callData: await options.sessionAccount.account.encodeCalls(normalizedCalls)
+                });
+
+                // Wait for receipt
+                const receipt = await kernelClient.waitForUserOperationReceipt({
+                    hash: userOpHash
+                });
+
+                return {
+                    success: true,
+                    userOpHash,
+                    transactionHash: receipt.receipt.transactionHash
+                };
+            } else {
+                // Use regular kernel account with AA service
+                const aaCalls: AACall[] = normalizedCalls.map(call => ({
+                    to: call.to,
+                    value: call.value,
+                    data: call.data
+                }));
+
+                const userOpHash = await this.aaService.sendBatchTransaction({
+                    account: this.kernelAccount,
+                    calls: aaCalls
+                });
+
+                // Wait for receipt
+                const receipt = await this.aaService.waitForReceipt({
+                    userOpHash,
+                    chain: this.chain
+                });
+
+                return {
+                    success: true,
+                    userOpHash,
+                    transactionHash: receipt.transactionHash
+                };
+            }
         } catch (error) {
             const errorMsg = error instanceof Error ? error.message : 'Unknown error';
             return {
@@ -336,27 +400,7 @@ export class EVMSmartWallet {
         }
     }
 
-    /**
-     * Recreate session key from stored private key
-     *
-     * @param privateKey - Session key private key
-     * @returns Session key info
-     *
-     * @example
-     * const sessionKey = await smartWallet.recreateSessionKey(storedPrivateKey);
-     */
-    async recreateSessionKey(privateKey: Hex): Promise<SessionKeyInfo> {
-        if (!this.aaService) {
-            throw new SmartWalletError('Smart wallet not initialized', 'NOT_INITIALIZED');
-        }
-        try {
-            return await this.aaService.recreateSessionKey(privateKey);
-        } catch (error) {
-            throw new SessionKeyError(
-                `Failed to recreate session key: ${error instanceof Error ? error.message : 'Unknown error'}`
-            );
-        }
-    }
+
 
     /**
      * Create session key approval (Owner side)
@@ -380,6 +424,7 @@ export class EVMSmartWallet {
         try {
             return await this.aaService.createSessionKeyApproval({
                 sessionKeyAddress: options.sessionKeyAddress,
+                sessionKeyPrivateKey: options.sessionKeyPrivateKey,
                 owner: this.ownerAccount,
                 chain: this.chain,
                 entryPointVersion: this.options.entryPointVersion,
@@ -393,52 +438,6 @@ export class EVMSmartWallet {
         }
     }
 
-    /**
-     * Use session key for transactions (Agent side)
-     * Agent deserializes the approval and can send transactions with session key
-     *
-     * @param options - Session key usage options with approval and signer
-     *
-     * @example
-     * const sessionKey = await smartWallet.recreateSessionKey(privateKey);
-     * await smartWallet.useSessionKey({
-     *   approval,
-     *   sessionKeySigner: sessionKey.signer
-     * });
-     * // Now can send transactions with session key permissions
-     */
-    async useSessionKey(options: SessionKeyUsageOptions): Promise<void> {
-        if (!this.aaService) {
-            throw new SmartWalletError('Smart wallet not initialized', 'NOT_INITIALIZED');
-        }
-        try {
-            this.sessionAccount = await this.aaService.deserializeSessionKey({
-                approval: options.approval,
-                sessionKeySigner: options.sessionKeySigner,
-                chain: this.chain,
-                entryPointVersion: this.options.entryPointVersion
-            });
-        } catch (error) {
-            throw new SessionKeyError(
-                `Failed to use session key: ${error instanceof Error ? error.message : 'Unknown error'}`
-            );
-        }
-    }
-
-    /**
-     * Clear session key (revert to owner account)
-     */
-    clearSessionKey(): void {
-        this.sessionAccount = null;
-    }
-
-    /**
-     * Check if using session key
-     */
-    isUsingSessionKey(): boolean {
-        return this.sessionAccount !== null;
-    }
-
     /**
      * Create USDC transfer permission
      *
@@ -446,11 +445,11 @@ export class EVMSmartWallet {
      * @param maxAmount - Maximum USDC amount (in USDC units, e.g., "10" for 10 USDC)
      * @returns Permission rule
      */
-    createUSDCPermission(usdcAddress: Hex, maxAmount: string): SessionKeyPermissionRule {
+    createUSDCPermission(usdcAddress: Hex, maxAmount: string, destinationAddress: Hex): SessionKeyPermissionRule {
         if (!this.aaService) {
             throw new SmartWalletError('Smart wallet not initialized', 'NOT_INITIALIZED');
         }
-        return this.aaService.createUSDCTransferPermission(usdcAddress, maxAmount);
+        return this.aaService.createUSDCTransferPermission(usdcAddress, maxAmount, destinationAddress);
     }
 
     /**
@@ -706,14 +705,5 @@ export class EVMSmartWallet {
         return this.aaService.getBundlerInfo(this.chain);
     }
 
-    /**
-     * Clear all caches
-     */
-    clearCache(): void {
-        if (this.aaService) {
-            this.aaService.clearCache();
-        }
-        this.kernelAccount = null;
-        this.sessionAccount = null;
-    }
+
 }

package/utils/evm/utils.ts

@@ -641,7 +641,7 @@ export const safeApprove = async (
 
 export const discoverTokens = async (wallet: string, chain: ChainWalletConfig): Promise<UserTokenBalance<string>[]> => {
     const balances = await HelperAPI.getUserToken(wallet, chain.vmType ?? "EVM", chain.chainId)
-    console.log('balances: ', JSON.stringify(balances));
+
 
 
     const formatBalances: UserTokenBalance<string>[] = balances.data.map((token: any) => {