@yerofey/cryptowallet-cli 1.36.2 → 1.37.0

package/README.md

@@ -13,9 +13,10 @@
 - [x] Generate brand new crypto wallet address (offline)
 - [x] Generate wallet address with prefix (string at the start): [`-p`] (case-insensitive) or [`-P`] (case-sensitive)
 - [x] Generate wallet address with suffix (string at the end): [`-s`] (case-insensitive) or [`-S`] (case-sensitive)
-- [x] Generate wallet with different formats (for Bitcoin: Legacy, SegWit, Bech32; for BNB: BEP2, BEP20): [`-f`]
+- [x] Generate wallet with different formats (for Bitcoin: `legacy`, `segwit`, `bech32`, `taproot`; for BNB: `bep2`, `bep20`, `erc20`; for TON: `w5` and all previous ones): [`-f`]
 - [x] Generate wallet from your desired mnemonic string: [`-m`]
 - [x] Generate mnemonic string: [`-m`] or [`-m 12`] or [`-m 15`] or [`-m 18`] or [`-m 21`] or [`-m 24`]
+- [x] Use multiple threads (cores) for faster generation [`-t`]
 - [x] Generate a lot of wallets at once: [`-n`]
 - [x] Save result into a CSV file: [`--csv`]
 - [x] Copy the generated mnemonic to the clipboard: [`-C` or `--copy`]
@@ -43,12 +44,18 @@ $ yarn global add @yerofey/cryptowallet-cli
 # generate random EVM-compatible wallet (for Ethereum, Polygon, any L1/L2 EVM-compatible chain, etc.)
 $ cw
 
+# generate random wallet and copy the mnemonic to the clipboard
+$ cw -C
+
 # generate random BTC wallet (default format: bech32 - "bc1q...")
 $ cw -c btc
 
 # generate random mnemonic string (12 words) to import in any wallet app
 $ cw -m
 
+# generate random wallet faster (use all available CPU cores)
+$ cw -t 
+
 # generate random mnemonic string of a specific length (12, 15, 18, 21 or 24 words)
 $ cw -m 12
 $ cw -m 15
@@ -118,14 +125,15 @@ $ cw -l
 - `EVM` (Ethereum, Base, Arbitrum, Optimism, Polygon, L2/L3, etc.) **default**
 - `BTC` (Bitcoin) [legacy, segwit, bech32, taproot]
 - `ETH` (Ethereum)
+- `SOL` (Solana)
 - `BNB` (Binance Coin) [BEP2, BEP20, ERC20]
 - `BSC` (Binance Smart Chain)
-- `SOL` (Solana)
+- `DOGE` (Dogecoin) [legacy, segwit, bech32]
 - `TRX` (Tron)
+- `SUI` (Sui)
 - `TON` (The Open Network) [W5, V2-V5, simple]
-- `DOGE` (Dogecoin) [legacy, segwit, bech32]
-- `BCH` (Bitcoin Cash)
 - `LTC` (Litecoin) [legacy, segwit, bech32]
+- `BCH` (Bitcoin Cash)
 - `ETC` (Ethereum Classic)
 - `XTZ` (Tezos)
 - `DASH` (Dash)
@@ -168,6 +176,7 @@ $ cw -l
 - `-P` or `--prefix-sensitive`: Specify desired prefix of the wallet address (**case-sensitive**)
 - `-s` or `--suffix`: Specify desired suffix for the wallet address (**case-insensitive**)
 - `-S` or `--suffix-sensitive`: Specify desired suffix for the wallet address (**case-sensitive**)
+- `-t` or `--threads`: Use multiple threads (cores) for faster generation (default: half of the available cores), or pass `0` to use all available cores (not recommended for laptops)
 - `-q` or `--qr`: Display QR code with the generated wallet address (works only without `-n` argument)
 - `-v` or `--version`: Display current version of CW tool
 
@@ -187,8 +196,6 @@ $ cw -l
 - [x] v22.x ✅
 - [x] v23.x ✅
 
-*tested on Ubuntu 22.04 & Mac M1*
-
 ## TODO
 
 - [ ] SegWit Bech32 wallet address support for all Bitcoin forks

