@deserialize/multi-vm-wallet 1.4.12 → 1.5.1

package/dist/evm/evm.js

@@ -1,14 +1,10 @@
 "use strict";
-/**
- *
- * @param phrase this is the pass phrase for this vm
- * this is a class that will be responsible for creating several evm wallets code
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMChainWallet = exports.EVMVM = void 0;
 const walletBip32_1 = require("../walletBip32");
 const IChainWallet_1 = require("../IChainWallet");
 const vm_1 = require("../vm");
+const vm_validation_1 = require("../vm-validation");
 const ethers_1 = require("ethers");
 const utils_1 = require("./utils");
 const transactionParsing_1 = require("./transactionParsing");
@@ -17,78 +13,383 @@ const smartWallet_1 = require("./smartWallet");
 const price_1 = require("../price");
 const accounts_1 = require("viem/accounts");
 class EVMVM extends vm_1.VM {
-    derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
+    derivationPath = "m/44'/60'/0'/0/";
     constructor(seed) {
         super(seed, "EVM");
     }
     getTokenInfo = utils_1.getTokenInfo;
     static getTokenInfo = utils_1.getTokenInfo;
     generatePrivateKey(index, seed, mnemonic, derivationPath = this.derivationPath) {
+        vm_validation_1.VMValidation.validateIndex(index, 'Wallet index');
         let _seed;
         if (seed) {
+            vm_validation_1.VMValidation.validateSeed(seed);
             _seed = seed;
         }
         else if (mnemonic) {
+            vm_validation_1.VMValidation.validateMnemonic(mnemonic);
             _seed = vm_1.VM.mnemonicToSeed(mnemonic);
         }
         else {
+            this.checkNotDisposed();
             _seed = this.seed;
         }
         const privateKey = (0, walletBip32_1.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) {
-        // 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 = (0, walletBip32_1.EVMDeriveChildPrivateKey)(this.seed, 0, `m/44'/60'/${accountIndex}'/0/`);
-        const privateKey = result.privateKey;
-        // Derive address from private key
-        const wallet = new ethers_1.ethers.Wallet(privateKey);
-        const address = wallet.address;
-        return {
-            privateKey,
-            address,
-            derivationPath
-        };
+    static generateMnemonicFromPrivateKey(privateKey) {
+        return (0, walletBip32_1.EntropyToMnemonic)(privateKey);
     }
     static fromMnemonic(mnemonic) {
         const seed = vm_1.VM.mnemonicToSeed(mnemonic);
         return new EVMVM(seed);
     }
-    static validateAddress(address) {
-        return ethers_1.ethers.isAddress(address);
+    static validateAddress(address, requireChecksum = false) {
+        if (!ethers_1.ethers.isAddress(address)) {
+            return false;
+        }
+        if (requireChecksum && address !== address.toLowerCase() && address !== address.toUpperCase()) {
+            try {
+                const checksummed = ethers_1.ethers.getAddress(address);
+                return checksummed === address;
+            }
+            catch {
+                return false;
+            }
+        }
+        return true;
+    }
+    static normalizeAddress(address) {
+        if (!this.validateAddress(address)) {
+            throw new Error(`Invalid Ethereum address: ${address}`);
+        }
+        return ethers_1.ethers.getAddress(address);
     }
     static async getNativeBalance(address, connection) {
-        // Implement native balance retrieval logic here
         return await (0, utils_1.getNativeBalance)(address, connection);
     }
     static async getTokenBalance(address, tokenAddress, connection) {
-        // Implement token balance retrieval logic here
         return await (0, utils_1.getTokenBalance)(tokenAddress, address, connection);
     }
     static convertFromEntropyToPrivateKey = (entropy) => {
         return (0, viem_1.toHex)(entropy);
     };
+    async discoverWallets(connection, options) {
+        const startTime = Date.now();
+        const checkInParallel = options?.checkInParallel ?? true;
+        const opts = {
+            startIndex: options?.startIndex ?? 0,
+            maxIndex: options?.maxIndex ?? 100,
+            gapLimit: options?.gapLimit ?? 20,
+            minBalance: options?.minBalance ?? 0n,
+            includeZeroBalance: options?.includeZeroBalance ?? false,
+            includePrivateKeys: options?.includePrivateKeys ?? false,
+            checkInParallel,
+            batchSize: options?.batchSize ?? 10,
+            checkDelay: options?.checkDelay ?? (checkInParallel ? 200 : 50),
+            onProgress: options?.onProgress ?? (() => { }),
+            onDiscovered: options?.onDiscovered ?? (() => { }),
+        };
+        const discovered = [];
+        let gapCounter = 0;
+        let highestIndex = opts.startIndex;
+        let stoppedByGapLimit = false;
+        const isViem = 'readContract' in connection;
+        if (opts.checkInParallel) {
+            for (let i = opts.startIndex; i <= opts.maxIndex; i += opts.batchSize) {
+                if (gapCounter >= opts.gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+                const batchIndices = Array.from({ length: Math.min(opts.batchSize, opts.maxIndex - i + 1) }, (_, idx) => i + idx);
+                const batchResults = await Promise.all(batchIndices.map(index => this.checkWalletBalance(index, connection, isViem)));
+                for (let j = 0; j < batchResults.length; j++) {
+                    const result = batchResults[j];
+                    const index = batchIndices[j];
+                    highestIndex = index;
+                    if (result) {
+                        const meetsMinBalance = result.nativeBalance.amount >= opts.minBalance;
+                        if (meetsMinBalance || opts.includeZeroBalance) {
+                            if (!opts.includePrivateKeys) {
+                                delete result.privateKey;
+                            }
+                            discovered.push(result);
+                            opts.onDiscovered(result);
+                            if (meetsMinBalance) {
+                                gapCounter = 0;
+                            }
+                            else {
+                                gapCounter++;
+                            }
+                        }
+                        else {
+                            gapCounter++;
+                        }
+                    }
+                    else {
+                        gapCounter++;
+                    }
+                    opts.onProgress(index + 1 - opts.startIndex, opts.maxIndex - opts.startIndex + 1, discovered.length);
+                    if (gapCounter >= opts.gapLimit) {
+                        stoppedByGapLimit = true;
+                        break;
+                    }
+                }
+                if (i + opts.batchSize <= opts.maxIndex && !stoppedByGapLimit) {
+                    await this.sleep(opts.checkDelay);
+                }
+            }
+        }
+        else {
+            for (let index = opts.startIndex; index <= opts.maxIndex; index++) {
+                if (gapCounter >= opts.gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+                const result = await this.checkWalletBalance(index, connection, isViem);
+                highestIndex = index;
+                if (result) {
+                    const meetsMinBalance = result.nativeBalance.amount >= opts.minBalance;
+                    if (meetsMinBalance || opts.includeZeroBalance) {
+                        if (!opts.includePrivateKeys) {
+                            delete result.privateKey;
+                        }
+                        discovered.push(result);
+                        opts.onDiscovered(result);
+                        if (meetsMinBalance) {
+                            gapCounter = 0;
+                        }
+                        else {
+                            gapCounter++;
+                        }
+                    }
+                    else {
+                        gapCounter++;
+                    }
+                }
+                else {
+                    gapCounter++;
+                }
+                opts.onProgress(index + 1 - opts.startIndex, opts.maxIndex - opts.startIndex + 1, discovered.length);
+                if (index < opts.maxIndex && !stoppedByGapLimit) {
+                    await this.sleep(opts.checkDelay);
+                }
+            }
+        }
+        const totalBalance = discovered.reduce((sum, wallet) => sum + wallet.nativeBalance.amount, 0n);
+        const duration = Date.now() - startTime;
+        return {
+            discovered,
+            scannedIndices: highestIndex - opts.startIndex + 1,
+            highestIndex,
+            totalBalance,
+            stoppedByGapLimit,
+            duration,
+        };
+    }
+    async checkWalletBalance(index, connection, isViem, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const { privateKey } = this.generatePrivateKey(index);
+                const wallet = new ethers_1.ethers.Wallet(privateKey);
+                const address = wallet.address;
+                let balanceWei;
+                if (isViem) {
+                    const viemConnection = connection;
+                    balanceWei = await viemConnection.getBalance({ address: address });
+                }
+                else {
+                    const ethersConnection = connection;
+                    balanceWei = await ethersConnection.getBalance(address);
+                }
+                const formatted = Number(ethers_1.ethers.formatEther(balanceWei));
+                return {
+                    index,
+                    address,
+                    derivationPath: `${this.derivationPath}${index}'`,
+                    nativeBalance: {
+                        amount: balanceWei,
+                        formatted,
+                        symbol: 'ETH',
+                    },
+                    privateKey,
+                };
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    console.warn(`Failed to check wallet at index ${index} after ${maxRetries} attempts:`, error);
+                    return null;
+                }
+                const delay = Math.pow(2, attempt) * 1000;
+                await this.sleep(delay);
+            }
+        }
+        return null;
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async discoverPockets(connection, options) {
+        const startTime = Date.now();
+        const walletIndex = options?.walletIndex ?? 0;
+        const checkInParallel = options?.checkInParallel ?? true;
+        const opts = {
+            startIndex: options?.startIndex ?? 0,
+            maxIndex: options?.maxIndex ?? 100,
+            gapLimit: options?.gapLimit ?? 20,
+            minBalance: options?.minBalance ?? 0n,
+            includeZeroBalance: options?.includeZeroBalance ?? false,
+            includePrivateKeys: options?.includePrivateKeys ?? false,
+            checkInParallel,
+            batchSize: options?.batchSize ?? 10,
+            checkDelay: options?.checkDelay ?? (checkInParallel ? 200 : 50),
+            onProgress: options?.onProgress ?? (() => { }),
+            onDiscovered: options?.onDiscovered ?? (() => { }),
+            walletIndex,
+        };
+        const discovered = [];
+        let gapCounter = 0;
+        let highestIndex = opts.startIndex;
+        let stoppedByGapLimit = false;
+        const isViem = 'readContract' in connection;
+        if (opts.checkInParallel) {
+            for (let i = opts.startIndex; i <= opts.maxIndex; i += opts.batchSize) {
+                if (gapCounter >= opts.gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+                const batchIndices = Array.from({ length: Math.min(opts.batchSize, opts.maxIndex - i + 1) }, (_, idx) => i + idx);
+                const batchResults = await Promise.all(batchIndices.map(index => this.checkPocketBalance(index, walletIndex, connection, isViem)));
+                for (let j = 0; j < batchResults.length; j++) {
+                    const result = batchResults[j];
+                    const index = batchIndices[j];
+                    highestIndex = index;
+                    if (result) {
+                        const meetsMinBalance = result.nativeBalance.amount >= opts.minBalance;
+                        if (meetsMinBalance || opts.includeZeroBalance) {
+                            if (!opts.includePrivateKeys) {
+                                delete result.privateKey;
+                            }
+                            discovered.push(result);
+                            opts.onDiscovered(result);
+                            if (meetsMinBalance) {
+                                gapCounter = 0;
+                            }
+                            else {
+                                gapCounter++;
+                            }
+                        }
+                        else {
+                            gapCounter++;
+                        }
+                    }
+                    else {
+                        gapCounter++;
+                    }
+                    opts.onProgress(index + 1 - opts.startIndex, opts.maxIndex - opts.startIndex + 1, discovered.length);
+                    if (gapCounter >= opts.gapLimit) {
+                        stoppedByGapLimit = true;
+                        break;
+                    }
+                }
+                if (i + opts.batchSize <= opts.maxIndex && !stoppedByGapLimit) {
+                    await this.sleep(opts.checkDelay);
+                }
+            }
+        }
+        else {
+            for (let index = opts.startIndex; index <= opts.maxIndex; index++) {
+                if (gapCounter >= opts.gapLimit) {
+                    stoppedByGapLimit = true;
+                    break;
+                }
+                const result = await this.checkPocketBalance(index, walletIndex, connection, isViem);
+                highestIndex = index;
+                if (result) {
+                    const meetsMinBalance = result.nativeBalance.amount >= opts.minBalance;
+                    if (meetsMinBalance || opts.includeZeroBalance) {
+                        if (!opts.includePrivateKeys) {
+                            delete result.privateKey;
+                        }
+                        discovered.push(result);
+                        opts.onDiscovered(result);
+                        if (meetsMinBalance) {
+                            gapCounter = 0;
+                        }
+                        else {
+                            gapCounter++;
+                        }
+                    }
+                    else {
+                        gapCounter++;
+                    }
+                }
+                else {
+                    gapCounter++;
+                }
+                opts.onProgress(index + 1 - opts.startIndex, opts.maxIndex - opts.startIndex + 1, discovered.length);
+                if (index < opts.maxIndex && !stoppedByGapLimit) {
+                    await this.sleep(opts.checkDelay);
+                }
+            }
+        }
+        const totalBalance = discovered.reduce((sum, wallet) => sum + wallet.nativeBalance.amount, 0n);
+        const duration = Date.now() - startTime;
+        return {
+            discovered,
+            scannedIndices: highestIndex - opts.startIndex + 1,
+            highestIndex,
+            totalBalance,
+            stoppedByGapLimit,
+            duration,
+        };
+    }
+    async checkPocketBalance(accountIndex, walletIndex, connection, isViem, maxRetries = 3) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const pocketIndex = accountIndex + 1;
+                const derivationPath = `m/44'/60'/${pocketIndex}'/0/${walletIndex}'`;
+                const { privateKey } = (0, walletBip32_1.EVMDeriveChildPrivateKey)(this.seed, walletIndex, `m/44'/60'/${pocketIndex}'/0/`);
+                const wallet = new ethers_1.ethers.Wallet(privateKey);
+                const address = wallet.address;
+                let balanceWei;
+                if (isViem) {
+                    const viemConnection = connection;
+                    balanceWei = await viemConnection.getBalance({ address: address });
+                }
+                else {
+                    const ethersConnection = connection;
+                    balanceWei = await ethersConnection.getBalance(address);
+                }
+                const formatted = Number(ethers_1.ethers.formatEther(balanceWei));
+                return {
+                    index: accountIndex,
+                    address,
+                    derivationPath,
+                    nativeBalance: {
+                        amount: balanceWei,
+                        formatted,
+                        symbol: 'ETH',
+                    },
+                    privateKey,
+                };
+            }
+            catch (error) {
+                if (attempt === maxRetries - 1) {
+                    console.warn(`Failed to check pocket at account ${accountIndex} after ${maxRetries} attempts:`, error);
+                    return null;
+                }
+                const delay = Math.pow(2, attempt) * 1000;
+                await this.sleep(delay);
+            }
+        }
+        return null;
+    }
 }
 exports.EVMVM = EVMVM;
 class EVMChainWallet extends IChainWallet_1.ChainWallet {
     wallet;
     smartWallet;
-    // private savingsManager?: SavingsManager
-    // private smartSavingsManager?: SmartSavingsManager
     constructor(config, privateKey, index) {
         privateKey = privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`;
         super(config, privateKey, index);
@@ -105,33 +406,15 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
         this.address = account.address;
         this.privateKey = privateKey;
     }
-    // ============================================
-    // Smart Wallet Extension Methods
-    // ============================================
-    /**
-     * Check if Account Abstraction is supported on this chain
-     * @returns true if aaSupport is enabled in config
-     */
     isAASupportedByChain() {
         return this.config.aaSupport?.enabled === true;
     }
     convertFromEntropyToPrivateKey = (entropy) => {
         return (0, viem_1.toHex)(entropy);
     };
