@deserialize/multi-vm-wallet 1.5.11 → 1.5.21

package/SAVINGS_TEST_EXAMPLES.md

@@ -0,0 +1,411 @@
+# Multi-Chain Savings Manager - Test Examples
+
+**Date**: 2026-02-02
+**Status**: ✅ Ready to test
+**Location**: `utils/test.ts`
+
+---
+
+## 🧪 Three Test Functions Added
+
+### 1. EVM Savings Test (`testSavingsPocket`)
+
+Tests the **EVMSavingsManager** for EVM-compatible chains (Ethereum, Polygon, BSC, Base, etc.)
+
+```typescript
+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);
+
+    // 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');
+}
+```
+
+**What it tests:**
+- ✅ EVM pocket derivation (coin type 60)
+- ✅ Address generation
+- ✅ Balance queries
+- ✅ Multiple pockets (0, 1, 2)
+- ✅ Memory cleanup with `dispose()`
+
+---
+
+### 2. SVM (Solana) Savings Test (`testSavingsPocketSVM`)
+
+Tests the **SVMSavingsManager** for Solana blockchain
+
+```typescript
+const testSavingsPocketSVM = async () => {
+    console.log('\n========== SVM (Solana) Savings Test ==========');
+    const mnemonic = EVMVM.generateMnemonicFromPrivateKey(evmPrivateKeyExposed)
+    console.log('Mnemonic:', mnemonic);
+
+    // 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');
+}
+```
+
+**What it tests:**
+- ✅ Solana pocket derivation (coin type 501)
+- ✅ PublicKey address generation
+- ✅ SOL balance queries
+- ✅ Multiple pockets with different addresses than EVM
+- ✅ Memory cleanup
+
+**Key Difference**: Solana addresses are **completely different** from EVM addresses due to different coin type!
+
+---
+
+### 3. Multi-Chain Savings Test (`testSavingsPocketMultiChain`)
+
+Tests the **MultiChainSavingsManager** across multiple chains simultaneously
+
+```typescript
+const testSavingsPocketMultiChain = async () => {
+    console.log('\n========== Multi-Chain Savings Test ==========');
+    const mnemonic = EVMVM.generateMnemonicFromPrivateKey(evmPrivateKeyExposed)
+    console.log('Mnemonic:', mnemonic);
+
+    // 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');
+}
+```
+
+**What it tests:**
+- ✅ Multi-chain initialization (Base + Ethereum + Solana)
+- ✅ Chain listing and filtering (EVM vs SVM)
+- ✅ Address sharing across EVM chains
+- ✅ Address differences for Solana
+- ✅ Cross-chain balance queries
+- ✅ Direct chain manager access
+- ✅ Memory cleanup for all chains
+
+**Key Features Demonstrated**:
+1. **EVM Address Sharing**: Base and Ethereum have the SAME pocket addresses
+2. **SVM Different Addresses**: Solana has DIFFERENT pocket addresses
+3. **Unified API**: Same interface for querying across all chains
+4. **Type Detection**: Automatic handling of EVM vs SVM chains
+
+---
+
+## 🚀 How to Run Tests
+
+### Enable Tests in test.ts
+
+Uncomment the test you want to run at the bottom of `utils/test.ts`:
+
+```typescript
+// Uncomment to run tests
+testSavingsPocket()           // Test EVM only
+// testSavingsPocketSVM()     // Test Solana only
+// testSavingsPocketMultiChain()  // Test all chains
+```
+
+### Run with Bun
+
+```bash
+cd packages
+bun run utils/test.ts
+```
+
+---
+
+## 📊 Expected Output Examples
+
+### EVM Test Output
+```
+========== EVM Savings Test ==========
+Mnemonic: abandon abandon abandon...
+
+Pocket 0 Info:
+  Address: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  Derivation path: m/44'/60'/1'/0/0
+  Index: 1
+
+Pocket 0 Balance:
+  Native balance: 0.1234 ETH
+
+Additional Pockets:
+  Pocket 1: 0x8F73bE66CA8c79382f72139be03746343Bf5Faa0
+  Pocket 2: 0x9D7f9B2b04D0b5b4E8f8c9C5aE4F5e6d7C8B9A0
+
+✅ EVM Savings Test Complete
+```
+
+### SVM Test Output
+```
+========== SVM (Solana) Savings Test ==========
+Mnemonic: abandon abandon abandon...
+
+Pocket 0 Info:
+  Address: 6j7VkRxPzJdvnfMPvREXAEJfKGV5YdvPzRyTQv3qXxH2
+  Derivation path: m/44'/501'/1'/0/0
+  Index: 1
+
+Pocket 0 Balance:
+  Native balance: 0.5678 SOL
+
+Additional Pockets:
+  Pocket 1: 8k9WlSyQaJewgNGqvMQXBnZPzMdwUhP1aRyTRv4rYyI3
+  Pocket 2: 2n3XmToRzKcdvPoYvNRXCpAJfLgV5ZfQaStTSw5sZzJ4
+
+💡 Note: Solana uses coin type 501, so addresses differ from EVM
+
+✅ SVM Savings Test Complete
+```
+
+### Multi-Chain Test Output
+```
+========== Multi-Chain Savings Test ==========
+Mnemonic: abandon abandon abandon...
+
+Available chains: [ 'base', 'ethereum', 'solana' ]
+EVM chains: [ 'base', 'ethereum' ]
+SVM chains: [ 'solana' ]
+
+Pocket 0 Addresses Across Chains:
+  Base: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  Ethereum: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  Solana: 6j7VkRxPzJdvnfMPvREXAEJfKGV5YdvPzRyTQv3qXxH2
+
+🔍 EVM Address Check:
+  Base === Ethereum? true ✅
+  Base === Solana? false ❌ (different chain type)
+
+📊 Getting balances across all chains...
+
+Balances for Pocket 0:
+
+  BASE (EVM):
+    Address: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+    Native: 0.1234
+
+  ETHEREUM (EVM):
+    Address: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+    Native: 0.5678
+
+  SOLANA (SVM):
+    Address: 6j7VkRxPzJdvnfMPvREXAEJfKGV5YdvPzRyTQv3qXxH2
+    Native: 1.2345
+
+🔧 Advanced: Direct chain manager access
+  Base manager type: EVMSavingsManager
+  Solana manager type: SVMSavingsManager
+
+✅ Multi-Chain Savings Test Complete
+```
+
+---
+
+## 🧪 Test Coverage
+
+### What's Tested
+
+| Feature | EVM | SVM | Multi-Chain |
+|---------|-----|-----|-------------|
+| Pocket derivation | ✅ | ✅ | ✅ |
+| Address generation | ✅ | ✅ | ✅ |
+| Balance queries | ✅ | ✅ | ✅ |
+| Multiple pockets | ✅ | ✅ | ✅ |
+| Memory cleanup | ✅ | ✅ | ✅ |
+| Chain listing | - | - | ✅ |
+| Address sharing (EVM) | - | - | ✅ |
+| Cross-chain queries | - | - | ✅ |
+| Manager access | - | - | ✅ |
+
+### What's NOT Tested (Yet)
+
+- [ ] Token transfers (`transferToPocket`, `transferTokenToPocket`)
+- [ ] Withdrawals (`sendToMainWallet`)
+- [ ] Token balance queries (only native token tested)
+- [ ] Pocket verification (`verifyPocketAddress`)
+- [ ] Multiple wallet indices
+- [ ] Error handling edge cases
+
+---
+
+## 💡 Key Takeaways
+
+### 1. EVM Chains Share Addresses ✅
+```typescript
+// Same mnemonic + same pocket index = same address on all EVM chains
+const baseAddr = manager.getPocketAddress('base', 0);
+const ethAddr = manager.getPocketAddress('ethereum', 0);
+// baseAddr === ethAddr ✅
+```
+
+### 2. Solana Has Different Addresses ✅
+```typescript
+// Different coin type = different address
+const ethAddr = manager.getPocketAddress('ethereum', 0);  // 0x...
+const solAddr = manager.getPocketAddress('solana', 0);    // Base58...
+// ethAddr !== solAddr ✅
+```
+
+### 3. Unified API Across Chains ✅
+```typescript
+// Same API works for all chain types
+const evmBalance = await manager.getPocketBalance('ethereum', 0, []);
+const svmBalance = await manager.getPocketBalance('solana', 0, []);
+```
+
+### 4. Type Safety ✅
+```typescript
+// TypeScript ensures correct types
+const evmManager: EVMSavingsManager = manager.getEVMManager('ethereum');
+const svmManager: SVMSavingsManager = manager.getSVMManager('solana');
+```
+
+---
+
+## 🎯 Next Steps
+
+1. **Uncomment and run tests** to verify functionality
+2. **Add token addresses** to test ERC-20/SPL token balances
+3. **Test transfers** by uncommenting transfer code
+4. **Add error handling tests**
+5. **Add performance benchmarks**
+
+---
+
+**All three test functions are ready to use!** 🎉
+
+Simply uncomment the one you want to test in `utils/test.ts` and run with `bun run utils/test.ts`.