package/cli.js

@@ -1,41 +1,176 @@
 #!/usr/bin/env node
 'use strict';
 
+import os from 'node:os';
+import {
+  Worker,
+  isMainThread,
+  parentPort,
+  workerData,
+} from 'node:worker_threads';
+import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import { options } from './src/options.js';
 import { log, supportedChains } from './src/utils.js';
 import Method from './src/Method.js';
 
-(async () => {
-  if (options.list !== undefined) {
+// get the current file path
+const __filename = fileURLToPath(import.meta.url);
+
+if (options.list !== undefined) {
+  (async () => {
     return new Method('list').init();
-  }
+  })();
+}
 
-  // generate mnemonic string if no argument is passed or only the mnemonic length is passed
-  if (
-    options.mnemonic &&
-    (options.mnemonic === true ||
-      options.mnemonic === '' ||
-      options.mnemonic.split(' ').length === 1)
-  ) {
-    return new Method('mnemonic').init({ mnemonic: options.mnemonic, copy: options?.copy || false });
-  }
+// generate mnemonic string if no argument is passed or only the mnemonic length is passed
+if (
+  options.mnemonic &&
+  (options.mnemonic === true ||
+    options.mnemonic === '' ||
+    options.mnemonic.split(' ').length === 1)
+) {
+  (async () => {
+    return new Method('mnemonic').init({
+      mnemonic: options.mnemonic,
+      copy: options?.copy || false,
+    });
+  })();
+}
 
-  if (options.version) {
+if (options.version) {
+  (async () => {
     return new Method('version').init();
-  }
+  })();
+}
 
-  if (options.donate) {
+if (options.donate) {
+  (async () => {
     return new Method('donate').init();
+  })();
+}
+
+const chain = (options.chain.toUpperCase() || 'EVM').trim();
+if (!supportedChains.includes(chain)) {
+  log(chalk.red('⛔️  Error: this chain is not supported!'));
+  process.exit(1);
+}
+options.b = chain; // ensure the chain is passed to the Method class
+
+// multi-threads mode (only for suffix, prefix, number)
+const allMachineThreads = os.cpus().length;
+const availableThreads = os.cpus().length - 1; // leave 1 core for the main thread
+const defaultThreads = os.cpus().length / 2; // use half of the available threads
+const inputThreads = parseInt(options.threads || 1, 10); // default to 1 thread
+let numThreads = defaultThreads; // default to half of the available threads
+if (inputThreads > availableThreads) {
+  numThreads = defaultThreads;
+} else if (inputThreads <= 0) {
+  numThreads = availableThreads;
+}
+
+if (isMainThread) {
+  if (numThreads === 1) {
+    console.log(
+      chalk.green(
+        '🐢  Using only 1 thread to generate a wallet, this might take a while...'
+      )
+    );
+  } else {
+    console.log(
+      chalk.green(`🏎️💨 Using ${numThreads}/${allMachineThreads} threads to generate a wallet...`)
+    );
   }
 
-  const chain = options.chain.toUpperCase() || 'EVM';
-  if (supportedChains.includes(chain)) {
-    return new Method('wallet', {
-      chain,
-      options,
-    }).init();
+  const workers = [];
+
+  // create a shared buffer to communicate between workers
+  const sharedBuffer = new SharedArrayBuffer(4); // 4 bytes for the flag
+  const sharedArray = new Int32Array(sharedBuffer);
+  sharedArray[0] = 0; // 0 - not found, 1 - found
+
+  for (let i = 0; i < numThreads; i++) {
+    const worker = new Worker(__filename, {
+      workerData: {
+        workerId: i,
+        totalWorkers: numThreads,
+        chain,
+        options: JSON.parse(JSON.stringify(options)),
+        sharedBuffer,
+      },
+      stdout: true, // enable capturing stdout
+    });
+
+    // pipe worker stdout to main process
+    worker.stdout.on('data', (data) => {
+      if (Atomics.load(sharedArray, 0) === 0) {
+        process.stdout.write(data); // forward stdout to main process
+
+        return data;
+      }
+    });
+
+    worker.on('message', (message) => {
+      if (Atomics.load(sharedArray, 0) === 0) {
+        // set the shared flag to 1 to stop all workers
+        Atomics.store(sharedArray, 0, 1);
+
+        // print the log output from the worker
+        process.stdout.write(message.log);
+
+        // terminate all workers
+        workers.forEach((w) => w.terminate());
+
+        process.exit(0);
+      }
+    });
+
+    worker.on('error', (err) =>
+      console.error(`❌ Worker error: ${err.message}`)
+    );
+
+    workers.push(worker);
   }
+} else {
+  // worker thread (multi-threaded mode)
+  (async () => {
+    try {
+      // read shared flag before starting work
+      const sharedArray = new Int32Array(workerData.sharedBuffer);
+      if (Atomics.load(sharedArray, 0) === 1) {
+        process.exit(0); // exit early if a wallet has already been found
+      }
+
+      // create a new Method instance
+      const method = new Method('wallet', {
+        b: workerData.chain,
+        chain: workerData.chain,
+        options: workerData.options,
+      });
+
+      // capture stdout logs in a buffer
+      let logOutput = '';
+      const originalWrite = process.stdout.write;
+      process.stdout.write = (chunk, encoding, callback) => {
+        logOutput += chunk.toString();
+        if (callback) callback();
+      };
+
+      // print the wallet to stdout
+      await method.init();
+
+      // restore stdout
+      process.stdout.write = originalWrite;
+
+      // check the shared flag again before sending the result
+      if (Atomics.load(sharedArray, 0) === 1) {
+        process.exit(0);
+      }
 
-  log(chalk.red('⛔️  Error: this blockchain is not supported!'));
-})();
+      // send the log output to the main thread
+      parentPort.postMessage({ log: logOutput });
+    } catch (err) {
+      console.error(`Worker ${workerData.workerId} failed: ${err.message}`);
+    }
+  })();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yerofey/cryptowallet-cli",
-  "version": "1.36.2",
+  "version": "1.37.0",
   "description": "Crypto wallet generator CLI tool",
   "type": "module",
   "homepage": "https://github.com/yerofey/cryptowallet-cli",

package/src/Method.js

@@ -312,10 +312,6 @@ class Method {
                   addressHighlightedPart
                 )}${addressLastPart}${magenta(addressHighlightedSuffix)}`
               );
-              // DEBUG
-              if (IS_DEV) {
-                log(`___ ${item.address}`);
-              }
             } else {
               log(`👛  ${item.address}`);
             }
@@ -362,10 +358,6 @@ class Method {
                   addressHighlightedPart
                 )}${addressLastPart}`
               );
-              // DEBUG
-              if (IS_DEV) {
-                log(`___ ${item.address}`);
-              }
             } else {
               log(`👛  ${item.address}`);
             }