-    /**
-     * Check if smart wallet is initialized and ready for AA operations
-     * @returns true if extend() has been called and smart wallet exists
-     */
     isSmartWalletInitialized() {
         return !!this.smartWallet;
     }
-    // createSavingsManager(mnemonic: string, index: number = 0, chain: ChainWalletConfig) {
-    //     return new SavingsManager(mnemonic, index, (chain))
-    // }
-    /**
-     * Validate that AA is available for sponsored transactions
-     * @throws Error with helpful message if AA is not available
-     */
     validateAAAvailability() {
         if (!this.isSmartWalletInitialized()) {
             if (this.isAASupportedByChain()) {
@@ -147,26 +430,8 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
             }
         }
     }
-    /**
-     * Extend wallet with smart wallet capabilities
-     * Enables Account Abstraction (EIP-4337) and EIP-7702 features
-     *
-     * @param options - Smart wallet configuration (optional if bundlerUrl is in config)
-     * @returns EVMSmartWallet instance
-     *
-     * @example
-     * // Using bundlerUrl from chainConfig
-     * const smartWallet = await evmWallet.extend();
-     *
-     * @example
-     * // Or provide bundlerUrl directly
-     * const smartWallet = await evmWallet.extend({
-     *   bundlerUrl: 'https://api.pimlico.io/v2/...'
-     * });
-     */
     async extend(options = {}) {
         if (!this.smartWallet) {
-            // Merge options with aaSupport config (options take priority)
             const mergedOptions = {
                 ...options,
                 aaConfig: this.config.aaSupport,
@@ -174,14 +439,12 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
                 paymasterUrl: options.paymasterUrl || this.config.aaSupport?.paymasterUrl,
                 entryPointVersion: options.entryPointVersion || this.config.aaSupport?.entryPoints?.[0]?.version
             };
-            // Validate bundlerUrl is available
             if (!mergedOptions.bundlerUrl) {
                 throw new Error('bundlerUrl is required to enable smart wallet features.\n' +
                     'Provide it via:\n' +
                     '1. extend({ bundlerUrl: "..." }), OR\n' +
                     '2. Configure aaSupport in your chain config');
             }
-            // Create viem chain object from config
             const chain = {
                 id: this.config.chainId,
                 name: this.config.name,
@@ -204,34 +467,18 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
                 testnet: this.config.testnet || false
             };
             this.smartWallet = new smartWallet_1.EVMSmartWallet(this.privateKey, chain, mergedOptions);
-            // Auto-initialize if option is set (default: true)
             if (options.autoInitialize !== false) {
                 await this.smartWallet.initialize();
             }
         }
         return this.smartWallet;
     }