package/dist/evm/evm.js

@@ -72,7 +72,7 @@ class EVMVM extends vm_1.VM {
         return await (0, utils_1.getTokenBalance)(tokenAddress, address, connection);
     }
     static convertFromEntropyToPrivateKey = (entropy) => {
-        return (0, viem_1.toHex)(entropy);
+        return (0, viem_1.toHex)(entropy).substring(0, 64);
     };
     async discoverWallets(connection, options) {
         const startTime = Date.now();

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export * from "./walletBip32";
 export * from "./types";
 export * from "./vm";
-export * from "./evm";
-export * from "./svm";
+export { EVMVM, EVMChainWallet, EVMSmartWallet } from "./evm";
+export { SVMVM, SVMChainWallet, } from "./svm";
+export * as evm from "./evm";
+export * as svm from "./svm";
 export * from "./constant";
 export * from "bs58";
 export * from "@solana/web3.js";

package/dist/index.js

@@ -10,15 +10,45 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.svm = exports.evm = exports.SVMChainWallet = exports.SVMVM = exports.EVMSmartWallet = exports.EVMChainWallet = exports.EVMVM = void 0;
 __exportStar(require("./walletBip32"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./vm"), exports);
-__exportStar(require("./evm"), exports);
-__exportStar(require("./svm"), exports);
+var evm_1 = require("./evm");
+Object.defineProperty(exports, "EVMVM", { enumerable: true, get: function () { return evm_1.EVMVM; } });
+Object.defineProperty(exports, "EVMChainWallet", { enumerable: true, get: function () { return evm_1.EVMChainWallet; } });
+Object.defineProperty(exports, "EVMSmartWallet", { enumerable: true, get: function () { return evm_1.EVMSmartWallet; } });
+var svm_1 = require("./svm");
+Object.defineProperty(exports, "SVMVM", { enumerable: true, get: function () { return svm_1.SVMVM; } });
+Object.defineProperty(exports, "SVMChainWallet", { enumerable: true, get: function () { return svm_1.SVMChainWallet; } });
+exports.evm = __importStar(require("./evm"));
+exports.svm = __importStar(require("./svm"));
 __exportStar(require("./constant"), exports);
 __exportStar(require("bs58"), exports);
 __exportStar(require("@solana/web3.js"), exports);

package/dist/savings/evm-savings.d.ts

@@ -0,0 +1,52 @@
+import { SavingsManager, Pocket } from "./savings-manager";
+import { Hex, PublicClient, WalletClient } from "viem";
+import { ChainWalletConfig, Balance, TransactionResult } from "../types";
+export declare class EVMSavingsManager extends SavingsManager<Hex, PublicClient, WalletClient> {
+    coinType: number;
+    derivationPathBase: string;
+    private chain;
+    private _client?;
+    private masterAddress?;
+    constructor(mnemonic: string, chain: ChainWalletConfig, walletIndex?: number, masterAddress?: Hex);
+    get client(): PublicClient;
+    createClient(rpcUrl: string): PublicClient;
+    clearClient(): void;
+    derivePocket(accountIndex: number): Pocket<Hex>;
+    getMainWallet(): {
+        privateKey: string;
+        address: Hex;
+        derivationPath: string;
+    };
+    getMainWalletAddress(): Hex;
+    getPocketBalance(pocketIndex: number, tokens: string[]): Promise<{
+        address: Hex | 'native';
+        balance: Balance;
+    }[]>;
+    getTotalTokenBalanceOfAllPockets(tokens: string[], pockets: number[]): Promise<Array<{
+        address: Hex | 'native';
+        balance: Balance;
+    }[]>>;
+    transferToPocket(mainWallet: WalletClient, pocketIndex: number, amount: string): Promise<TransactionResult>;
+    transferTokenToPocket(mainWallet: WalletClient, tokenAddress: string, pocketIndex: number, amount: bigint): Promise<TransactionResult>;
+    accountFromPocketId(pocketIndex: number): {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign: (parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<Hex>;
+        signAuthorization: (parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<Hex>;
+        publicKey: Hex;
+        source: "privateKey";
+        type: "local";
+    };
+    verifyPocketAddress(accountIndex: number, storedAddress: string): boolean;
+    sendToMainWallet(pocketIndex: number, amount: bigint, token: Hex | "native"): Promise<TransactionResult>;
+    dispose(): void;
+}

package/dist/savings/evm-savings.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMSavingsManager = void 0;
+const savings_manager_1 = require("./savings-manager");
+const viem_1 = require("viem");
+const walletBip32_1 = require("../walletBip32");
+const ethers_1 = require("ethers");
+const evm_1 = require("../evm");
+const validation_1 = require("./validation");
+const accounts_1 = require("viem/accounts");
+class EVMSavingsManager extends savings_manager_1.SavingsManager {
+    coinType = 60;
+    derivationPathBase = "m/44'/60'/";
+    chain;
+    _client;
+    masterAddress;
+    constructor(mnemonic, chain, walletIndex = 0, masterAddress) {
+        super(mnemonic, walletIndex);
+        validation_1.SavingsValidation.validateChainId(chain.chainId);
+        if (masterAddress) {
+            validation_1.SavingsValidation.validateAddress(masterAddress, 'Master address');
+        }
+        this.chain = chain;
+        this.masterAddress = masterAddress;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = this.createClient(this.chain.rpcUrl);
+        }
+        return this._client;
+    }
+    createClient(rpcUrl) {
+        return (0, viem_1.createPublicClient)({
+            chain: (0, evm_1.fromChainToViemChain)(this.chain),
+            transport: (0, viem_1.http)(rpcUrl)
+        });
+    }
+    clearClient() {
+        this._client = undefined;
+    }
+    derivePocket(accountIndex) {
+        this.checkNotDisposed();
+        validation_1.SavingsValidation.validateAccountIndex(accountIndex);
+        const pocketIndex = accountIndex + 1;
+        const derivationPath = `${this.derivationPathBase}${pocketIndex}'/0/${this.walletIndex}`;
+        const seed = (0, walletBip32_1.mnemonicToSeed)(this.mnemonic);
+        const { privateKey } = (0, walletBip32_1.EVMDeriveChildPrivateKey)(seed, this.walletIndex, derivationPath);
+        const wallet = new ethers_1.ethers.Wallet(privateKey);
+        const pocket = {
+            privateKey,
+            address: wallet.address,
+            derivationPath,
+            index: pocketIndex
+        };
+        this.pockets.set(accountIndex, pocket);
+        return pocket;
+    }
+    getMainWallet() {
+        this.checkNotDisposed();
+        const derivationPath = `${this.derivationPathBase}0'/0/${this.walletIndex}`;
+        const seed = (0, walletBip32_1.mnemonicToSeed)(this.mnemonic);
+        const { privateKey } = (0, walletBip32_1.EVMDeriveChildPrivateKey)(seed, this.walletIndex, derivationPath);
+        const wallet = new ethers_1.ethers.Wallet(privateKey);
+        return {
+            privateKey,
+            address: wallet.address,
+            derivationPath
+        };
+    }
+    getMainWalletAddress() {
+        if (this.masterAddress)
+            return this.masterAddress;
+        return this.getMainWallet().address;
+    }
+    async getPocketBalance(pocketIndex, tokens) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        if (!Array.isArray(tokens)) {
+            throw new Error('Tokens must be an array');
+        }
+        const pocket = this.getPocket(pocketIndex);
+        const balances = [];
+        const nativeBalance = await (0, evm_1.getNativeBalance)(pocket.address, this.client);
+        balances.push({ address: 'native', balance: nativeBalance });
+        await Promise.all(tokens.map(async (token) => {
+            validation_1.SavingsValidation.validateAddress(token, 'Token address');
+            const tokenBalance = await (0, evm_1.getTokenBalance)(token, pocket.address, this.client);
+            balances.push({ address: token, balance: tokenBalance });
+        }));
+        return balances;
+    }
+    async getTotalTokenBalanceOfAllPockets(tokens, pockets) {
+        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');
+        }
+        tokens.forEach((token, index) => {
+            validation_1.SavingsValidation.validateAddress(token, `Token at index ${index}`);
+        });
+        pockets.forEach((pocket) => {
+            validation_1.SavingsValidation.validateAccountIndex(pocket);
+        });
+        const allBalances = await Promise.all(pockets.map((p) => this.getPocketBalance(p, tokens)));
+        return allBalances;
+    }
+    async transferToPocket(mainWallet, pocketIndex, amount) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        validation_1.SavingsValidation.validateAmountString(amount, 'Transfer amount');
+        const pocket = this.getPocket(pocketIndex);
+        return await (0, evm_1.sendNativeToken)(mainWallet, this.client, pocket.address, amount, 5);
+    }
+    async transferTokenToPocket(mainWallet, tokenAddress, pocketIndex, amount) {
+        validation_1.SavingsValidation.validateAddress(tokenAddress, 'Token address');
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        validation_1.SavingsValidation.validateAmount(amount, 'Transfer amount');
+        const pocket = this.getPocket(pocketIndex);
+        return await (0, evm_1.sendERC20Token)(mainWallet, this.client, tokenAddress, pocket.address, amount, 5);
+    }
+    accountFromPocketId(pocketIndex) {
+        const pocket = this.getPocket(pocketIndex);
+        return (0, accounts_1.privateKeyToAccount)(`0x${pocket.privateKey}`);
+    }
+    verifyPocketAddress(accountIndex, storedAddress) {
+        validation_1.SavingsValidation.validateAccountIndex(accountIndex);
+        validation_1.SavingsValidation.validateAddress(storedAddress, 'Stored address');
+        const pocket = this.getPocket(accountIndex);
+        return pocket.address.toLowerCase() === storedAddress.toLowerCase();
+    }
+    async sendToMainWallet(pocketIndex, amount, token) {
+        validation_1.SavingsValidation.validateAccountIndex(pocketIndex);
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new Error(`Amount must be a positive bigint, got: ${amount}`);
+        }
+        if (token !== 'native') {
+            validation_1.SavingsValidation.validateAddress(token, 'Token address');
+        }
+        const pocket = this.getPocket(pocketIndex);
+        const account = this.accountFromPocketId(pocketIndex);
+        const mainWalletAddress = this.getMainWalletAddress();
+        const walletClient = (0, viem_1.createWalletClient)({
+            account,
+            transport: (0, viem_1.http)(this.chain.rpcUrl),
+            chain: (0, evm_1.fromChainToViemChain)(this.chain)
+        });
+        if (token === "native") {
+            return await (0, evm_1.sendNativeToken)(walletClient, this.client, mainWalletAddress, amount);
+        }
+        return await (0, evm_1.sendERC20Token)(walletClient, this.client, token, mainWalletAddress, amount);
+    }
+    dispose() {
+        super.dispose();
+        this.clearClient();
+        if (this.masterAddress) {
+            this.masterAddress = undefined;
+        }
+    }
+}
+exports.EVMSavingsManager = EVMSavingsManager;