hodl-wallet 1.4.4 → 1.4.6

package/README.md

@@ -41,7 +41,18 @@ 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 both BEP-20 (Binance Smart Chain) and ERC-20 (Ethereum and Polygon) networks. Switch between networks with ease!
+
+### 💾 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,6 +76,7 @@ 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.

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();
@@ -97,113 +99,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 +206,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 +232,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;
     }
@@ -585,6 +583,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/pol.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hodl-wallet",
-    "version": "1.4.4",
+    "version": "1.4.6",
     "description": "🧊 HODL Wallet - Fast CLI crypto wallet!",
     "author": "Martin Clasen",
     "repository": {
@@ -37,16 +37,20 @@
         "stable",
         "coin",
         "evm",
+        "polygon",
+        "matic",
+        "pol",
         "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"
     }
 }