-    /**
-     * Check if smart wallet is enabled
-     *
-     * @returns true if extend() has been called
-     */
     hasSmartWallet() {
         return !!this.smartWallet;
     }
-    /**
-     * Get smart wallet instance
-     *
-     * @returns EVMSmartWallet instance or undefined
-     */
     getSmartWallet() {
         return this.smartWallet;
     }
-    /**
-     * Get smart wallet address (if initialized)
-     *
-     * @returns Smart wallet address or undefined
-     */
     getSmartWalletAddress() {
         if (!this.smartWallet) {
             return undefined;
@@ -243,9 +490,6 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
             return undefined;
         }
     }
-    // ============================================
-    // Existing Wallet Methods
-    // ============================================
     getWallet() {
         return this.wallet;
     }
@@ -253,22 +497,18 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
         return this.address;
     }
     async getNativeBalance() {
-        // Implement native balance retrieval logic here
         return await EVMVM.getNativeBalance(this.address, this.connection);
     }
     async getTokenBalance(tokenAddress) {
-        // Implement token balance retrieval logic here
         return await EVMVM.getTokenBalance(this.address, tokenAddress, this.connection);
     }
     async getTokenInfo(tokenAddress) {
         return await EVMVM.getTokenInfo(tokenAddress, this.connection);
     }
     async discoverToken() {
-        // Implement token discovery logic here
         return await (0, utils_1.discoverTokens)(this.address, this.config);
     }
     async discoverNFT() {
-        // Implement NFT discovery logic here
         return await (0, utils_1.discoverNFTs)(this.address, this.config);
     }
     async transferNative(to, amount) {
@@ -300,11 +540,9 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
         }
         return result.data;
     }
