@deserialize/multi-vm-wallet 1.3.3 → 1.4.0

package/utils/evm/evm.ts

@@ -8,36 +8,32 @@ import { EVMDeriveChildPrivateKey } from "../walletBip32";
 import { ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, NFTInfo, UserTokenBalance, TokenInfo, TransactionResult, NFT } from "../types";
 import { VM } from "../vm";
-import { ethers, JsonRpcProvider, Wallet, formatUnits, Interface } from "ethers";
+import { ethers, formatUnits, Interface } from "ethers";
 import BN from "bn.js";
 import {
     getNativeBalance,
     getTokenBalance,
     sendERC20Token,
     sendNativeToken,
-    performSwap,
+
     checkAndApprove,
     signSendAndConfirm,
-    getNativeTokenAddress,
-    prepareSwapParams,
-    formatAmountToWei,
-    isChainSupportedByKyber,
-    isChainSupportedByDebonk,
-    // normalizeTokenAddressForDebonk,
-    convertSlippageForDebonk,
+
+
     TransactionParams,
     approveToken,
-    executeContractMethod,
+
     getTokenInfo,
     DESERIALIZED_SUPPORTED_CHAINS,
     discoverTokens,
-    discoverNFTs
+    discoverNFTs,
+    fromChainToViemChain
 } from "./utils";
 import { EVMTransactionHistoryItem, getEVMTransactionHistory } from "./transactionParsing";
-import { createPublicClient, Hex, http, PublicClient, parseEther, parseUnits, Call } from "viem";
+import { createPublicClient, Hex, http, parseEther, parseUnits, Call, walletActions, WalletClient, createWalletClient, Chain, ClientConfig, EIP1193RequestFn, TransportConfig, PublicClient, ChainConfig } 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,
@@ -47,6 +43,11 @@ import {
     TransferToSavingsOptions,
     WithdrawFromSavingsOptions
 } from "../savings/types";
