hodl-wallet 1.8.4 → 1.8.8

package/index.js

@@ -8,7 +8,6 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import Table from 'cli-table3';
 import os from 'os';
-import inquirerFuzzyPath from 'inquirer-fuzzy-path';
 import ora from 'ora';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -16,7 +15,6 @@ const __dirname = dirname(__filename);
 
 import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
 inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
-inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
 
 process.on('SIGINT', () => {
     process.exit();
@@ -39,20 +37,20 @@ class Wallet {
 
     formatAmount(num) {
         num = parseFloat(num);
-        
+
         // Handle integers - add .00
         if (num === Math.floor(num)) {
             return num.toString() + '.00';
         }
-        
+
         // For decimals, format to max 3 decimal places, then remove trailing zeros
         let formatted = num.toFixed(3);
-        
+
         // Remove trailing zeros, but keep at least 2 decimal places
         while (formatted.endsWith('0') && formatted.split('.')[1].length > 2) {
             formatted = formatted.slice(0, -1);
         }
-        
+
         return formatted;
     }
 
@@ -84,6 +82,9 @@ class Wallet {
     }
 
     setAccount(account) {
+        if (!account) {
+            return;
+        }
         this.db.set('account', this.network.constructor.name, account);
         if (account.mnemonic) {
             this.db.set('mnemonic', account.mnemonic);
@@ -92,8 +93,8 @@ class Wallet {
 
     async getAccount() {
         const account = this.db.get('account', this.network.constructor.name);
-        
-        
+
+
         return account;
     }
 
@@ -113,7 +114,7 @@ class Wallet {
                 head: ['green']
             }
         });
-        
+
         table.push([await this.getAddress()]);
         console.log(table.toString());
     }
@@ -135,18 +136,18 @@ class Wallet {
         const sortedNetworks = networkPlugins.sort((a, b) => {
             const aUsage = this.networkUsage[a.name];
             const bUsage = this.networkUsage[b.name];
-            
+
             // Handle old format (number) vs new format (object)
             const aLastUsed = typeof aUsage === 'object' ? aUsage.lastUsed || 0 : 0;
             const bLastUsed = typeof bUsage === 'object' ? bUsage.lastUsed || 0 : 0;
-            
+
             // If neither has lastUsed timestamp, sort by old count format
             if (aLastUsed === 0 && bLastUsed === 0) {
                 const aCount = typeof aUsage === 'number' ? aUsage : (aUsage?.count || 0);
                 const bCount = typeof bUsage === 'number' ? bUsage : (bUsage?.count || 0);
                 return bCount - aCount;
             }
-            
+
             return bLastUsed - aLastUsed;
         });
 
@@ -169,19 +170,19 @@ class Wallet {
         // Update usage info for the selected network
         // Handle migration from old format (number) to new format (object)
         const currentUsage = this.networkUsage[selectedNetwork.name];
-        
+
         if (!currentUsage || typeof currentUsage === 'number') {
             // Old format (number) or doesn't exist - create new object
-            this.networkUsage[selectedNetwork.name] = { 
-                count: typeof currentUsage === 'number' ? currentUsage + 1 : 1, 
-                lastUsed: Date.now() 
+            this.networkUsage[selectedNetwork.name] = {
+                count: typeof currentUsage === 'number' ? currentUsage + 1 : 1,
+                lastUsed: Date.now()
             };
         } else {
             // New format (object) - update values
             this.networkUsage[selectedNetwork.name].count = (currentUsage.count || 0) + 1;
             this.networkUsage[selectedNetwork.name].lastUsed = Date.now();
         }
-        
+
         await this.db.set('networkUsage', this.networkUsage);
 
         this.selectedNetwork = selectedNetwork;
@@ -199,9 +200,9 @@ class Wallet {
             mainChoices.push('Manage Address Book');
             mainChoices.push('Go Back');
         } else {
-            mainChoices.push('Import Mnemonic (12 words)');
-            mainChoices.push('Import Private-key');
             mainChoices.push('Import HODL File');
+            mainChoices.push('Import Mnemonic (12 or 24 words)');
+            mainChoices.push('Import Private-key');
         }
 
         if (!account || loggedIn) {
@@ -238,7 +239,7 @@ class Wallet {
             }
 
             if (accountAction === 'Import Options') {
-                const importChoices = ['Import Mnemonic (12 words)', 'Import Private-key', 'Import HODL File', 'Go Back'];
+                const importChoices = ['Import HODL File', 'Import Mnemonic (12 or 24 words)', 'Import Private-key', 'Go Back'];
                 const { importAction } = await inquirer.prompt({
                     type: 'list',
                     name: 'importAction',
@@ -257,7 +258,7 @@ class Wallet {
             }
 
             switch (accountAction) {
-                case 'Import Mnemonic (12 words)':
+                case 'Import Mnemonic (12 or 24 words)':
                     account = await this.importFromMnemonic();
                     if (!account) {
                         // Wallet.displayError('Invalid mnemonic.');
@@ -270,13 +271,16 @@ class Wallet {
                     await this.importPrivateKey();
                     break;
                 case 'Import HODL File':
-                    this.setAccount(await this.importHODLFile());
-                    await this.displayAccountAddress();
+                    const importedAccount = await this.importHODLFile();
+                    if (importedAccount) {
+                        this.setAccount(importedAccount);
+                        await this.displayAccountAddress();
+                    }
                     break;
             }
 
             if (accountAction === 'Export Options') {
-                const exportChoices = ['Export Private-key', 'Export HODL File', 'Go Back'];
+                const exportChoices = ['Export HODL File', 'Export Private-key', 'Go Back'];
                 const { exportAction } = await inquirer.prompt({
                     type: 'list',
                     name: 'exportAction',
@@ -335,7 +339,7 @@ class Wallet {
         const { mnemonic } = await inquirer.prompt({
             type: 'password',
             name: 'mnemonic',
-            message: 'Enter your 12-word mnemonic phrase:',
+            message: 'Enter your mnemonic phrase (12 or 24 words):',
             mask: '*',
             validate: (input) => {
                 if (input.trim() === '') return true;
@@ -468,17 +472,17 @@ class Wallet {
             let currentBalance = 0;
             try {
                 const walletAddress = await this.getAddress();
-                
+
                 // Get the balance AFTER transaction (not before)
                 if (token === this.selectedNetwork.nativeToken) {
                     currentBalance = await this.network.getBalance(walletAddress);
                 } else {
                     currentBalance = await this.network.getTokenBalance(walletAddress, token);
                 }
-                
+
                 // Round to avoid floating point precision issues
                 currentBalance = Math.round(currentBalance * 100000000) / 100000000;
-                
+
             } catch (error) {
                 console.error('Error getting post-transaction balance:', error.message);
             }
@@ -726,21 +730,58 @@ class Wallet {
     }
 
     async importHODLFile() {
+        // Scan current directory for .HODL files
+        const currentDir = process.cwd();
+        let hodlFiles = [];
+
+        try {
+            const files = fs.readdirSync(currentDir);
+            hodlFiles = files.filter(file => file.endsWith('.HODL'));
+        } catch (error) {
+            console.error('Error reading directory:', error.message);
+        }
+
+        // Create file options array for autocomplete
+        const fileOptions = hodlFiles.map(file => ({
+            name: file,
+            value: path.join(currentDir, file)
+        }));
+
+        // Use autocomplete pattern similar to transferFunds
         const { filePath } = await inquirer.prompt({
-            type: 'fuzzypath',
+            type: 'autocomplete',
             name: 'filePath',
-            message: 'Select the .HODL file:',
-            rootPath: '.',
-            itemType: 'file',
-            suggestOnly: false,
-            depthLimit: 5,
-            excludePath: nodePath => nodePath.startsWith('node_modules'),
-            excludeFilter: nodePath => !nodePath.endsWith('.HODL'),
+            message: 'HODL file path:',
+            source: (answersSoFar, input) => {
+                input = input || '';
+
+                const filenameOptions = fileOptions
+                    .filter(entry => entry.name.toLowerCase().includes(input.toLowerCase()) || entry.value.toLowerCase().includes(input.toLowerCase()))
+                    .map(entry => ({
+                        name: entry.name,
+                        value: entry.value
+                    }));
+
+                // Put path options first, then filename options, then manual input
+                return [].concat([{ name: input, value: input }])
+                    .concat(filenameOptions)
+            },
         });
 
+        // If user leaves empty, skip the operation
+        if (!filePath || filePath.trim() === '') {
+            return null;
+        }
+
+        // Validate the file path
+        if (!filePath.endsWith('.HODL')) {
+            Wallet.displayError('File must have .HODL extension');
+            return null;
+        }
+
         if (!fs.existsSync(filePath)) {
             Wallet.displayError('File not found.');
-            return;
+            return null;
         }
 
         const encryptedData = fs.readFileSync(filePath, 'utf8');
@@ -751,6 +792,7 @@ class Wallet {
             return this.getAccount();
         } catch (error) {
             Wallet.displayError('Failed to import HODL file.', 'The password is incorrect.');
+            return null;
         }
     }
 
@@ -805,7 +847,19 @@ class Wallet {
             });
 
             if (createWithMnemonic) {
-                this.setAccount(await this.network.createAccountFromMnemonic());
+                // Ask for mnemonic word count
+                const { wordCount } = await inquirer.prompt({
+                    type: 'list',
+                    name: 'wordCount',
+                    message: 'Choose mnemonic phrase length:',
+                    choices: [
+                        { name: '12 words (standard)', value: 12 },
+                        { name: '24 words (more secure)', value: 24 }
+                    ],
+                    default: 12
+                });
+
+                this.setAccount(await this.network.createAccountFromMnemonic(wordCount));
             } else {
                 this.setAccount(await this.network.createAccount());
             }

package/network/lib/BitcoinNetwork.js

@@ -185,9 +185,11 @@ export default class BitcoinNetwork extends BaseNetwork {
         };
     }
 
-    async createAccountFromMnemonic() {
+    async createAccountFromMnemonic(wordCount = 12) {
         try {
-            const mnemonic = bip39.generateMnemonic();
+            // Support both 12 and 24 word mnemonics
+            const strength = wordCount === 24 ? 256 : 128; // 256 bits = 24 words, 128 bits = 12 words
+            const mnemonic = bip39.generateMnemonic(strength);
             return this.accountFromMnemonic(mnemonic);
         } catch (error) {
             throw new Error('Failed to create account from mnemonic: ' + error.message);

package/network/lib/TONNetwork.js

@@ -86,40 +86,84 @@ export default class TONNetwork extends BaseNetwork {
     }
 
     async createAccount() {
-        const mnemonic = await this.generateMnemonic();
-        return this.accountFromMnemonic(mnemonic);
+        try {
+            const mnemonic = await this.generateMnemonic();
+            const account = await this.accountFromMnemonic(mnemonic);
+            
+            // Ensure all required fields are present
+            if (!account.address || !account.privateKey) {
+                throw new Error('Failed to create complete account');
+            }
+            
+            return account;
+        } catch (error) {
+            console.error('Error creating new account:', error.message);
+            throw error;
+        }
     }
 
     async accountFromMnemonic(mnemonic) {
-        const mnemonicArray = Array.isArray(mnemonic) ? mnemonic : mnemonic.split(' ');
-        const keyPair = await mnemonicToPrivateKey(mnemonicArray);
-        const wallet = WalletContractV4.create({ 
-            publicKey: keyPair.publicKey,
-            workchain: 0 
-        });
-
-        return {
-            address: wallet.address.toString(),
-            publicKey: keyPair.publicKey,
-            // Store secretKey as hex string to avoid Buffer serialization issues
-            secretKey: keyPair.secretKey.toString('hex'),
-            mnemonic: Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic
-        };
+        try {
+            const mnemonicArray = Array.isArray(mnemonic) ? mnemonic : mnemonic.split(' ');
+            
+            // Validate mnemonic first
+            if (!mnemonicValidate(mnemonicArray)) {
+                throw new Error('Invalid mnemonic phrase');
+            }
+            
+            const keyPair = await mnemonicToPrivateKey(mnemonicArray);
+            const wallet = WalletContractV4.create({ 
+                publicKey: keyPair.publicKey,
+                workchain: 0 
+            });
+
+            const account = {
+                address: wallet.address.toString(),
+                publicKey: keyPair.publicKey,
+                // Store secretKey as hex string to avoid Buffer serialization issues
+                secretKey: keyPair.secretKey.toString('hex'),
+                privateKey: keyPair.secretKey.toString('hex'), // Add privateKey for compatibility
+                mnemonic: Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic
+            };
+            
+            return account;
+        } catch (error) {
+            console.error('Error creating account from mnemonic:', error.message);
+            throw error;
+        }
     }
 
-    async createAccountFromMnemonic() {
-        const mnemonic = await this.generateMnemonic();
-        return this.accountFromMnemonic(mnemonic);
+    async createAccountFromMnemonic(wordCount = 12) {
+        try {
+            const mnemonic = await this.generateMnemonic(wordCount);
+            const account = await this.accountFromMnemonic(mnemonic);
+            
+            // Ensure all required fields are present including mnemonic
+            if (!account.address || !account.privateKey || !account.mnemonic) {
+                throw new Error('Failed to create complete account with mnemonic');
+            }
+            
+            return account;
+        } catch (error) {
+            console.error('Error creating account with mnemonic:', error.message);
+            throw error;
+        }
     }
 
-    async generateMnemonic() {
-        const mnemonic = await mnemonicNew();
+    async generateMnemonic(wordCount = 12) {
+        const mnemonic = await mnemonicNew(wordCount);
         return mnemonic.join(' ');
     }
 
     validateMnemonic(mnemonic) {
         try {
-            return mnemonicValidate(mnemonic.split(' '));
+            const mnemonicArray = mnemonic.split(' ');
+            // Check if it has exactly 12 or 24 words
+            if (mnemonicArray.length !== 12 && mnemonicArray.length !== 24) {
+                return false;
+            }
+            // Use TON's built-in validation
+            return mnemonicValidate(mnemonicArray);
         } catch {
             return false;
         }

package/network/lib/Web3Network.js

@@ -89,10 +89,11 @@ export default class Web3Network extends BaseNetwork {
 
     async handleNativeTransfer(account, recipient, amount) {
         const gasPrice = await this.getGasPrice();
+        const valueInWei = this.web3.utils.toWei(amount.toString(), 'ether');
         const gasLimit = await this.estimateGas({
             from: account.address,
             to: recipient,
-            value: amount
+            value: valueInWei
         });
 
         return this.transfer(account, recipient, amount, { gasLimit, gasPrice });
@@ -144,9 +145,11 @@ export default class Web3Network extends BaseNetwork {
         return account;
     }
 
-    async createAccountFromMnemonic() {
+    async createAccountFromMnemonic(wordCount = 12) {
         try {
-            const mnemonic = bip39.generateMnemonic();
+            // Support both 12 and 24 word mnemonics
+            const strength = wordCount === 24 ? 256 : 128; // 256 bits = 24 words, 128 bits = 12 words
+            const mnemonic = bip39.generateMnemonic(strength);
             return this.accountFromMnemonic(mnemonic);
         } catch (error) {
             throw new Error('Failed to create account from mnemonic: ' + error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hodl-wallet",
-    "version": "1.8.4",
+    "version": "1.8.8",
     "description": "🧊 HODL Wallet - Fast CLI crypto wallet!",
     "author": "Martin Clasen",
     "repository": {
@@ -18,7 +18,10 @@
     },
     "scripts": {
         "start": "node ./index.js",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "node ./test/test-all.js",
+        "test:network": "node ./test/test.js",
+        "test:integration": "node ./test/test-integration.js",
+        "test:quick": "node ./test/test.js --quick"
     },
     "keywords": [
         "hodl",
@@ -60,12 +63,18 @@
         "crypto-js": "^4.2.0",
         "deepbase": "^1.5.2",
         "ecpair": "^2.1.0",
+        "external-editor": "^3.1.0",
         "hdkey": "^2.1.0",
         "inquirer": "^9.3.7",
         "inquirer-autocomplete-prompt": "^3.0.1",
         "inquirer-fuzzy-path": "^2.3.0",
+        "ora": "^8.1.1",
         "tiny-secp256k1": "^2.2.3",
+        "tmp": "^0.2.4",
         "web3": "^4.14.0"
     },
+    "overrides": {
+        "tmp": "^0.2.4"
+    },
     "type": "module"
 }

package/test/README.md

@@ -0,0 +1,65 @@
+# 🧪 Test Directory - HODL Wallet
+
+This directory contains the complete test suite to validate the functionality of the HODL Wallet library.
+
+## 📁 File Structure
+
+```
+test/
+├── test.js              # Main network tests
+├── test-integration.js  # Cross-network integration tests
+├── test-all.js         # Complete runner with interactive menu
+├── TESTING.md          # Complete testing documentation
+├── TEST_RESULTS.md     # Latest execution results
+└── README.md           # This file
+```
+
+## 🚀 Quick Start
+
+### Run all tests:
+```bash
+npm test
+```
+
+### Run specific tests:
+```bash
+npm run test:network      # Network tests only
+npm run test:integration  # Integration tests only
+npm run test:quick        # Quick validation
+```
+
+## 📊 Current Status
+
+- **✅ 9/9 networks fully functional** (100% success)
+- **✅ 79 individual tests**
+- **✅ Complete functionality coverage**
+
+### Validated Networks:
+- ✅ Ethereum (ETH)
+- ✅ Binance Smart Chain (BNB)  
+- ✅ Arbitrum One (ARB)
+- ✅ Avalanche C-Chain (AVAX)
+- ✅ Fantom (FTM)
+- ✅ Optimism (OP)
+- ✅ Polygon (MATIC)
+- ✅ Bitcoin (BTC)
+- ✅ TON (fully fixed and functional)
+
+## 📖 Documentation
+
+For detailed information on how to use the tests, see:
+- **[TESTING.md](./TESTING.md)** - Complete testing guide
+- **[TEST_RESULTS.md](./TEST_RESULTS.md)** - Detailed results
+
+## 🎯 Purpose
+
+This test suite validates:
+1. **Correct configuration** of all networks
+2. **Complete implementation** of required methods  
+3. **Consistency between networks** EVM
+4. **Account functionality** (creation, import)
+5. **Network connectivity** and validations
+
+---
+
+*Keep this directory updated when adding new networks or functionality.*