-    // Updated swap method signature to match base class so created another method to use it inside swap
     async swap(tokenAddress, to, amount, slippage = 50) {
         throw new Error("Not Implemented");
     }
-    // Helper method for EVMChainWallet class
     fail(message) {
         return {
             success: false,
@@ -329,4 +567,3 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
     }
 }
 exports.EVMChainWallet = EVMChainWallet;
-//# sourceMappingURL=evm.js.map

package/dist/evm/index.js

@@ -17,6 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./evm"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./smartWallet"), exports);
-// Note: AA service types are re-exported through smartWallet.types.ts
-// Direct AA service exports would cause duplicate export errors
-//# sourceMappingURL=index.js.map

package/dist/evm/script.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quickSwapSetup = exports.quote = void 0;
 const ethers_1 = require("ethers");
-// Simplified ABI for Uniswap V3 Router
 const ROUTER_ABI = [
     'function exactInputSingle((address tokenIn, address tokenIn, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
     'function exactOutputSingle((address tokenIn, address tokenIn, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountIn)'
 ];
-// ERC20 ABI (simplified)
 const ERC20_ABI = [
     'function approve(address spender, uint256 amount) external returns (bool)',
     'function allowance(address owner, address spender) external view returns (uint256)',
@@ -42,18 +40,13 @@ const quote = async (quoterAddress, rpc, tokenIn, tokenOut, amountIn, fee, sqrtP
 };
 exports.quote = quote;
 const quickSwapSetup = async (params) => {
-    const { privateKey, tokenIn, tokenOut, amountIn, tokenInDecimal, adminAddress, routerAddress, rpcUrl, minAmountOut, feeTier = 100 // 0.01% fee tier
-     } = params;
+    const { privateKey, tokenIn, tokenOut, amountIn, tokenInDecimal, adminAddress, routerAddress, rpcUrl, minAmountOut, feeTier = 100 } = params;
     try {
-        // Setup provider and wallet
         const provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
         const wallet = new ethers_1.ethers.Wallet(privateKey, provider);
-        // Create contract instances
         const router = new ethers_1.ethers.Contract(routerAddress, ROUTER_ABI, wallet);
         const tokenInContract = new ethers_1.ethers.Contract(tokenIn, ERC20_ABI, wallet);
-        // Convert amount to wei
-        const amountInWei = ethers_1.ethers.parseUnits(amountIn, tokenInDecimal); // Assuming 18 decimals
-        // Check and approve token allowance
+        const amountInWei = ethers_1.ethers.parseUnits(amountIn, tokenInDecimal);
         const allowance = await tokenInContract.allowance(wallet.address, routerAddress);
         if (allowance < amountInWei) {
             console.log('Approving tokens...');
@@ -61,18 +54,14 @@ const quickSwapSetup = async (params) => {
             await approveTx.wait();
             console.log('Approval confirmed');
         }
-        // Calculate amount with fee (0.01% to admin)
-        const feeAmount = amountInWei * BigInt(1) / BigInt(10000); // 0.01%
+        const feeAmount = amountInWei * BigInt(1) / BigInt(10000);
         const amountAfterFee = amountInWei - feeAmount;
-        // Transfer fee to admin
         if (feeAmount > 0) {
             console.log(`Transferring ${ethers_1.ethers.formatUnits(feeAmount, tokenIn)} fee to admin`);
             const feeTransferTx = await tokenInContract.transfer(adminAddress, feeAmount);
             await feeTransferTx.wait();
         }
-        // Set deadline (10 minutes from now)
         const deadline = Math.floor(Date.now() / 1000) + 600;
-        // Prepare swap parameters
         const swapParams = {
             tokenIn: tokenIn,
             tokenOut: tokenOut,
@@ -84,12 +73,10 @@ const quickSwapSetup = async (params) => {
             sqrtPriceLimitX96: 0
         };
         console.log('Executing swap...');
-        // Execute swap
         const swapTx = await router.exactInputSingle(swapParams);
         const receipt = await swapTx.wait();
         console.log('Swap successful!');
         console.log('Transaction hash:', receipt.hash);
-        // Check final balances
         const tokenOutContract = new ethers_1.ethers.Contract(tokenOut, ERC20_ABI, wallet);
         const finalBalance = await tokenOutContract.balanceOf(wallet.address);
         console.log(`Final ${tokenOut} balance:`, ethers_1.ethers.formatUnits(finalBalance, 18));
@@ -108,4 +95,3 @@ const quickSwapSetup = async (params) => {
     }
 };
 exports.quickSwapSetup = quickSwapSetup;
-//# sourceMappingURL=script.js.map