hodl-wallet 1.4.4 → 1.5.2

package/README.md

@@ -41,7 +41,28 @@ Keep your favorite addresses handy. No more copy-pasting!
 
 ### 🌐 Multi-Network Support
 
-Seamlessly manage your assets on both BEP-20 (Binance Smart Chain) and ERC-20 (Ethereum) networks. Switch between networks with ease!
+Seamlessly manage your assets on multiple networks. HODL Wallet supports the following networks:
+
+- Binance Smart Chain
+- Ethereum
+- Polygon
+- Optimism
+- Arbitrum One
+- Fantom
+- Avalanche C-Chain
+
+Each network supports its native token and popular tokens like USDT. You can easily add more tokens as needed.
+
+## 💾 Export and Import HODL Files
+
+HODL Wallet now supports exporting and importing encrypted .HODL files, which securely store your wallet information.
+
+- **Export HODL File**: Save your wallet data (including private keys and addresses) to an encrypted .HODL file.
+- **Import HODL File**: Restore your wallet from a previously exported .HODL file.
+
+These files are encrypted using your wallet password, providing an additional layer of security for storing and transferring your wallet information.
+
+The main advantage of exporting a HODL file is that to access the private key, you need BOTH the file AND the password. This two-factor approach significantly enhances security. However, keep in mind that this solution is only compatible with HODL Wallet.
 
 ## 🔒 Security
 
@@ -65,12 +86,25 @@ We've carefully selected trusted and well-maintained dependencies for this proje
 - **deepbase**: For persistent storage.
 - **crypto-js**: For encryption.
 - **inquirer** and **inquirer-autocomplete-prompt**: For interactive command-line interfaces.
+- **inquirer-fuzzy-path**: For fuzzy searching and selecting file paths during HODL file import.
 - **cli-table3**: For creating formatted CLI tables.
 - **bip39**: For generating and handling mnemonic phrases.
 - **hdkey**: For handling hierarchical deterministic (HD) keys.
 
 ⚠️ **Important Notice**: HODL Wallet is a personal project created with the best intentions. While we strive for security, it may contain security flaws or vulnerabilities. Use at your own risk and always exercise caution with your crypto assets.
 
+## 📘 What HODL means
+
+The term "HODL" is a cornerstone of crypto culture, and it's worth understanding its origins:
+
+- 🎂 Born on December 18, 2013, in a Bitcoin Talk forum post
+- 🍺 Originally a typo for "HOLD" in a drunk, impassioned rant about not selling Bitcoin
+- 🔤 Later backronymed to mean "Hold On for Dear Life"
+- 💎 Symbolizes a long-term investment strategy and resistance to panic selling
+- 🌍 Now used across various cryptocurrency communities as a rallying cry
+
+HODL embodies the belief in the long-term potential of cryptocurrencies, often in the face of short-term market volatility. It's more than just a misspelling; it's a philosophy that has shaped the crypto landscape.
+
 ## 🤝 Contributing
 
 Found a bug? Want to add a feature? We're all ears! Open an issue or submit a PR. Let's make crypto easier together.

package/index.mjs

@@ -11,12 +11,14 @@ import Table from 'cli-table3';
 import bip39 from 'bip39';
 import hdkey from 'hdkey';
 import os from 'os';