@@ -389,10 +381,6 @@ class Method {
               log(
                 `👛  ${addressFirstPart}${magenta(addressHighlightedSuffix)}`
               );
-              // DEBUG
-              if (IS_DEV) {
-                log(`___ ${item.address}`);
-              }
             } else {
               log(`👛  ${item.address}`);
             }

package/src/options.js

@@ -3,10 +3,7 @@ import { program } from 'commander';
 program.option('-b <ticker>', 'Wallet for specific blockchain', 'EVM');
 program.option('-c, --chain <ticker>', 'Wallet for specific blockchain', 'EVM');
 program.option('-C, --copy', 'Copy the result to the clipboard');
-program.option(
-  '-D, --csv [filename]',
-  'Save result into CSV file'
-);
+program.option('-D, --csv [filename]', 'Save result into CSV file');
 program.option(
   '-f, --format <format>',
   'Wallet format type (for cryptos with multiple wallet formats)'
@@ -37,8 +34,12 @@ program.option(
   '-S, --suffix-sensitive <suffix>',
   'Desired wallet suffix (case-sensitive)'
 );
+program.option(
+  '-t, --threads <threads>',
+  'Number of threads (cores) to use for wallet generation'
+);
 program.option('-v, --version', 'Display cryptowallet version');
-program.option('-T, --donate', 'Donate to the project');
+program.option('--donate', 'Donate to the project');
 program.parse();
 
 export const options = program.opts();