+import { fetchPrices } from "../price";
+import { PriceResponse } from "../price.types";
+import { Account, privateKeyToAccount } from "viem/accounts";
+// import { extendWalletClientWithSavings } from "../savings";
+import { SavingsManager } from "../savings/saving-actions";
 
 
 interface DebonkQuoteResponse {
@@ -85,7 +86,8 @@ interface DebonkSwapResult {
 }
 
 
-export class EVMVM extends VM<string, string, JsonRpcProvider> {
+export class EVMVM extends VM<string, string, PublicClient> {
+
     derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
 
     constructor(seed: string) {
@@ -139,7 +141,7 @@ export class EVMVM extends VM<string, string, JsonRpcProvider> {
         };
     }
 
-    static fromMnemonic(mnemonic: string): VM<string, string, JsonRpcProvider> {
+    static fromMnemonic(mnemonic: string): VM<string, string, PublicClient> {
         const seed = VM.mnemonicToSeed(mnemonic)
         return new EVMVM(seed)
     }
@@ -148,63 +150,40 @@ export class EVMVM extends VM<string, string, JsonRpcProvider> {
         return ethers.isAddress(address);
     }
 
-    static async getNativeBalance(address: string, connection: JsonRpcProvider): Promise<Balance> {
+    static async getNativeBalance(address: string, connection: PublicClient): Promise<Balance> {
         // Implement native balance retrieval logic here
-        return await getNativeBalance(address, connection)
+        return await getNativeBalance(address as Hex, connection)
     }
 
-    static async getTokenBalance(address: string, tokenAddress: string, connection: JsonRpcProvider): Promise<Balance> {
+    static async getTokenBalance(address: string, tokenAddress: string, connection: PublicClient): Promise<Balance> {
         // Implement token balance retrieval logic here
-        return await getTokenBalance(tokenAddress, address, connection)
+        return await getTokenBalance(tokenAddress as Hex, address as Hex, connection)
     }
 }
 
-export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider> {
-    client: PublicClient
-    wallet: Wallet
+export class EVMChainWallet extends ChainWallet<string, string, PublicClient> {
+    wallet: WalletClient
     private smartWallet?: EVMSmartWallet
     private savingsManager?: SavingsManager
     private smartSavingsManager?: SmartSavingsManager
 
     constructor(config: ChainWalletConfig, privateKey: string, index: number) {
         super(config, privateKey, index);
-        this.connection = new JsonRpcProvider(config.rpcUrl)
-        const wallet = new Wallet(privateKey, this.connection);
-        this.wallet = wallet
-        this.address = wallet.address;
-        this.privateKey = privateKey;
-
-        //client for viem
-        this.client = createPublicClient(
+        this.connection = createPublicClient(
             {
-                chain: {
-                    rpcUrls: {
-                        default: {
-                            http: [config.rpcUrl]
-                        }
-                    },
-                    id: config.chainId,
-                    name: config.name,
-                    nativeCurrency: {
-                        name: config.nativeToken.name,
-                        symbol: config.nativeToken.symbol,
-                        decimals: config.nativeToken.decimals
-                    },
-                    blockExplorers: {
-                        default: {
-                            name: config.name + " Explorer",
-                            url: config.explorerUrl,
-                            apiUrl: config.explorerUrl
-                        },
-
-                    },
-                    testnet: config.testnet || false
-
-                },
+                chain: fromChainToViemChain(config),
                 transport: http(config.rpcUrl)
             },
-
         )
+        const account = privateKeyToAccount(privateKey as Hex)
+        this.wallet = createWalletClient({
+            account,
+            chain: fromChainToViemChain(config),
+            transport: http(config.rpcUrl)
+        })
+
+        this.address = account.address
+        this.privateKey = privateKey;
     }
 
     // ============================================
@@ -227,6 +206,10 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         return !!this.smartWallet;
     }
 
+    createSavingsManager(mnemonic: string, index: number = 0, chain: ChainConfig) {
+        return new SavingsManager(mnemonic, index, chain)
+    }
+
     /**
      * Validate that AA is available for sponsored transactions
      * @throws Error with helpful message if AA is not available
@@ -364,8 +347,8 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
     // Existing Wallet Methods
     // ============================================
 
-    getWallet(): Wallet {
-        return new Wallet(this.privateKey, this.connection);
+    getWallet(): WalletClient {
+        return this.wallet
     }
 
     generateAddress(): string {
@@ -383,7 +366,7 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
     }
 
     async getTokenInfo(tokenAddress: string) {
-        return await EVMVM.getTokenInfo(tokenAddress, this.connection!)
+        return await EVMVM.getTokenInfo(tokenAddress as Hex, this.connection!)
     }
 
     async discoverToken(): Promise<UserTokenBalance<string>[]> {
@@ -398,24 +381,38 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
 
     async transferNative(to: string, amount: number): Promise<TransactionResult> {
         const wallet = this.getWallet();
-        return await sendNativeToken(wallet, to, amount.toString(), undefined, this.config.confirmationNo || 5);
+        return await sendNativeToken(wallet, this.connection!, to as Hex, amount.toString(), this.config.confirmationNo || 5);
     }
 
     async transferToken(tokenAddress: TokenInfo, to: string, amount: number): Promise<TransactionResult> {
         const wallet = this.getWallet();
-        return await sendERC20Token(wallet, tokenAddress.address, to, amount.toString(), undefined, this.config.confirmationNo || 5);
+        return await sendERC20Token(wallet, this.connection!, tokenAddress.address as Hex, to as Hex, BigInt(amount.toString()), this.config.confirmationNo || 5);
     }
 
     async getTransactionHistory(): Promise<EVMTransactionHistoryItem[]> {
         const wallet = this.getWallet();
         let res: EVMTransactionHistoryItem
         try {
-            return await getEVMTransactionHistory(this.client, wallet.address as Hex);
+            return await getEVMTransactionHistory(this.connection!, this.address as Hex);
         } catch (error) {
             return []
         }
     }
 
+    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,
@@ -423,187 +420,12 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         amount: number,
         slippage: number = 50
     ): Promise<TransactionResult> {
-        if (amount <= 0) {
-            return {
-                success: false,
-                hash: "",
-                error: "Amount must be greater than 0"
-            };
-        }
-        const tokenOut: TokenInfo = {
-            address: to,
-            name: '',
-            symbol: '',
-            decimals: 18
-        };
-
-        return await this.performCompleteSwap(tokenAddress, tokenOut, amount, slippage);
+        throw new Error("Not Implemented")
     }
 
-    async performCompleteSwap(
-        tokenIn: TokenInfo,
-        tokenOut: TokenInfo,
-        amount: number,
-        slippage: number = 50,
-        recipient?: string,
-        deadline?: number
-    ): Promise<TransactionResult> {
-        try {
-            const wallet = this.getWallet();
-            const chainId = (await this.connection!.getNetwork()).chainId.toString();
-
-            console.log(` Starting swap on chain ${chainId}:`, {
-                from: tokenIn.symbol || tokenIn.address,
-                to: tokenOut.symbol || tokenOut.address,
-                amount: amount,
-                slippage: `${slippage / 100}%`
-            });
-
-            // Check if this is a 0G chain that should use Debonk
-            if (isChainSupportedByDebonk(chainId)) {
-                console.log('Using Debonk API for 0G chain swap');
-                return await this.performDebonkSwap(tokenIn, tokenOut, amount, slippage, recipient, deadline);
-            }
-
-            // Otherwise use Kyber (existing flow)
-            console.log('Using KyberSwap for non-0G chain swap');
-            return await this.performKyberSwap(tokenIn, tokenOut, amount, slippage, recipient, deadline);
-
-        } catch (error) {
-            console.error('Swap failed:', error);
-            throw new Error(`Swap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    private async performDebonkSwap(
-        tokenIn: TokenInfo,
-        tokenOut: TokenInfo,
-        amount: number,
-        slippage: number = 50,     // bps (e.g., 50 = 0.5%)
-        recipient?: string,
-        deadline?: number
-    ): Promise<DebonkSwapResult> {
-        try {
-            const BASE_URL = 'https://evm-api.deserialize.xyz';
-            const tokenInAddress = tokenIn.address;
-            const tokenOutAddress = tokenOut.address;
-
-            // Convert amount to wei (multiply by 10^18 for 18 decimal tokens)
-            const amountInWei = (amount * Math.pow(10, tokenIn.decimals || 18)).toString();
-
-            // Convert slippage from bps to percentage (e.g., 50 bps -> 0.5%)
-            const slippagePercentage = slippage / 100;
-
-
-            // Step 1: Get quote from API
-
-            const quotePayload = {
-                tokenA: tokenInAddress,
-                tokenB: tokenOutAddress,
-                amountIn: amountInWei, // Use wei amount
-                dexId: "ZERO_G"
-            };
-
-
-            const quoteResponse = await fetch(`${BASE_URL}/quote`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(quotePayload)
-            });
-
-            if (!quoteResponse.ok) {
-                const errorText = await quoteResponse.text();
-                console.error("Quote API error response:", errorText);
-                return this.fail(`Quote API failed: ${quoteResponse.status} ${errorText}`);
-            }
-
-            const quote: DebonkQuoteResponse = await quoteResponse.json();
-
-            // Step 2: Fix the quote dexId for swap API (it expects "ALL")
-            const modifiedQuote = {
-                ...quote,
-                dexId: "ALL"  // Change from "ZERO_G" to "ALL" as required by swap API
-            };
-
-            // Step 3: Get wallet address
-            const walletAddress = await this.getWallet().getAddress();
-
-            const swapPayload = {
-                publicKey: walletAddress,
-                slippage: slippagePercentage,
-                quote: modifiedQuote
-
-            };
-
-
-            const swapResponse = await fetch(`${BASE_URL}/swap`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(swapPayload)
-            });
-
-            if (!swapResponse.ok) {
-                const errorText = await swapResponse.text();
-                console.error("Swap API error response:", errorText);
-                return this.fail(`Swap API failed: ${swapResponse.status} ${errorText}`);
-            }
-
-            const swapData: DebonkSwapResponse = await swapResponse.json();
-
-            const wallet = this.getWallet();
-            let lastTxHash = '';
 
-            // Step 5: Execute each transaction sequentially
 
-            for (let i = 0; i < swapData.transactions.length; i++) {
-                const transaction = swapData.transactions[i];
 
-                // Prepare transaction object
-                const txRequest = {
-                    to: transaction.to,
-                    data: transaction.data,
-                    value: transaction.value,
-                    // gasPrice: 70000000000,
-                    // gasLimit: 70000, // Increase significantly
-                };
-
-                try {
-                    const txResponse = await wallet.sendTransaction(txRequest);
-                    console.log(`Transaction ${i + 1} sent:`, txResponse.hash);
-
-                    // Wait for confirmation
-                    const receipt = await txResponse.wait();
-
-                    if (!receipt) {
-                        return this.fail(`Transaction ${i + 1} failed - no receipt received`);
-                    }
-
-                    const txHash = receipt.hash || txResponse.hash;
-                    lastTxHash = txHash;
-
-
-                } catch (txError: any) {
-                    console.error(`Transaction ${i + 1} failed:`, txError);
-                    return this.fail(`Transaction ${i + 1} failed: ${txError?.message ?? String(txError)}`);
-                }
-            }
-
-
-
-            return {
-                success: true,
-                hash: lastTxHash // Return the hash of the last transaction
-            };
-
-        } catch (error: any) {
-            console.error("Debonk API swap error:", error);
-            return this.fail(`Debonk API swap failed: ${error?.message ?? String(error)}`);
-        }
-    }
 
     // Helper method for EVMChainWallet class
     private fail(message: string): DebonkSwapResult {
@@ -615,170 +437,9 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
     }
 
 
-    private async performKyberSwap(
-        tokenIn: TokenInfo,
-        tokenOut: TokenInfo,
-        amount: number,
-        slippage: number = 50,
-        recipient?: string,
-        deadline?: number
-    ): Promise<TransactionResult> {
-        try {
-            const wallet = this.getWallet();
-            const chainId = (await this.connection!.getNetwork()).chainId.toString();
-
-            if (!isChainSupportedByKyber(chainId)) {
-                throw new Error(`Chain ${chainId} is not supported by KyberSwap`);
-            }
-
-            const isNativeIn = tokenIn.address === 'native' ||
-                tokenIn.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-            const isNativeOut = tokenOut.address === 'native' ||
-                tokenOut.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-
-            let tokenInDecimals = 18;
-            if (!isNativeIn && tokenIn.decimals) {
-                tokenInDecimals = tokenIn.decimals;
-            } else if (!isNativeIn) {
-                const tokenBalance = await this.getTokenBalance(tokenIn.address);
-                tokenInDecimals = tokenBalance.decimal;
-            }
-
-            const { tokenInAddress, tokenOutAddress, formattedAmountIn } = prepareSwapParams(
-                tokenIn.address,
-                tokenOut.address,
-                amount.toString(),
-                tokenInDecimals,
-                isNativeIn,
-                isNativeOut
-            );
 
 
 
-            if (isNativeIn) {
-                const nativeBalance = await this.getNativeBalance();
-                const requiredAmount = new BN(formattedAmountIn);
-                if (nativeBalance.balance.lt(requiredAmount)) {
-                    throw new Error(`Insufficient native balance. Required: ${amount}, Available: ${nativeBalance.formatted}`);
-                }
-            } else {
-                const tokenBalance = await this.getTokenBalance(tokenIn.address);
-                const requiredAmount = new BN(formattedAmountIn);
-                if (tokenBalance.balance.lt(requiredAmount)) {
-                    throw new Error(`Insufficient token balance. Required: ${amount}, Available: ${tokenBalance.formatted}`);
-                }
-            }
-
-            const swapTx = await performSwap({
-                chainId,
-                tokenIn: tokenInAddress,
-                tokenOut: tokenOutAddress,
-                amountIn: formattedAmountIn,
-                sender: this.address,
-                recipient: recipient || this.address,
-                slippageTolerance: slippage,
-                deadline: deadline ? Math.floor(Date.now() / 1000) + deadline : Math.floor(Date.now() / 1000) + 1200, // 20 minutes default
-                clientId: 'EVMChainWallet'
-            });
-
-            console.log('Kyber swap transaction prepared:', {
-                to: swapTx.to,
-                dataLength: swapTx.data?.length || 0,
-                gasLimit: swapTx.gasLimit?.toString(),
-                value: swapTx.value?.toString()
-            });
-
-            if (!isNativeIn) {
-
-                const approvalResult = await checkAndApprove(
-                    wallet,
-                    tokenIn.address,
-                    swapTx.to,
-                    formattedAmountIn,
-                    undefined,
-                    undefined,
-                    this.config.confirmationNo || 1
-                );
-
-                if (approvalResult.approvalNeeded && approvalResult.approvalResult) {
-                    if (!approvalResult.approvalResult.success) {
-                        throw new Error('Token approval failed');
-                    }
-                    console.log('Token approval successful');
-                } else if (approvalResult.approvalNeeded) {
-                    throw new Error('Token approval was needed but failed');
-                } else {
-                    console.log('Token approval not needed - sufficient allowance');
-                }
-            }
-
-            const result = await signSendAndConfirm(
-                wallet,
-                {
-                    to: swapTx.to,
-                    data: swapTx.data,
-                    value: swapTx.value || '0',
-                    gasLimit: swapTx.gasLimit
-                },
-                this.config.confirmationNo || 1,
-            );
-
-
-            return result;
-
-        } catch (error) {
-
-            throw new Error(`Kyber swap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    async getSwapQuote(
-        tokenIn: TokenInfo,
-        tokenOut: TokenInfo,
-        amount: number
-    ): Promise<{
-        amountOut: string;
-        priceImpact: string;
-        gasEstimate: string;
-        route: string[];
-    }> {
-
-        try {
-            const chainId = (await this.connection!.getNetwork()).chainId.toString();
-
-            if (!isChainSupportedByKyber(chainId)) {
-                throw new Error(`Chain ${chainId} is not supported by KyberSwap`);
-            }
-
-            const isNativeIn = tokenIn.address === 'native' ||
-                tokenIn.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-            const isNativeOut = tokenOut.address === 'native' ||
-                tokenOut.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-
-            let tokenInDecimals = 18;
-            if (!isNativeIn && tokenIn.decimals) {
-                tokenInDecimals = tokenIn.decimals;
-            } else if (!isNativeIn) {
-                const tokenBalance = await this.getTokenBalance(tokenIn.address);
-                tokenInDecimals = tokenBalance.decimal;
-            }
-
-            const { tokenInAddress, tokenOutAddress, formattedAmountIn } = prepareSwapParams(
-                tokenIn.address,
-                tokenOut.address,
-                amount.toString(),
-                tokenInDecimals,
-                isNativeIn,
-                isNativeOut
-            );
-
-            throw new Error("Quote functionality requires direct API integration - use the swap method for full execution");
-
-        } catch (error) {
-            console.error('Error getting swap quote:', error);
-            throw error;
-        }
-    }
     async approveToken(params: {
         tokenAddress: string
         spender: string
@@ -787,303 +448,287 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         gasLimit?: string | bigint
     }): Promise<TransactionResult> {
         const signer = this.getWallet()
+
         const r = await approveToken(
             signer,
-            params.tokenAddress,
-            params.spender,
-            params.amountRaw,
-            params.gasLimit,
+            this.connection!,
+            params.tokenAddress as Hex,
+            params.spender as Hex,
+            BigInt(params.amountRaw),
             params.confirmations ?? this.config.confirmationNo ?? 1,
         )
-        return {
-            hash: r.hash,
-            success: r.success,
-            error: (r as any).error,
-        }
-    }
 
-    async executeContractMethod(params: {
-        contractAddress: string
-        abi: any[]
-        methodName: string
-        methodParams?: any[]
-        value?: string | bigint
-        gasLimit?: string | bigint
-        confirmations?: number
-    }): Promise<TransactionResult> {
-        const signer = this.getWallet()
-        const r = await executeContractMethod(
-            signer,
-            params.contractAddress,
-            params.abi,
-            params.methodName,
-            params.methodParams ?? [],
-            params.value,
-        )
         return {
             hash: r.hash,
             success: r.success,
-            error: (r as any).error,
         }
     }
-    async signMessage(message: string): Promise<string> {
-        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;
-    }
+    async signMessage(message: string): Promise<string> {
 
-    /**
-     * 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);
-        }
-    }
+        const signer = this.wallet
 
-    /**
-     * 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;
+        if (!signer.account) {
+            throw new Error("Account is required for signing, signer.account from this.wallet is undefined")
         }
-    }
+        return signer.signMessage({ message, account: signer.account?.address })
+    }
+
+    // // ============================================
+    // // 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;
+    //     }
+    // }
 }