+import inquirerFuzzyPath from 'inquirer-fuzzy-path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
 inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
 
 process.on('SIGINT', () => {
     process.exit();
@@ -34,6 +36,7 @@ class Wallet {
         this.web3 = null;
         this.selectedNetwork = null;
         this.account = null;
+        this.networkUsage = this.db.get('networkUsage') || {};
     }
 
     async initialize() {
@@ -82,14 +85,23 @@ class Wallet {
     }
 
     async selectNetwork(networkPlugins) {
+        // Sort networks by usage count (descending)
+        const sortedNetworks = networkPlugins.sort((a, b) => 
+            (this.networkUsage[b.name] || 0) - (this.networkUsage[a.name] || 0)
+        );
+
         const { network } = await inquirer.prompt({
             type: 'list',
             name: 'network',
             message: 'Select the network:',
-            choices: networkPlugins.map(plugin => plugin.name),
+            choices: sortedNetworks.map(plugin => plugin.name),
         });
 
-        const selectedNetwork = networkPlugins.find(plugin => plugin.name === network);
+        const selectedNetwork = sortedNetworks.find(plugin => plugin.name === network);
+
+        // Increment usage count for the selected network
+        this.networkUsage[network] = (this.networkUsage[network] || 0) + 1;
+        this.db.set('networkUsage', this.networkUsage);
 
         this.selectedNetwork = selectedNetwork;
     }
@@ -97,113 +109,101 @@ class Wallet {
     async loadAccount(forceReload = false) {
         let account = this.db.secureGet('account');
 
-        const choices = ['Create New Account', 'Import Mnemonic (12 words)', 'Import Private-key'];
+        const mainChoices = ['Create New Account'];
 
         if (forceReload) {
-            choices.push('Export Account');
-            choices.push('Switch Network');
-            choices.push('Go Back');
+            mainChoices.push('Import Options');
+            mainChoices.push('Export Options');
+            mainChoices.push('Switch Network');
+            mainChoices.push('Go Back');
+        } else {
+            mainChoices.push('Import Mnemonic (12 words)');
+            mainChoices.push('Import Private-key');
+            mainChoices.push('Import HODL File');
         }
 
         if (!account || forceReload) {
-            const { accountAction } = await inquirer.prompt({
+            let { accountAction } = await inquirer.prompt({
                 type: 'list',
                 name: 'accountAction',
                 message: 'Select an account option:',
-                choices,
+                choices: mainChoices,
             });
 
             if (accountAction === 'Go Back') {
                 return;
             }
 
-            if (account && accountAction !== 'Export Account' && accountAction !== 'Switch Network') {
-                const { confirmOverwrite } = await inquirer.prompt({
-                    type: 'confirm',
-                    name: 'confirmOverwrite',
-                    message: 'This action will overwrite the existing account. Are you sure you want to continue?',
-                    default: false,
+            if (accountAction === 'Import Options') {
+                const importChoices = ['Import Mnemonic (12 words)', 'Import Private-key', 'Import HODL File', 'Go Back'];
+                const { importAction } = await inquirer.prompt({
+                    type: 'list',
+                    name: 'importAction',
+                    message: 'Select an import option:',
+                    choices: importChoices,
                 });
 
-                if (!confirmOverwrite) {
-                    return;
+                if (importAction === 'Go Back') {
+                    return this.loadAccount(forceReload);
                 }
-            }
 
-            if (accountAction === 'Create New Account') {
-                const { createWithMnemonic } = await inquirer.prompt({
-                    type: 'confirm',
-                    name: 'createWithMnemonic',
-                    message: 'Create account with mnemonic?',
-                    default: true
-                });
-
-                let message = 'Do you want to display sensitive information (private key';
-                if (createWithMnemonic) {
-                    const mnemonic = bip39.generateMnemonic();
-                    const seed = await bip39.mnemonicToSeed(mnemonic);
-                    const root = hdkey.fromMasterSeed(seed);
-                    const addrNode = root.derive("m/44'/60'/0'/0/0");
-                    const privateKey = addrNode.privateKey.toString('hex');
-                    this.account = this.web3.eth.accounts.privateKeyToAccount('0x' + privateKey);
-                    this.account.mnemonic = mnemonic;
-                    message += ' and mnemonic';
-                } else {
-                    this.account = this.web3.eth.accounts.create();
+                if (!await this.confirmOverwrite()) {
+                    return;
                 }
 
-                message += ')?';
-
-                await this.db.secureSet('account', this.account);
-
-                const { showSensitive } = await inquirer.prompt({
-                    type: 'confirm',
-                    name: 'showSensitive',
-                    message,
-                    default: false,
-                });
+                accountAction = importAction;
+            }
 
-                if (showSensitive) {
-                    this.displayAccountDetails();
-                } else {
+            switch (accountAction) {
+                case 'Import Mnemonic (12 words)':
+                    account = await this.importFrom12Words();
+                    if (!account) {
+                        Wallet.displayError('Invalid mnemonic.');
+                        return;
+                    }
+                    this.account = account;
                     this.displayAccountAddress();
-                }
+                    break;
+                case 'Import Private-key':
+                    await this.importPrivateKey();
+                    break;
+                case 'Import HODL File':
+                    this.account = await this.importHODLFile();
+                    this.displayAccountAddress();
+                    break;
             }
 
-            if (accountAction === 'Import Private-key') {
-                const { privateKey } = await inquirer.prompt({
-                    type: 'password',
-                    name: 'privateKey',
-                    message: 'Private-key:',
-                    mask: '*',
+            if (accountAction === 'Export Options') {
+                const exportChoices = ['Export Private-key', 'Export HODL File', 'Go Back'];
+                const { exportAction } = await inquirer.prompt({
+                    type: 'list',
+                    name: 'exportAction',
+                    message: 'Select an export option:',
+                    choices: exportChoices,
                 });
 
-                if (!privateKey.trim()) {
-                    Wallet.displayError('Private-key is empty.');
-                    return;
+                if (exportAction === 'Go Back') {
+                    return this.loadAccount(forceReload);
                 }
 
-                try {
-                    this.account = this.web3.eth.accounts.privateKeyToAccount(privateKey);
-                    await this.db.secureSet('account', this.account);
-                    this.displayAccountAddress();
-                } catch (error) {
-                    Wallet.displayError('Invalid private-key.');
+                switch (exportAction) {
+                    case 'Export Private-key':
+                        await this.displayAccountDetails();
+                        break;
+                    case 'Export HODL File':
+                        await this.exportHODLFile();
+                        break;
                 }
+                return;
             }
 
-            if (accountAction === 'Import Mnemonic (12 words)') {
-                account = await this.importFrom12Words();
-                if (!account) {
-                    Wallet.displayError('Invalid mnemonic.');
+
+            if (accountAction === 'Create New Account') {
+                if (!await this.confirmOverwrite()) {
                     return;
                 }
-                this.account = account;
-                this.displayAccountAddress();
-            }
 
-            if (accountAction === 'Export Account') {
-                await this.displayAccountDetails();
+                await this.createNewAccount();
             }
 
             if (accountAction === 'Switch Network') {
@@ -216,6 +216,20 @@ class Wallet {
         this.account = account;
     }
 
+    async confirmOverwrite() {
+        if (this.account) {
+            const { confirmOverwrite } = await inquirer.prompt({
+                type: 'confirm',
+                name: 'confirmOverwrite',
+                message: 'This action will overwrite the existing account. Are you sure you want to continue?',
+                default: false,
+            });
+
+            return confirmOverwrite;
+        }
+        return false;
+    }
+
     async importFrom12Words() {
         const { mnemonic } = await inquirer.prompt({
             type: 'password',
@@ -228,13 +242,7 @@ class Wallet {
             return null;
         }
 
-        const seed = await bip39.mnemonicToSeed(mnemonic);
-        const root = hdkey.fromMasterSeed(seed);
-        const addrNode = root.derive("m/44'/60'/0'/0/0");
-        const privateKey = addrNode.privateKey.toString('hex');
-        const account = this.web3.eth.accounts.privateKeyToAccount('0x' + privateKey);
-
-        account.mnemonic = mnemonic;
+        const account = await this.accountFromMnemonic(mnemonic);
         await this.db.secureSet('account', account);
         return account;
     }
@@ -329,7 +337,7 @@ class Wallet {
         const { amount } = await inquirer.prompt({
             type: 'input',
             name: 'amount',
-            message: `Amount to transfer [${token}] (leave empty to cancel):`,
+            message: `Amount to transfer:`,
             validate: value => {
                 if (value === '') return true;
                 return !isNaN(value) && Number(value) > 0 ? true : 'Please enter a valid number or leave empty to cancel.';
@@ -340,6 +348,18 @@ class Wallet {
             return;
         }
 
+        // Add confirmation step
+        const { confirmTransaction } = await inquirer.prompt({
+            type: 'confirm',
+            name: 'confirmTransaction',
+            message: `Confirm transfer?`,
+            default: true
+        });
+
+        if (!confirmTransaction) {
+            return;
+        }
+
         try {
             let signedTx;
             if (tokens[token] && token !== this.selectedNetwork.nativeToken) {
@@ -585,6 +605,134 @@ class Wallet {
         await this.selectNetwork(networkPlugins);
         this.web3 = new Web3(this.selectedNetwork.rpcUrl);
     }
+
+    async exportHODLFile() {
+        const defaultFileName = `${this.account.address.slice(-6).toUpperCase()}`;
+        let { fileName } = await inquirer.prompt({
+            type: 'input',
+            name: 'fileName',
+            message: 'Enter the name for the HODL file:',
+            default: defaultFileName
+        });
+
+        fileName += '.HODL';
+
+        const data = this.db.get();
+        const encryptedData = this.db.encrypt(data);
+
+        fs.writeFileSync(fileName, encryptedData);
+
+        const table = new Table({
+            head: ['HODL File Exported'],
+            style: { head: ['green'] }
+        });
+        table.push([`File saved as: ${fileName}`]);
+        console.log(table.toString());
+    }
+
+    async importHODLFile() {
+        const { filePath } = await inquirer.prompt({
+            type: 'fuzzypath',
+            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'),
+        });
+
+        if (!fs.existsSync(filePath)) {
+            Wallet.displayError('File not found.');
+            return;
+        }
+
+        const encryptedData = fs.readFileSync(filePath, 'utf8');
+
+        try {
+            const decryptedData = this.db.decrypt(encryptedData);
+            this.db.set(decryptedData);
+            return this.db.secureGet('account');
+        } catch (error) {
+            Wallet.displayError('Failed to import HODL file.', 'The file may be corrupted or the encryption key is incorrect.');
+        }
+    }
+
+    async importPrivateKey() {
+        const { privateKey } = await inquirer.prompt({
+            type: 'password',
+            name: 'privateKey',
+            message: 'Private-key:',
+            mask: '*',
+        });
+
+        if (!privateKey.trim()) {
+            Wallet.displayError('Private-key is empty.');
+            return;
+        }
+
+        try {
+            this.account = this.web3.eth.accounts.privateKeyToAccount(privateKey);
+            await this.db.secureSet('account', this.account);
+            this.displayAccountAddress();
+        } catch (error) {
+            Wallet.displayError('Invalid private-key.');
+        }
+    }
+
+    async createNewAccount() {
+        const { createWithMnemonic } = await inquirer.prompt({
+            type: 'confirm',
+            name: 'createWithMnemonic',
+            message: 'Create account with mnemonic?',
+            default: true
+        });
+
+        let message = 'Do you want to display sensitive information (private key';
+        if (createWithMnemonic) {
+            this.account = await this.createAccountFromMnemonic();
+            message += ' and mnemonic';
+        } else {
+            this.account = this.web3.eth.accounts.create();
+        }
+
+        message += ')?';
+
+        await this.db.secureSet('account', this.account);
+
+        const { showSensitive } = await inquirer.prompt({
+            type: 'confirm',
+            name: 'showSensitive',
+            message,
+            default: false,
+        });
+
+        if (showSensitive) {
+            this.displayAccountDetails();
+        } else {
+            this.displayAccountAddress();
+        }
+    }
+
+    async accountFromMnemonic(mnemonic) {
+        const seed = await bip39.mnemonicToSeed(mnemonic);
+        const root = hdkey.fromMasterSeed(seed);
+        const addrNode = root.derive("m/44'/60'/0'/0/0");
+        const privateKey = addrNode.privateKey.toString('hex');
+        const account = this.web3.eth.accounts.privateKeyToAccount('0x' + privateKey);
+        account.mnemonic = mnemonic;
+        return account;
+    }
+
+    async createAccountFromMnemonic() {
+        try {
+            const mnemonic = bip39.generateMnemonic();
+            return this.accountFromMnemonic(mnemonic);
+        } catch (error) {
+            Wallet.displayError('Failed to create account from mnemonic.', error);
+        }
+    }
 }
 
 class UIManager {

package/network/arb.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: '[ERC-20] Arbitrum One',
+    explorer: 'https://arbiscan.io/tx/',
+    rpcUrl: 'https://arb1.arbitrum.io/rpc',
+    nativeToken: 'ETH',
+    tokens: {
+        'USDT': '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9', // USDT on Arbitrum
+        'ARB': '0x0000000000000000000000000000000000000000', // Native ETH on Arbitrum
+    },
+};

package/network/avax.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: '[ERC-20] Avalanche C-Chain',
+    explorer: 'https://snowtrace.io/tx/',
+    rpcUrl: 'https://api.avax.network/ext/bc/C/rpc',
+    nativeToken: 'AVAX',
+    tokens: {
+        'USDT': '0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7', // USDT.e on Avalanche C-Chain
+        'AVAX': '0x0000000000000000000000000000000000000000', // Native AVAX
+    },
+};

package/network/ftm.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: '[ERC-20] Fantom',
+    explorer: 'https://ftmscan.com/tx/',
+    rpcUrl: 'https://rpc.ftm.tools/',
+    nativeToken: 'FTM',
+    tokens: {
+        'USDT': '0x049d68029688eAbF473097a2fC38ef61633A3C7A', // USDT on Fantom
+        'FTM': '0x0000000000000000000000000000000000000000', // Native FTM
+    },
+};

package/network/op.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: '[ERC-20] Optimism',
+    explorer: 'https://optimistic.etherscan.io/tx/',
+    rpcUrl: 'https://mainnet.optimism.io',
+    nativeToken: 'ETH',
+    tokens: {
+        'USDT': '0x94b008aA00579c1307B0EF2c499aD98a8ce58e58', // USDT on Optimism
+        'OP': '0x0000000000000000000000000000000000000000',
+    },
+};

package/network/pol.js

@@ -0,0 +1,11 @@
+// network/matic.js
+module.exports = {
+    name: '[ERC-20] Polygon',
+    explorer: 'https://polygonscan.com/tx/',
+    rpcUrl: 'https://polygon-rpc.com/',
+    nativeToken: 'POL',
+    tokens: {
+        'USDT': '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', 
+        'POL': '0x0000000000000000000000000000000000000000',
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hodl-wallet",
-    "version": "1.4.4",
+    "version": "1.5.2",
     "description": "🧊 HODL Wallet - Fast CLI crypto wallet!",
     "author": "Martin Clasen",
     "repository": {
@@ -37,16 +37,24 @@
         "stable",
         "coin",
         "evm",
+        "polygon",
+        "matic",
+        "arbitrum",
+        "fantom",
+        "optimism",
+        "avalanche",
+        "avax",
         "clasen"
     ],
     "dependencies": {
         "bip39": "^3.1.0",
         "cli-table3": "^0.6.5",
         "crypto-js": "^4.2.0",
-        "deepbase": "^1.2.2",
+        "deepbase": "^1.2.4",
         "hdkey": "^2.1.0",
         "inquirer": "^9.3.7",
         "inquirer-autocomplete-prompt": "^3.0.1",
+        "inquirer-fuzzy-path": "^2.3.0",
         "web3": "^4.13.0"
     }
-}
+}