cryptoseed 1.0.0

package/src/bin/cli.js

@@ -0,0 +1,1785 @@
+#!/usr/bin/env node
+
+/**
+ * CryptoSeedRecovery - CLI Terminal Interativo Multilíngue
+ * 
+ * Desenvolvido sob o ecossistema b2 wallet (better2better, diegooris).
+ * Interface interativa profissional para restauração de sementes perdidas ou embaralhadas.
+ * Suporte a idiomas: Português, English, Español, 简体中文, 日本語.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const cliProgress = require('cli-progress');
+const ethers = require('ethers');
+
+const inquirerModule = require('inquirer');
+const inquirer = inquirerModule.default || inquirerModule;
+
+const { bip39, electrumPoet } = require('../lib/wordlists');
+const { validateElectrumMnemonic } = require('../lib/electrum-legacy');
+const { deriveAddress } = require('../lib/address-deriver');
+const { getSuggestions, getPrefixSuggestions } = require('../lib/typo');
+const { 
+  searchMode1, 
+  searchMode2And3, 
+  searchMode4,
+  getMode1Prefixes,
+  getMode23PartialStates,
+  getMode4PartialStates
+} = require('../lib/search-engine');
+
+const { getBalance, EVM_NETWORKS, NON_EVM_DEFAULTS } = require('../lib/balance-checker');
+
+const locales = require('../lib/cli-locales');
+
+let currentLocale = 'pt'; // Idioma de interface padrão
+
+// Helper de tradução dinâmico com suporte a formatação {0}, {1}, etc.
+function t(key, ...args) {
+  const locale = locales[currentLocale] || locales['en'] || locales['pt'];
+  let str = locale[key] || locales['en'][key] || locales['pt'][key] || '';
+  if (args.length > 0) {
+    args.forEach((val, i) => {
+      str = str.replace(new RegExp(`\\{${i}\\}`, 'g'), val);
+    });
+  }
+  return str;
+}
+
+// Detecção inteligente de idioma do sistema operacional do usuário
+function getSystemLocale() {
+  const envLang = process.env.LANG || process.env.LANGUAGE || '';
+  if (envLang.startsWith('en')) return 'en';
+  if (envLang.startsWith('es')) return 'es';
+  if (envLang.startsWith('zh')) return 'zh';
+  if (envLang.startsWith('ja')) return 'ja';
+  return 'pt'; // Padrão
+}
+
+// Helper para links clicáveis no terminal (Hyperlinks ANSI)
+function link(text, url) {
+  return `\u001b]8;;${url}\u0007${text}\u001b]8;;\u0007`;
+}
+
+// Cabeçalho da Marca Traduzido
+function printHeader() {
+  console.clear();
+  console.log(chalk.cyan('================================================================'));
+  console.log(chalk.cyan(`   🛡️  CryptoSeedRecovery - ${t('headerTitle')}`));
+  console.log(chalk.cyan(`   ${t('headerIntegration')} `) + chalk.cyan.bold.underline(link('Better2Better', 'https://better2better.net')));
+  console.log(chalk.cyan(`   ${t('headerLead')} `) + chalk.cyan.bold.underline(link('Diego Oris', 'https://diegohorantunes.web.app/')));
+  console.log(chalk.cyan('================================================================\n'));
+}
+
+/**
+ * Formata duração em milissegundos para leitura humana
+ */
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms.toFixed(1)} ms`;
+  let secs = ms / 1000;
+  if (secs < 60) return `${secs.toFixed(1)} s`;
+  let mins = secs / 60;
+  if (mins < 60) return `${mins.toFixed(1)} m`;
+  let hours = mins / 60;
+  if (hours < 24) return `${hours.toFixed(1)} h`;
+  let days = hours / 24;
+  if (days < 365) return `${days.toFixed(1)} d`;
+  let years = days / 365;
+  return `${years.toFixed(1)} y`;
+}
+
+/**
+ * Auxiliar para fatorial (Mode 4 progress)
+ */
+function factorial(n) {
+  let res = 1n;
+  for (let i = 2n; i <= BigInt(n); i++) res *= i;
+  return res;
+}
+
+/**
+ * Helper to check if user input is a step-back command
+ */
+function isBackInput(val) {
+  if (typeof val !== 'string') return false;
+  const clean = val.trim().toLowerCase();
+  return clean === 'back' || clean === 'voltar' || clean === 'volver' || clean === '返回' || clean === '戻る' || clean === '<' || clean === 'b';
+}
+
+/**
+ * Corrige erros ortográficos de forma interativa para uma semente fornecida pelo usuário.
+ */
+async function interactiveTypoHelper(rawPhrase, wordlist) {
+  const words = rawPhrase.trim().split(/\s+/);
+  const correctedWords = [];
+
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i].toLowerCase().trim();
+
+    // Se for curinga, ignora validação
+    if (word === '*' || word === '?' || word.endsWith('*')) {
+      correctedWords.push(word);
+      continue;
+    }
+
+    if (wordlist.includes(word)) {
+      correctedWords.push(word);
+    } else {
+      // 1. Tenta buscar por iniciais (comer por letras de trás para frente)
+      let prefixSuggestions = getPrefixSuggestions(word, wordlist);
+      let isDistanceTypo = false;
+
+      // 2. Se não houver sugestões de prefixo, tenta por distância de edição Levenshtein e teclado adjacente
+      if (prefixSuggestions.length === 0) {
+        prefixSuggestions = getSuggestions(word, wordlist, 15);
+        isDistanceTypo = true;
+      }
+
+      if (prefixSuggestions.length > 0) {
+        console.log(chalk.yellow(t('typoTitle', word, i + 1)));
+        
+        if (isDistanceTypo) {
+          console.log(chalk.cyan(t('typoDistanceCoincidence')));
+        } else {
+          // Determina o prefixo mais longo que bateu
+          let longestPrefix = '';
+          for (let len = word.length; len >= 1; len--) {
+            const testPref = word.substring(0, len);
+            if (wordlist.some(w => w.startsWith(testPref))) {
+              longestPrefix = testPref;
+              break;
+            }
+          }
+          console.log(chalk.cyan(t('typoPrefixCoincidence', longestPrefix)));
+        }
+
+        const choices = [...prefixSuggestions.slice(0, 15)];
+        if (!isDistanceTypo && prefixSuggestions.length >= 2) {
+          choices.push(t('typoChoicePrefixCandidates'));
+        }
+        choices.push(t('typoChoiceLost'), t('typoChoiceManual'), t('typoChoiceKeep'));
+
+        const ans = await inquirer.prompt([{
+          type: 'select',
+          name: 'choice',
+          message: t('typoChoicePrompt', i + 1),
+          choices: choices
+        }]);
+
+        if (ans.choice === t('typoChoiceLost')) {
+          correctedWords.push('*');
+        } else if (ans.choice === t('typoChoicePrefixCandidates')) {
+          correctedWords.push(prefixSuggestions.slice(0, 15).join(','));
+        } else if (ans.choice === t('typoChoiceManual')) {
+          const ansManual = await inquirer.prompt([{
+            type: 'input',
+            name: 'typed',
+            message: t('typoManualPrompt')
+          }]);
+          const manualWord = ansManual.typed.trim().toLowerCase();
+          if (wordlist.includes(manualWord)) {
+            correctedWords.push(manualWord);
+          } else {
+            console.log(chalk.yellow(t('typoManualInvalid', manualWord)));
+            correctedWords.push('*');
+          }
+        } else if (ans.choice === t('typoChoiceKeep')) {
+          correctedWords.push(word);
+        } else {
+          correctedWords.push(ans.choice);
+        }
+      } else {
+        // Se não bater com nenhuma inicial conhecida nem distância de edição, trata automaticamente como desconhecida (*) para testar 1 por 1 de toda a lista
+        console.log(chalk.red(t('typoNoPrefix', word, i + 1)));
+        console.log(chalk.green(t('typoNoPrefixSub')));
+        correctedWords.push('*');
+      }
+    }
+  }
+
+  return correctedWords;
+}
+
+function runParallelSearch({
+  mode,
+  phraseWords,
+  constraints,
+  format,
+  wordlist,
+  wallet,
+  coin,
+  targetAddress,
+  pattern,
+  threads,
+  totalCombinations,
+  onProgress,
+  language
+}) {
+  return new Promise((resolve, reject) => {
+    const { Worker } = require('worker_threads');
+    const path = require('path');
+    
+    let subtasks = [];
+    if (mode === 1) {
+      subtasks = getMode1Prefixes(phraseWords, format, wordlist, coin, threads);
+    } else if (mode === 2 || mode === 3) {
+      subtasks = getMode23PartialStates(phraseWords, constraints, format, wordlist, coin, threads);
+    } else if (mode === 4) {
+      subtasks = getMode4PartialStates(phraseWords, threads);
+    }
+
+    if (subtasks.length === 0) {
+      return reject(new Error('No subtasks generated to distribute.'));
+    }
+
+    const actualThreads = Math.min(threads, subtasks.length);
+    const chunks = Array.from({ length: actualThreads }, () => []);
+    for (let i = 0; i < subtasks.length; i++) {
+      chunks[i % actualThreads].push(subtasks[i]);
+    }
+
+    const workers = [];
+    const workerProgress = Array(actualThreads).fill(0);
+    const allResults = [];
+    const allAssembled = [];
+    let completedWorkers = 0;
+
+    const workerPath = path.join(__dirname, '../lib/search-worker.js');
+
+    function cleanUpWorkers() {
+      for (const w of workers) {
+        w.terminate().catch(() => {});
+      }
+    }
+
+    for (let i = 0; i < actualThreads; i++) {
+      const worker = new Worker(workerPath);
+      workers.push(worker);
+
+      worker.on('message', (msg) => {
+        if (msg.type === 'progress') {
+          workerProgress[i] = msg.checked;
+          const currentTotal = workerProgress.reduce((sum, val) => sum + val, 0);
+          onProgress(currentTotal, totalCombinations);
+        } else if (msg.type === 'done') {
+          workerProgress[i] = msg.totalChecked;
+          
+          if (msg.results && msg.results.length > 0) {
+            allResults.push(...msg.results);
+          }
+          if (msg.assembledCandidates && msg.assembledCandidates.length > 0) {
+            allAssembled.push(...msg.assembledCandidates);
+          }
+
+          completedWorkers++;
+          if (completedWorkers === actualThreads) {
+            cleanUpWorkers();
+            
+            const uniqueResults = [...new Set(allResults)].slice(0, 50000);
+            
+            const seenPhrases = new Set();
+            const uniqueAssembled = [];
+            for (const cand of allAssembled) {
+              if (!seenPhrases.has(cand.phrase)) {
+                seenPhrases.add(cand.phrase);
+                uniqueAssembled.push(cand);
+                if (uniqueAssembled.length >= 50000) break;
+              }
+            }
+
+            const totalChecked = workerProgress.reduce((sum, val) => sum + val, 0);
+            onProgress(totalChecked, totalCombinations);
+
+            resolve({
+              results: uniqueResults,
+              totalChecked: BigInt(totalChecked),
+              assembledCandidates: uniqueAssembled
+            });
+          }
+        } else if (msg.type === 'error') {
+          cleanUpWorkers();
+          reject(new Error(msg.message));
+        }
+      });
+
+      worker.on('error', (err) => {
+        cleanUpWorkers();
+        reject(err);
+      });
+
+      worker.on('exit', (code) => {
+        if (code !== 0 && completedWorkers < actualThreads) {
+          cleanUpWorkers();
+          reject(new Error(`Worker stopped with exit code ${code}`));
+        }
+      });
+
+      const startMsg = {
+        type: 'start',
+        mode,
+        phraseWords,
+        constraints,
+        format,
+        wordlist,
+        walletType: wallet,
+        coinKey: coin,
+        targetAddress,
+        pattern,
+        startPrefixes: mode === 1 ? chunks[i] : null,
+        startStates: (mode === 2 || mode === 3 || mode === 4) ? chunks[i] : null,
+        language
+      };
+
+      worker.postMessage(startMsg);
+    }
+  });
+}
+
+async function main() {
+  // Imprime o cabeçalho traduzido
+  printHeader();
+
+  let step = 'format';
+  const history = [];
+
+  // Declaração de todas as variáveis do wizard
+  let format = '';
+  let yearProfile = '';
+  let coin = '';
+  let wallet = '';
+  let pattern = null;
+  let wordlist = [];
+  let language = 'en';
+  let mode = null;
+  let rawPhrase = '';
+  let phraseWords = [];
+  let targetAddress = '';
+  let threadMode = 'single';
+  let threads = 1;
+  const constraints = {};
+  let totalCombinations = 1n;
+
+  while (step !== 'execute') {
+    switch (step) {
+      case 'format': {
+        const formatAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'format',
+          message: t('chooseFormat'),
+          choices: [
+            { name: t('formatBip39'), value: 'bip39' },
+            { name: t('formatElectrum'), value: 'electrum' },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+        if (formatAnswers.format === '__back__') {
+          return '__back_to_lang__';
+        }
+        format = formatAnswers.format;
+        history.push('format');
+        step = 'year';
+        break;
+      }
+
+      case 'year': {
+        const yearAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'year',
+          message: t('chooseYear'),
+          choices: [
+            { name: t('yearModern'), value: 'modern_2020_present' },
+            { name: t('yearMiddle'), value: 'middle_2015_2019' },
+            { name: t('yearLegacy'), value: 'legacy_2011_2014' },
+            { name: t('yearGenesis'), value: 'genesis_pre_2011' },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+
+        if (yearAnswers.year === '__back__') {
+          step = history.pop() || 'format';
+        } else {
+          yearProfile = yearAnswers.year;
+          if (yearProfile === 'genesis_pre_2011') {
+            console.log(chalk.yellow.bold('\n================================================================================'));
+            console.log(chalk.yellow.bold(`    🎓 ${t('satoshiTitle')} 🎓`));
+            console.log(chalk.yellow.bold('================================================================================'));
+            console.log(chalk.white(t('satoshiDesc1')));
+            console.log('\n' + chalk.bold(t('satoshiHowWorked')));
+            console.log(chalk.gray(`  • ${t('satoshiPoint1')}`));
+            console.log(chalk.gray(`  • ${t('satoshiPoint2')}`));
+            console.log(chalk.gray(`  • ${t('satoshiPoint3')}`));
+            console.log(chalk.gray(`  • ${t('satoshiPoint4')}`));
+            console.log('\n' + chalk.bold(t('satoshiInvention')));
+            console.log(chalk.gray(`  • ${t('satoshiInventionPoint1')}`));
+            console.log(chalk.gray(`  • ${t('satoshiInventionPoint2')}`));
+            console.log('\n' + chalk.bold(t('satoshiWhatToDo')));
+            console.log(chalk.gray(`  • ${t('satoshiWhatToDoPoint1')}`));
+            console.log(chalk.yellow.bold('================================================================================\n'));
+
+            await inquirer.prompt([{
+              type: 'select',
+              name: 'back',
+              message: t('satoshiWhatToDo'),
+              choices: [
+                { name: t('backChoice'), value: '__back__' }
+              ]
+            }]);
+            step = 'year';
+          } else {
+            history.push('year');
+            step = 'coin';
+          }
+        }
+        break;
+      }
+
+      case 'coin': {
+        const blockchainChoices = [
+          { name: 'Ethereum / EVMs (ETH, BNB, Polygon, Arbitrum, Optimism, Avalanche, Base, Fantom, Cronos, Harmony)', value: 'ETH' },
+          { name: 'Bitcoin (BTC)', value: 'BTC' },
+          { name: 'Litecoin (LTC)', value: 'LTC' },
+          { name: 'Dogecoin (DOGE)', value: 'DOGE' },
+          { name: 'Solana (SOL)', value: 'SOL' },
+          { name: 'TRON (TRX)', value: 'TRX' },
+          { name: 'Cardano (ADA)', value: 'ADA' },
+          { name: 'Ripple (XRP)', value: 'XRP' },
+          { name: 'Polkadot (DOT)', value: 'DOT' },
+          { name: 'Kusama (KSM)', value: 'KSM' },
+          { name: 'Cosmos (ATOM)', value: 'ATOM' },
+          { name: 'Osmosis (OSMO)', value: 'OSMO' },
+          { name: 'Waves (WAVES)', value: 'WAVES' },
+          { name: 'Kaspa (KAS)', value: 'KAS' },
+          { name: 'Stellar (XLM)', value: 'XLM' },
+          { name: 'Zcash (ZEC)', value: 'ZEC' },
+          { name: 'Bitcoin Cash (BCH)', value: 'BCH' },
+          { name: 'Monero (XMR)', value: 'XMR' },
+          { name: 'Dash (DASH)', value: 'DASH' },
+          { name: 'Secret Network (SCRT)', value: 'SCRT' },
+          { name: 'Injective (INJ)', value: 'INJ' },
+          { name: 'Hedera (HBAR)', value: 'HBAR' },
+          { name: 'NEM (XEM)', value: 'XEM' },
+          { name: 'Chia (XCH)', value: 'XCH' },
+          { name: 'Gnosis Chain (GNOSIS)', value: 'GNOSIS' },
+          { name: 'Tezos (XTZ)', value: 'XTZ' },
+          { name: 'Algorand (ALGO)', value: 'ALGO' },
+          { name: 'Near (NEAR)', value: 'NEAR' },
+          { name: 'Sui (SUI)', value: 'SUI' },
+          { name: 'Aptos (APT)', value: 'APT' },
+          { name: chalk.yellow(t('backChoice')), value: '__back__' }
+        ];
+
+        const blockchainAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'coin',
+          message: t('chooseBlockchain'),
+          choices: blockchainChoices
+        }]);
+
+        if (blockchainAnswers.coin === '__back__') {
+          step = history.pop() || 'year';
+        } else {
+          coin = blockchainAnswers.coin;
+          history.push('coin');
+          step = 'wallet';
+        }
+        break;
+      }
+
+      case 'wallet': {
+        let walletChoices = [];
+        if (coin === 'ETH' || coin === 'GNOSIS') {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: t('walletMeta'), value: 'metamask' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: `Ledger (${t('walletLedger')} m/44'/60'/0'/0)`, value: 'ledger' },
+            { name: `Trezor (${t('walletTrezor')} m/44'/60'/0'/0)`, value: 'trezor' }
+          ];
+        } else if (coin === 'BTC') {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: 'Electrum', value: 'electrum' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: t('walletLedger'), value: 'ledger' },
+            { name: t('walletTrezor'), value: 'trezor' }
+          ];
+        } else if (coin === 'SOL') {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: t('walletPhantom'), value: 'phantom' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: t('walletLedger'), value: 'ledger' }
+          ];
+        } else if (coin === 'ADA') {
+          walletChoices = [
+            { name: t('walletYoroi'), value: 'yoroi' },
+            { name: 'Daedalus Wallet', value: 'daedalus' },
+            { name: t('walletLedger'), value: 'ledger' }
+          ];
+        } else {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: t('walletLedger'), value: 'ledger' },
+            { name: t('walletTrezor'), value: 'trezor' }
+          ];
+        }
+        walletChoices.push({ name: chalk.yellow(t('backChoice')), value: '__back__' });
+
+        const walletAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'wallet',
+          message: t('chooseWallet'),
+          choices: walletChoices
+        }]);
+
+        if (walletAnswers.wallet === '__back__') {
+          step = history.pop() || 'coin';
+        } else {
+          wallet = walletAnswers.wallet;
+          history.push('wallet');
+          if (wallet !== 'b2wallet' && (coin === 'BTC' || coin === 'LTC' || coin === 'SOL' || coin === 'ADA')) {
+            step = 'pattern';
+          } else {
+            pattern = null;
+            step = 'language';
+          }
+        }
+        break;
+      }
+
+      case 'pattern': {
+        let patternChoices = [];
+        if (coin === 'BTC') {
+          patternChoices = [
+            { name: t('btcSegwit'), value: 'segwit' },
+            { name: t('btcNested'), value: 'nested' },
+            { name: t('btcLegacy'), value: 'legacy' },
+            { name: t('btcTaproot'), value: 'taproot' }
+          ];
+        } else if (coin === 'LTC') {
+          patternChoices = [
+            { name: t('ltcSegwit'), value: 'segwit' },
+            { name: t('ltcLegacy'), value: 'legacy' }
+          ];
+        } else if (coin === 'SOL') {
+          patternChoices = [
+            { name: t('solPhantom'), value: 'phantom' },
+            { name: t('solSollet'), value: 'sollet' }
+          ];
+        } else if (coin === 'ADA') {
+          patternChoices = [
+            { name: t('adaShelley'), value: 'shelley' },
+            { name: t('adaByron'), value: 'byron' }
+          ];
+        }
+        patternChoices.push({ name: chalk.yellow(t('backChoice')), value: '__back__' });
+
+        const patternAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'pattern',
+          message: coin === 'BTC' ? t('choosePatternBTC') : (coin === 'LTC' ? t('choosePatternLTC') : (coin === 'SOL' ? t('choosePatternSOL') : t('choosePatternADA'))),
+          choices: patternChoices
+        }]);
+
+        if (patternAnswers.pattern === '__back__') {
+          step = history.pop() || 'wallet';
+        } else {
+          pattern = patternAnswers.pattern;
+          history.push('pattern');
+          step = 'language';
+        }
+        break;
+      }
+
+      case 'language': {
+        if (format === 'bip39') {
+          let langChoices = [
+            { name: 'Inglês (English)', value: 'en' },
+            { name: 'Português (Portuguese)', value: 'pt' },
+            { name: 'Espanhol (Spanish)', value: 'es' },
+            { name: 'Francês (French)', value: 'fr' },
+            { name: 'Italiano (Italian)', value: 'it' },
+            { name: 'Tcheco (Czech)', value: 'cz' },
+            { name: 'Japonês (Japanese)', value: 'ja' },
+            { name: 'Coreano (Korean)', value: 'ko' },
+            { name: 'Chinês Simplificado (Simplified Chinese)', value: 'zh_cn' },
+            { name: 'Chinês Tradicional (Traditional Chinese)', value: 'zh_tw' }
+          ];
+          let langMessage = t('chooseLang');
+
+          if (coin === 'ALGO') {
+            langChoices = [{ name: 'Inglês (English)', value: 'en' }];
+            langMessage = `${chalk.yellow(t('algoLangOnly'))}\n  ${t('chooseLang')}`;
+          } else if (coin === 'ADA' && pattern === 'byron') {
+            langChoices = [{ name: 'Inglês (English)', value: 'en' }];
+            langMessage = `${chalk.yellow(t('adaByronLangOnly'))}\n  ${t('chooseLang')}`;
+          } else if (yearProfile === 'legacy_2011_2014') {
+            langChoices = [{ name: 'Inglês (English)', value: 'en' }];
+            langMessage = `${chalk.yellow(t('legacyYearLangWarning'))}\n  ${t('chooseLang')}`;
+          }
+
+          langChoices.push({ name: chalk.yellow(t('backChoice')), value: '__back__' });
+
+          const langAnswers = await inquirer.prompt([{
+            type: 'select',
+            name: 'lang',
+            message: langMessage,
+            choices: langChoices
+          }]);
+
+          if (langAnswers.lang === '__back__') {
+            step = history.pop() || 'wallet';
+          } else {
+            language = langAnswers.lang;
+            wordlist = bip39[language];
+            history.push('language');
+            step = 'mode';
+          }
+        } else {
+          wordlist = electrumPoet;
+          language = 'en';
+          step = 'mode';
+        }
+        break;
+      }
+
+      case 'mode': {
+        const modeAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'mode',
+          message: t('chooseMode'),
+          choices: [
+            { name: t('mode1'), value: 1 },
+            { name: t('mode2'), value: 2 },
+            { name: t('mode3'), value: 3 },
+            { name: t('mode4'), value: 4 },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+
+        if (modeAnswers.mode === '__back__') {
+          step = history.pop() || 'language';
+        } else {
+          mode = modeAnswers.mode;
+          history.push('mode');
+          step = 'phrase';
+        }
+        break;
+      }
+
+      case 'phrase': {
+        let wordsInputMessage = '';
+        const guidanceNote = chalk.cyan(t('guidanceTitle')) + chalk.white(t('guidanceBody'));
+
+        if (mode === 1) {
+          wordsInputMessage = guidanceNote + t('inputMsgMode1');
+        } else if (mode === 2) {
+          wordsInputMessage = guidanceNote + t('inputMsgMode2');
+        } else if (mode === 3 || mode === 4) {
+          wordsInputMessage = guidanceNote + t('inputMsgMode3');
+        }
+
+        wordsInputMessage += chalk.gray('\n' + t('backInputHint') + '\n>');
+
+        const phraseAnswers = await inquirer.prompt([{
+          type: 'input',
+          name: 'rawPhrase',
+          message: wordsInputMessage,
+          validate: (val) => {
+            if (isBackInput(val)) return true;
+            return val.trim().split(/\s+/).length >= 4 ? true : t('validateMinWords');
+          }
+        }]);
+
+        rawPhrase = phraseAnswers.rawPhrase.trim();
+
+        if (isBackInput(rawPhrase)) {
+          step = history.pop() || 'mode';
+        } else {
+          console.log(chalk.cyan(t('validatingSpell')));
+          phraseWords = await interactiveTypoHelper(rawPhrase, wordlist);
+          console.log(chalk.green(t('spellValidated', phraseWords.join(' '))));
+
+          const unknownWordsCount = phraseWords.filter(w => w === '*' || w === '?').length;
+
+          if (unknownWordsCount > 1) {
+            console.log(chalk.red.bold('\n================================================================================'));
+            console.log(chalk.red.bold(t('complexityTitle')));
+            console.log(chalk.red.bold('================================================================================'));
+            console.log(chalk.yellow(t('complexityWarn', unknownWordsCount)));
+            console.log(chalk.yellow(t('complexityBeAware')));
+
+            console.log(chalk.bold(t('complexity24Seeds')));
+            console.log(chalk.white(t('complexity1Word')));
+            console.log(chalk.white(t('complexity2Words')));
+            console.log(chalk.white(t('complexity3Words')));
+            console.log(chalk.white(t('complexity4Words')));
+            console.log(chalk.white(t('complexity5Words')));
+
+            console.log(chalk.bold(t('complexityInPractice')));
+            console.log(chalk.green(t('complexityPractice1')));
+            console.log(chalk.yellow(t('complexityPractice2')));
+            console.log(chalk.red(t('complexityPractice3')));
+            console.log(chalk.red.bold(t('complexityPractice4')));
+
+            console.log('\n' + chalk.bold(t('complexityInPractice')));
+            console.log(chalk.gray(t('complexityChecksumNote')));
+            console.log(chalk.red.bold('================================================================================'));
+
+            const confirmAnswers = await inquirer.prompt([{
+              type: 'select',
+              name: 'proceed',
+              message: chalk.red.bold(t('complexityProceedConfirm')),
+              choices: [
+                { name: t('complexityConfirmYes'), value: 'yes' },
+                { name: t('complexityConfirmNo'), value: 'no' }
+              ]
+            }]);
+
+            if (confirmAnswers.proceed === 'no') {
+              console.log(chalk.yellow(t('complexityCancelled')));
+              step = 'phrase'; // Stay/Loop back to phrase input
+              break;
+            }
+          }
+
+          history.push('phrase');
+          step = 'targetAddress';
+        }
+        break;
+      }
+
+      case 'targetAddress': {
+        const addressAnswers = await inquirer.prompt([{
+          type: 'input',
+          name: 'targetAddress',
+          message: t('targetAddressPrompt') + chalk.gray('\n' + t('backInputHint') + '\n>'),
+          validate: (val) => {
+            if (isBackInput(val)) return true;
+            return val.trim() === '' ? true : (val.trim().length > 10 ? true : t('invalidAddress'));
+          }
+        }]);
+
+        const rawAddr = addressAnswers.targetAddress.trim();
+
+        if (isBackInput(rawAddr)) {
+          step = history.pop() || 'phrase';
+        } else {
+          targetAddress = rawAddr;
+          history.push('targetAddress');
+          step = 'threadMode';
+        }
+        break;
+      }
+
+      case 'threadMode': {
+        const threadModeAnswer = await inquirer.prompt([{
+          type: 'select',
+          name: 'threadMode',
+          message: t('chooseThreadMode'),
+          choices: [
+            { name: t('threadModeSingle'), value: 'single' },
+            { name: t('threadModeMulti'), value: 'multi' },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+
+        if (threadModeAnswer.threadMode === '__back__') {
+          step = history.pop() || 'targetAddress';
+        } else {
+          threadMode = threadModeAnswer.threadMode;
+          history.push('threadMode');
+          if (threadMode === 'multi') {
+            step = 'threads';
+          } else {
+            step = 'constraints';
+          }
+        }
+        break;
+      }
+
+      case 'threads': {
+        const os = require('os');
+        const maxThreads = os.cpus().length || 1;
+        const threadCountAnswer = await inquirer.prompt([{
+          type: 'input',
+          name: 'threads',
+          message: t('threadCountPrompt', maxThreads) + chalk.gray('\n' + t('backInputHint') + '\n>'),
+          default: String(maxThreads),
+          validate: (val) => {
+            if (isBackInput(val)) return true;
+            const num = Number(val);
+            return (!isNaN(num) && Number.isInteger(num) && num >= 1 && num <= maxThreads) ? true : `Invalid thread count (1 - ${maxThreads})`;
+          }
+        }]);
+
+        const rawThr = threadCountAnswer.threads.trim();
+
+        if (isBackInput(rawThr)) {
+          step = history.pop() || 'threadMode';
+        } else {
+          threads = parseInt(rawThr, 10) || 1;
+          history.push('threads');
+          step = 'constraints';
+        }
+        break;
+      }
+
+      case 'constraints': {
+        if (mode === 2 || mode === 3) {
+          const constraintSetup = await inquirer.prompt([{
+            type: 'select',
+            name: 'addConstraints',
+            message: t('addConstraintsPrompt'),
+            choices: [
+              { name: t('yes'), value: 'yes' },
+              { name: t('no'), value: 'no' },
+              { name: chalk.yellow(t('backChoice')), value: '__back__' }
+            ]
+          }]);
+
+          if (constraintSetup.addConstraints === '__back__') {
+            step = history.pop() || 'threadMode';
+          } else if (constraintSetup.addConstraints === 'yes') {
+            let adding = true;
+            for (const key of Object.keys(constraints)) delete constraints[key];
+
+            while (adding) {
+              const typeAnswer = await inquirer.prompt([{
+                type: 'select',
+                name: 'type',
+                message: t('addConstraintType'),
+                choices: [
+                  { name: t('constraintTypeOK'), value: 'OK' },
+                  { name: t('constraintTypeNOK'), value: 'NOK' },
+                  { name: t('constraintTypeDONE'), value: 'DONE' }
+                ]
+              }]);
+
+              if (typeAnswer.type === 'DONE') {
+                adding = false;
+                break;
+              }
+
+              const slotAnswers = await inquirer.prompt([
+                {
+                  type: 'input',
+                  name: 'slot',
+                  message: t('constraintSlotPrompt', phraseWords.length),
+                  validate: (val) => {
+                    const num = Number(val);
+                    return (!isNaN(num) && num >= 1 && num <= phraseWords.length) ? true : t('invalidSlot');
+                  }
+                },
+                {
+                  type: 'input',
+                  name: 'word',
+                  message: t('constraintWordPrompt'),
+                  validate: (val) => wordlist.includes(val.trim().toLowerCase()) ? true : t('wordNotInDict')
+                }
+              ]);
+
+              const slotIdx = parseInt(slotAnswers.slot, 10) - 1;
+              const cleanWord = slotAnswers.word.trim().toLowerCase();
+
+              if (!constraints[slotIdx]) {
+                constraints[slotIdx] = { excludedWords: [] };
+              }
+
+              if (typeAnswer.type === 'OK') {
+                constraints[slotIdx].requiredWord = cleanWord;
+              } else {
+                constraints[slotIdx].excludedWords.push(cleanWord);
+              }
+
+              const continueAnswer = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'continue',
+                message: t('addAnotherConstraint'),
+                default: true
+              }]);
+              adding = continueAnswer.continue;
+            }
+
+            history.push('constraints');
+            step = 'confirmSearch';
+          } else {
+            for (const key of Object.keys(constraints)) delete constraints[key];
+            history.push('constraints');
+            step = 'confirmSearch';
+          }
+        } else {
+          step = 'confirmSearch';
+        }
+        break;
+      }
+
+      case 'confirmSearch': {
+        // 13. Cálculo de combinações totais
+        totalCombinations = 1n;
+        if (mode === 1) {
+          const slots = phraseWords.map(pat => {
+            const clean = pat.toLowerCase().trim();
+            if (clean.includes(',')) {
+              return clean.split(',').map(s => s.trim()).filter(Boolean);
+            } else if (clean === '*' || clean === '?') {
+              return wordlist;
+            } else if (clean.endsWith('*')) {
+              const prefix = clean.slice(0, -1);
+              return wordlist.filter(w => w.startsWith(prefix));
+            } else {
+              return [clean];
+            }
+          });
+          totalCombinations = slots.reduce((acc, slot) => acc * BigInt(slot.length), 1n);
+        } else if (mode === 2 || mode === 3) {
+          const seedSize = phraseWords.length;
+          const fixedPositions = {};
+          const activeConstraints = constraints || {};
+          for (let idx = 0; idx < seedSize; idx++) {
+            if (activeConstraints[idx] && activeConstraints[idx].requiredWord) {
+              fixedPositions[idx] = true;
+            }
+          }
+          const floatingWords = phraseWords.map(w => w.toLowerCase().trim());
+          for (let idx = 0; idx < seedSize; idx++) {
+            if (fixedPositions[idx]) {
+              const fixedWord = activeConstraints[idx].requiredWord.toLowerCase().trim();
+              const matchIdx = floatingWords.indexOf(fixedWord);
+              if (matchIdx !== -1) {
+                floatingWords.splice(matchIdx, 1);
+              }
+            }
+          }
+          const expandedFloatingPools = floatingWords.map(word => {
+            const clean = word.toLowerCase().trim();
+            if (clean.includes(',')) {
+              return clean.split(',').map(s => s.trim()).filter(Boolean);
+            } else if (clean === '*' || clean === '?') {
+              return wordlist;
+            } else if (clean.endsWith('*')) {
+              const prefix = clean.slice(0, -1);
+              return wordlist.filter(w => w.startsWith(prefix));
+            } else {
+              return [clean];
+            }
+          });
+          let remainingWordsCount = expandedFloatingPools.length;
+          for (let i = 0; i < expandedFloatingPools.length; i++) {
+            totalCombinations *= BigInt(expandedFloatingPools[i].length) * BigInt(remainingWordsCount);
+            remainingWordsCount--;
+          }
+        } else if (mode === 4) {
+          totalCombinations = factorial(phraseWords.length);
+        }
+
+        // 14. Simulador de Velocidade de Consulta de Saldos
+        const combosNum = Number(totalCombinations);
+        const timePublicAPI = combosNum * 50;
+        const timeLocalNode = combosNum * 0.1;
+
+        console.log(chalk.cyan('\n================================================================'));
+        console.log(chalk.cyan(t('speedSimHeader')));
+        console.log(chalk.cyan('================================================================'));
+        console.log(`${t('speedSimTotalCombos', totalCombinations.toString())}`);
+        console.log('----------------------------------------------------------------');
+        console.log(chalk.white(t('speedSimTimeEst')));
+        console.log(chalk.yellow(t('speedSimPublic')) + chalk.bold(formatDuration(timePublicAPI)));
+        console.log(chalk.green(t('speedSimLocal')) + chalk.bold(formatDuration(timeLocalNode)));
+        console.log(chalk.gray(t('speedSimNote')));
+        console.log(chalk.cyan('================================================================\n'));
+
+        // Confirmação de Execução
+        console.log(chalk.cyan('================================================================'));
+        console.log(chalk.cyan(t('prepEngineTitle')));
+        console.log(chalk.cyan('================================================================'));
+        console.log(t('prepFormat', format.toUpperCase()));
+        console.log(t('prepWallet', wallet.toUpperCase()));
+        console.log(t('prepYear', yearProfile.toUpperCase()));
+        if (pattern) {
+          console.log(t('prepPattern', pattern.toUpperCase()));
+        }
+        console.log(t('prepCoin', coin));
+        let targetAddrDisplay = targetAddress;
+        if (!targetAddrDisplay) {
+          if (currentLocale === 'pt') targetAddrDisplay = 'QUALQUER SEMENTE VÁLIDA (COLETAR TODAS)';
+          else if (currentLocale === 'es') targetAddrDisplay = 'CUALQUIER SEMILLA VÁLIDA (COLECTAR TODAS)';
+          else if (currentLocale === 'zh') targetAddrDisplay = '任何有效助记词 (收集全部)';
+          else if (currentLocale === 'ja') targetAddrDisplay = '任意の有效なシード (すべて収集)';
+          else targetAddrDisplay = 'ANY VALID SEED (COLLECT ALL)';
+        }
+        console.log(t('prepTargetAddr', targetAddrDisplay));
+        console.log(t('prepWords', phraseWords.join(' ')));
+        console.log(chalk.cyan('================================================================\n'));
+
+        const execAns = await inquirer.prompt([{
+          type: 'select',
+          name: 'confirm',
+          message: t('confirmStartSearch'),
+          choices: [
+            { name: t('yes') + ' (Start)', value: 'yes' },
+            { name: t('backChoice'), value: '__back__' }
+          ]
+        }]);
+
+        if (execAns.confirm === '__back__') {
+          step = history.pop() || 'constraints';
+        } else {
+          step = 'execute';
+        }
+        break;
+      }
+    }
+  }
+
+  // Prepara barra de progresso
+  const multibar = new cliProgress.MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: t('progressBarFormat')
+  }, cliProgress.Presets.shades_grey);
+
+  let pbar;
+  let startTime = Date.now();
+
+  const onProgress = (checked, total) => {
+    if (!pbar) {
+      pbar = multibar.create(Number(total), 0);
+    }
+    const elapsedSecs = (Date.now() - startTime) / 1000;
+    const speed = elapsedSecs > 0 ? Math.round(Number(checked) / elapsedSecs) : 0;
+    pbar.update(Number(checked), { speed });
+  };
+
+  let searchResult;
+  try {
+    if (threadMode === 'multi') {
+      console.log(chalk.cyan(t('threadsStarted', threads)));
+      searchResult = await runParallelSearch({
+        mode,
+        phraseWords,
+        constraints,
+        format,
+        wordlist,
+        wallet,
+        coin,
+        targetAddress,
+        pattern,
+        threads,
+        totalCombinations,
+        onProgress,
+        language
+      });
+    } else {
+      if (mode === 1) {
+        searchResult = searchMode1(phraseWords, format, wordlist, wallet, coin, targetAddress, onProgress, pattern, null, language);
+      } else if (mode === 2 || mode === 3) {
+        searchResult = searchMode2And3(phraseWords, constraints, format, wordlist, wallet, coin, targetAddress, onProgress, pattern, null, language);
+      } else if (mode === 4) {
+        // For safety, warn if permutating too many items
+        if (phraseWords.length > 10) {
+          const confirmPerm = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'proceed',
+            message: chalk.red(t('permutingWarning', phraseWords.length, phraseWords.length)),
+            default: false
+          }]);
+
+          if (!confirmPerm.proceed) {
+            console.log(chalk.yellow(t('permutingCancelled')));
+            process.exit(0);
+          }
+        }
+        searchResult = searchMode4(phraseWords, format, wallet, coin, targetAddress, onProgress, pattern, null, language);
+      }
+    }
+  } catch (err) {
+    multibar.stop();
+    console.error(chalk.red(t('searchError', err.message)));
+    process.exit(1);
+  }
+
+  multibar.stop();
+  const endTime = Date.now();
+  const elapsedSecs = ((endTime - startTime) / 1000).toFixed(2);
+
+  // 16. Relatório de Resultados
+  console.log(chalk.cyan('\n================================================================'));
+  console.log(chalk.cyan(t('endExecutionTitle')));
+  console.log(chalk.cyan('================================================================'));
+  console.log(t('elapsedTime', elapsedSecs));
+  console.log(t('testedSeeds', searchResult.totalChecked.toString()));
+  console.log(t('averageSpeed', Math.round(Number(searchResult.totalChecked) / parseFloat(elapsedSecs))));
+
+  const results = searchResult.results;
+  const assembled = searchResult.assembledCandidates || [];
+
+  console.log(t('totalChecksumPassed', assembled.length.toString()));
+
+  const reportLines = [
+    '===========================================================',
+    t('reportTitle'),
+    '===========================================================',
+    t('reportDateTime', new Date().toLocaleString()),
+    t('reportWallet', wallet.toUpperCase()),
+    t('reportYear', yearProfile.toUpperCase()),
+    t('reportBlockchain', coin),
+    t('reportDerivation', pattern ? pattern.toUpperCase() : 'STANDARD/PADRÃO'),
+    t('reportTested', searchResult.totalChecked.toString()),
+    t('reportChecksumValid', assembled.length),
+    t('reportSearchTime', elapsedSecs),
+    '-----------------------------------------------------------',
+    t('reportEstSpeedHeader'),
+    t('reportEstPublic', formatDuration(assembled.length * 50)),
+    t('reportEstLocal', formatDuration(assembled.length * 0.1)),
+    '-----------------------------------------------------------',
+    t('reportExactCompatibleHeader'),
+    ...(results.length > 0 ? results.map((r, i) => t('reportOptionIdx', i + 1, r)) : [t('reportNoneFound')]),
+    '-----------------------------------------------------------',
+    t('reportAssembledHeader'),
+    ...assembled.slice(0, 1000).map((cand, idx) => t('reportAssembledItem', idx + 1, cand.phrase, cand.address)),
+    ...(assembled.length > 1000 ? [t('reportMoreOmitted', assembled.length - 1000)] : []),
+    '===========================================================',
+    t('reportFooterSafe'),
+    t('reportFooterDev')
+  ];
+
+  if (results.length > 0) {
+    console.log(t('successFound'));
+    console.log(chalk.green(results.map((r, i) => t('reportOptionIdx', i + 1, r)).join('\n')));
+  } else {
+    console.log(t('noneFound'));
+    console.log(chalk.gray(t('noneFoundDica1')));
+    console.log(chalk.gray(t('noneFoundDica2')));
+  }
+
+  // Escrever em arquivo txt
+  const reportFilename = `resultado_recuperacao_${Date.now()}.txt`;
+  const reportPath = path.join(process.cwd(), reportFilename);
+  fs.writeFileSync(reportPath, reportLines.join('\n'), 'utf8');
+
+  console.log(chalk.cyan(t('reportSaved', reportPath)));
+
+  // 17. Consulta de Saldos (Opcional)
+  if (assembled.length > 0) {
+    const uniqueAddresses = [...new Set(assembled.map(a => a.address))];
+    
+    console.log(chalk.cyan('\n================================================================'));
+    const balanceAns = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'query',
+      message: t('queryBalancesPrompt'),
+      default: false
+    }]);
+
+    if (balanceAns.query) {
+      // 17a. Choose Connection Type
+      const connAns = await inquirer.prompt([{
+        type: 'select',
+        name: 'connType',
+        message: t('queryConnectionType'),
+        choices: [
+          { name: t('connectionPublic'), value: 'public' },
+          { name: t('connectionPrivate'), value: 'private' }
+        ]
+      }]);
+
+      let selectedRpcUrl = '';
+      let defaultLocalUrl = 'http://localhost:8545';
+      let selectedCoinKey = coin;
+
+      // Check if EVM
+      const isEvm = coin === 'ETH' || coin === 'GNOSIS' || EVM_NETWORKS.some(n => n.id === coin);
+
+      if (connAns.connType === 'public') {
+        if (isEvm) {
+          // EVM blockchain list
+          const evmChoices = EVM_NETWORKS.map(net => ({
+            name: `${net.name} (ChainID: ${net.chainId})`,
+            value: net
+          }));
+
+          const chainAns = await inquirer.prompt([{
+            type: 'select',
+            name: 'network',
+            message: t('chooseEvmChain'),
+            choices: evmChoices
+          }]);
+
+          selectedRpcUrl = chainAns.network.rpc;
+          defaultLocalUrl = chainAns.network.localRpc;
+          selectedCoinKey = chainAns.network.id;
+        } else {
+          // Non-EVM
+          const defaultInfo = NON_EVM_DEFAULTS[coin];
+          if (defaultInfo) {
+            selectedRpcUrl = defaultInfo.rpc;
+            defaultLocalUrl = defaultInfo.localRpc;
+          } else {
+            selectedRpcUrl = 'http://localhost:8545';
+          }
+        }
+      } else {
+        // Private
+        if (isEvm) {
+          defaultLocalUrl = 'http://localhost:8545';
+        } else {
+          defaultLocalUrl = NON_EVM_DEFAULTS[coin]?.localRpc || 'http://localhost:8545';
+        }
+
+        const privAns = await inquirer.prompt([{
+          type: 'input',
+          name: 'rpc',
+          message: t('privateRpcPrompt', defaultLocalUrl)
+        }]);
+
+        selectedRpcUrl = privAns.rpc.trim() || defaultLocalUrl;
+      }
+
+      console.log(chalk.cyan(`\n🔌 Node URL: ${selectedRpcUrl}`));
+
+      // 17b. Query balances loop
+      for (let i = 0; i < uniqueAddresses.length; i++) {
+        const addr = uniqueAddresses[i];
+        console.log(chalk.cyan(`⏳ ${t('fetchingBalance', addr)}`));
+        try {
+          const bal = await getBalance(addr, selectedCoinKey, selectedRpcUrl);
+          console.log(chalk.green(`✔️  ${t('balanceResult', addr, bal)}`));
+        } catch (err) {
+          console.log(chalk.red(`\n❌ Error querying balance for ${addr}: ${err.message}`));
+          console.log(chalk.yellow(t('rateLimitError')));
+
+          const rateAns = await inquirer.prompt([{
+            type: 'select',
+            name: 'action',
+            message: t('rateLimitTitle'),
+            choices: [
+              { name: t('rateLimitCustom'), value: 'custom' },
+              { name: t('rateLimitLocal'), value: 'local' },
+              { name: t('rateLimitSkip'), value: 'skip' }
+            ]
+          }]);
+
+          if (rateAns.action === 'custom') {
+            const customAns = await inquirer.prompt([{
+              type: 'input',
+              name: 'url',
+              message: t('customNodePrompt')
+            }]);
+            selectedRpcUrl = customAns.url.trim();
+            i--; // retry current address
+          } else if (rateAns.action === 'local') {
+            selectedRpcUrl = defaultLocalUrl;
+            i--; // retry current address
+          } else {
+            console.log(chalk.yellow(t('rateLimitSkip')));
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
+function printHelp() {
+  console.clear();
+  console.log(chalk.cyan('================================================================'));
+  console.log(chalk.cyan(`   🛡️  CryptoSeedRecovery - ${t('helpTitle')}`));
+  console.log(chalk.cyan('================================================================\n'));
+  console.log(chalk.bold(`${t('helpUsage')}`));
+  console.log('  cryptoseed [arguments]\n');
+  console.log(chalk.bold(`${t('helpArguments')}`));
+  console.log(chalk.green('  -h, --help') + `         ${t('helpOptHelp')}`);
+  console.log(chalk.green('  -i, --info') + `         ${t('helpOptInfo')}`);
+  console.log(chalk.green('  -c, --create') + `       ${t('helpCommandCreate')}\n`);
+  console.log(chalk.bold(`${t('helpWizard')}`));
+  console.log(`  ${t('helpWizardDesc')}\n`);
+  console.log(chalk.bold(`Developed under b2 wallet ecosystem (${link('better2better', 'https://better2better.net')}, ${link('diegooris', 'https://diegohorantunes.web.app/')}).\n`));
+}
+
+function printInfo() {
+  console.clear();
+  console.log(chalk.cyan('================================================================'));
+  console.log(chalk.cyan(`   🛡️  CryptoSeedRecovery - ${t('infoTitle')}`));
+  console.log(chalk.cyan('================================================================\n'));
+  
+  console.log(chalk.yellow.bold(t('infoTimelines')));
+  console.log('----------------------------------------------------------------');
+  console.log(chalk.cyan(t('infoEra1')));
+  console.log(`  ${t('infoEra1Desc')}`);
+  console.log(chalk.cyan(t('infoEra2')));
+  console.log(`  ${t('infoEra2Desc')}`);
+  console.log(chalk.cyan(t('infoEra3')));
+  console.log(`  ${t('infoEra3Desc')}`);
+  console.log(chalk.cyan(t('infoEra4')));
+  console.log(`  ${t('infoEra4Desc')}\n`);
+
+  console.log(chalk.yellow.bold(t('infoSupported')));
+  console.log('----------------------------------------------------------------');
+  console.log(t('infoBTC'));
+  console.log(t('infoEVM'));
+  console.log(t('infoWaves'));
+  console.log(t('infoSol'));
+  console.log(t('infoOthers') + '\n');
+
+  console.log(chalk.yellow.bold(t('infoFeatured')));
+  console.log('----------------------------------------------------------------');
+  console.log(t('infoB2Wallet'));
+  console.log(t('infoMeta'));
+  console.log(t('infoHardware') + '\n');
+  console.log(chalk.cyan('================================================================'));
+}
+
+async function runCreateSeedWizard() {
+  console.clear();
+  console.log(chalk.cyan('================================================================'));
+  console.log(chalk.cyan(`   🛡️  CryptoSeedRecovery - ${t('createSeedTitle')}`));
+  console.log(chalk.cyan('================================================================\n'));
+
+  let step = 'format';
+  const history = [];
+
+  let format = '';
+  let coin = 'BTC';
+  let wallet = 'b2wallet';
+  let pattern = null;
+  let wordCount = 12;
+  let language = 'en';
+
+  const blockchainChoices = [
+    { name: 'Ethereum / EVMs (ETH, BNB, Polygon, Arbitrum, Optimism, Avalanche, Base, Fantom, Cronos, Harmony)', value: 'ETH' },
+    { name: 'Bitcoin (BTC)', value: 'BTC' },
+    { name: 'Litecoin (LTC)', value: 'LTC' },
+    { name: 'Dogecoin (DOGE)', value: 'DOGE' },
+    { name: 'Solana (SOL)', value: 'SOL' },
+    { name: 'TRON (TRX)', value: 'TRX' },
+    { name: 'Cardano (ADA)', value: 'ADA' },
+    { name: 'Ripple (XRP)', value: 'XRP' },
+    { name: 'Polkadot (DOT)', value: 'DOT' },
+    { name: 'Kusama (KSM)', value: 'KSM' },
+    { name: 'Cosmos (ATOM)', value: 'ATOM' },
+    { name: 'Osmosis (OSMO)', value: 'OSMO' },
+    { name: 'Waves (WAVES)', value: 'WAVES' },
+    { name: 'Kaspa (KAS)', value: 'KAS' },
+    { name: 'Stellar (XLM)', value: 'XLM' },
+    { name: 'Zcash (ZEC)', value: 'ZEC' },
+    { name: 'Bitcoin Cash (BCH)', value: 'BCH' },
+    { name: 'Monero (XMR)', value: 'XMR' },
+    { name: 'Dash (DASH)', value: 'DASH' },
+    { name: 'Secret Network (SCRT)', value: 'SCRT' },
+    { name: 'Injective (INJ)', value: 'INJ' },
+    { name: 'Hedera (HBAR)', value: 'HBAR' },
+    { name: 'NEM (XEM)', value: 'XEM' },
+    { name: 'Chia (XCH)', value: 'XCH' },
+    { name: 'Gnosis Chain (GNOSIS)', value: 'GNOSIS' },
+    { name: 'Tezos (XTZ)', value: 'XTZ' },
+    { name: 'Algorand (ALGO)', value: 'ALGO' },
+    { name: 'Near (NEAR)', value: 'NEAR' },
+    { name: 'Sui (SUI)', value: 'SUI' },
+    { name: 'Aptos (APT)', value: 'APT' },
+    { name: chalk.yellow(t('backChoice')), value: '__back__' }
+  ];
+
+  while (step !== 'execute') {
+    switch (step) {
+      case 'format': {
+        const formatAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'format',
+          message: t('chooseFormat'),
+          choices: [
+            { name: t('formatBip39'), value: 'bip39' },
+            { name: t('formatElectrum'), value: 'electrum' },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+        if (formatAnswers.format === '__back__') {
+          return '__back_to_lang__';
+        }
+        format = formatAnswers.format;
+        history.push('format');
+        step = 'coin';
+        break;
+      }
+
+      case 'coin': {
+        const blockchainAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'coin',
+          message: t('chooseBlockchain'),
+          choices: blockchainChoices
+        }]);
+
+        if (blockchainAnswers.coin === '__back__') {
+          step = history.pop() || 'format';
+        } else {
+          coin = blockchainAnswers.coin;
+          history.push('coin');
+          step = 'wallet';
+        }
+        break;
+      }
+
+      case 'wallet': {
+        let walletChoices = [];
+        if (coin === 'ETH' || coin === 'GNOSIS') {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: t('walletMeta'), value: 'metamask' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: `Ledger (${t('walletLedger')} m/44'/60'/0'/0)`, value: 'ledger' },
+            { name: `Trezor (${t('walletTrezor')} m/44'/60'/0'/0)`, value: 'trezor' }
+          ];
+        } else if (coin === 'BTC') {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: 'Electrum', value: 'electrum' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: t('walletLedger'), value: 'ledger' },
+            { name: t('walletTrezor'), value: 'trezor' }
+          ];
+        } else if (coin === 'SOL') {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: t('walletPhantom'), value: 'phantom' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: t('walletLedger'), value: 'ledger' }
+          ];
+        } else if (coin === 'ADA') {
+          walletChoices = [
+            { name: t('walletYoroi'), value: 'yoroi' },
+            { name: 'Daedalus Wallet', value: 'daedalus' },
+            { name: t('walletLedger'), value: 'ledger' }
+          ];
+        } else {
+          walletChoices = [
+            { name: t('walletB2'), value: 'b2wallet' },
+            { name: t('walletTrust'), value: 'trust' },
+            { name: t('walletLedger'), value: 'ledger' },
+            { name: t('walletTrezor'), value: 'trezor' }
+          ];
+        }
+        walletChoices.push({ name: chalk.yellow(t('backChoice')), value: '__back__' });
+
+        const walletAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'wallet',
+          message: t('chooseWallet'),
+          choices: walletChoices
+        }]);
+
+        if (walletAnswers.wallet === '__back__') {
+          step = history.pop() || 'coin';
+        } else {
+          wallet = walletAnswers.wallet;
+          history.push('wallet');
+          if (wallet !== 'b2wallet' && (coin === 'BTC' || coin === 'LTC' || coin === 'SOL' || coin === 'ADA')) {
+            step = 'pattern';
+          } else {
+            pattern = null;
+            step = (format === 'bip39') ? 'wordCount' : 'language';
+          }
+        }
+        break;
+      }
+
+      case 'pattern': {
+        let patternChoices = [];
+        if (coin === 'BTC') {
+          patternChoices = [
+            { name: t('btcSegwit'), value: 'segwit' },
+            { name: t('btcNested'), value: 'nested' },
+            { name: t('btcLegacy'), value: 'legacy' },
+            { name: t('btcTaproot'), value: 'taproot' }
+          ];
+        } else if (coin === 'LTC') {
+          patternChoices = [
+            { name: t('ltcSegwit'), value: 'segwit' },
+            { name: t('ltcLegacy'), value: 'legacy' }
+          ];
+        } else if (coin === 'SOL') {
+          patternChoices = [
+            { name: t('solPhantom'), value: 'phantom' },
+            { name: t('solSollet'), value: 'sollet' }
+          ];
+        } else if (coin === 'ADA') {
+          patternChoices = [
+            { name: t('adaShelley'), value: 'shelley' },
+            { name: t('adaByron'), value: 'byron' }
+          ];
+        }
+        patternChoices.push({ name: chalk.yellow(t('backChoice')), value: '__back__' });
+
+        const patternAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'pattern',
+          message: coin === 'BTC' ? t('choosePatternBTC') : (coin === 'LTC' ? t('choosePatternLTC') : (coin === 'SOL' ? t('choosePatternSOL') : t('choosePatternADA'))),
+          choices: patternChoices
+        }]);
+
+        if (patternAnswers.pattern === '__back__') {
+          step = history.pop() || 'wallet';
+        } else {
+          pattern = patternAnswers.pattern;
+          history.push('pattern');
+          step = (format === 'bip39') ? 'wordCount' : 'language';
+        }
+        break;
+      }
+
+      case 'wordCount': {
+        const wordCountAnswers = await inquirer.prompt([{
+          type: 'select',
+          name: 'wordCount',
+          message: t('chooseWordCount'),
+          choices: [
+            { name: '12 Words / Palavras', value: 12 },
+            { name: '24 Words / Palavras', value: 24 },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+
+        if (wordCountAnswers.wordCount === '__back__') {
+          step = history.pop() || 'wallet';
+        } else {
+          wordCount = wordCountAnswers.wordCount;
+          history.push('wordCount');
+          step = 'language';
+        }
+        break;
+      }
+
+      case 'language': {
+        if (format === 'bip39') {
+          let langChoices = [
+            { name: 'Inglês (English)', value: 'en' },
+            { name: 'Português (Portuguese)', value: 'pt' },
+            { name: 'Espanhol (Spanish)', value: 'es' },
+            { name: 'Francês (French)', value: 'fr' },
+            { name: 'Italiano (Italian)', value: 'it' },
+            { name: 'Tcheco (Czech)', value: 'cz' },
+            { name: 'Japonês (Japanese)', value: 'ja' },
+            { name: 'Coreano (Korean)', value: 'ko' },
+            { name: 'Chinês Simplificado (Simplified Chinese)', value: 'zh_cn' },
+            { name: 'Chinês Tradicional (Traditional Chinese)', value: 'zh_tw' }
+          ];
+          let langMessage = t('chooseLang');
+
+          if (coin === 'ALGO') {
+            langChoices = [{ name: `Inglês (English) - [${t('algoLangOnly')}]`, value: 'en' }];
+            langMessage = `${chalk.yellow(t('algoLangOnly'))}\n  ${t('chooseLang')}`;
+          } else if (coin === 'ADA' && pattern === 'byron') {
+            langChoices = [{ name: `Inglês (English) - [${t('adaByronLangOnly')}]`, value: 'en' }];
+            langMessage = `${chalk.yellow(t('adaByronLangOnly'))}\n  ${t('chooseLang')}`;
+          }
+
+          langChoices.push({ name: chalk.yellow(t('backChoice')), value: '__back__' });
+
+          const langAnswers = await inquirer.prompt([{
+            type: 'select',
+            name: 'lang',
+            message: langMessage,
+            choices: langChoices
+          }]);
+
+          if (langAnswers.lang === '__back__') {
+            step = history.pop() || 'wordCount';
+          } else {
+            language = langAnswers.lang;
+            step = 'execute';
+          }
+        } else {
+          let langChoices = [
+            { name: `Inglês (English) - [${t('electrumLangOnly')}]`, value: 'en' },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ];
+
+          const langAnswers = await inquirer.prompt([{
+            type: 'select',
+            name: 'lang',
+            message: `${chalk.yellow(t('electrumLangOnly'))}\n  ${t('chooseLang')}`,
+            choices: langChoices
+          }]);
+
+          if (langAnswers.lang === '__back__') {
+            step = history.pop() || 'wallet';
+          } else {
+            language = 'en';
+            step = 'execute';
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  // 6. Generate Mnemonic Phrase securely
+  console.log('\n' + chalk.cyan(t('generatingSeed')));
+  const crypto = require('crypto');
+  let generatedPhrase = '';
+
+  if (format === 'bip39') {
+    const entropyBytes = wordCount === 12 ? 16 : 32;
+    const entropy = crypto.randomBytes(entropyBytes);
+    const wlName = language === 'en' ? 'en' : language;
+    const wl = ethers.wordlists[wlName] || ethers.wordlists[wlName.replace('-', '_')];
+    generatedPhrase = ethers.Mnemonic.entropyToPhrase(entropy, wl);
+  } else {
+    const entropy = crypto.randomBytes(16);
+    const hex = entropy.toString('hex');
+    const { mnEncode } = require('../lib/electrum-legacy');
+    generatedPhrase = mnEncode(hex).join(' ');
+  }
+
+  // 7. Derive Address
+  console.log(chalk.cyan(t('derivingAddress')));
+  let derivedAddr = '';
+  try {
+    derivedAddr = deriveAddress(generatedPhrase, wallet, coin, 0, pattern, language);
+  } catch (err) {
+    console.log(chalk.red(`Error deriving address: ${err.message}`));
+  }
+
+  // 8. Output results beautifully
+  console.log('\n' + chalk.green.bold('================================================================'));
+  console.log(chalk.green.bold(`🎉 ${t('generatedSeedHeader')}`));
+  console.log(chalk.green.bold('================================================================'));
+  console.log(chalk.yellow.bold(`\n  ${generatedPhrase}\n`));
+  console.log(chalk.green.bold('----------------------------------------------------------------'));
+  console.log(chalk.white(`${t('derivedAddressResult')} `) + chalk.cyan.bold(derivedAddr));
+  
+  // Reconstruct path for info
+  let derivationPath = `m/44'/60'/0'/0/0`;
+  if (wallet === 'b2wallet') {
+    derivationPath = `B2 Wallet Custom Multichain PBKDF2/XOR`;
+  } else {
+    if (coin === 'BTC') {
+      if (pattern === 'legacy') derivationPath = `m/44'/0'/0'/0/0`;
+      else if (pattern === 'nested') derivationPath = `m/49'/0'/0'/0/0`;
+      else if (pattern === 'taproot') derivationPath = `m/86'/0'/0'/0/0`;
+      else derivationPath = `m/84'/0'/0'/0/0`;
+    } else if (coin === 'LTC') {
+      if (pattern === 'legacy') derivationPath = `m/44'/2'/0'/0/0`;
+      else derivationPath = `m/84'/2'/0'/0/0`;
+    } else if (coin === 'SOL') {
+      if (pattern === 'sollet') derivationPath = `m/44'/501'/0'/0/0`;
+      else derivationPath = `m/44'/501'/0'/0'`;
+    } else if (coin === 'ADA') {
+      if (pattern === 'byron') derivationPath = `m/44'/1815'/0'/0/0`;
+      else derivationPath = `m/1852'/1815'/0'/0/0`;
+    } else if (coin === 'ETH') {
+      derivationPath = `m/44'/60'/0'/0/0`;
+    } else if (coin === 'ALGO') {
+      derivationPath = `m/44'/283'/0'/0'/0'`;
+    }
+  }
+  console.log(chalk.white(`${t('derivationPathLabel')} `) + chalk.gray(derivationPath));
+  console.log(chalk.green.bold('================================================================\n'));
+  
+  // Escreve o relatório TXT físico de semente gerada
+  const reportLines = [
+    '===========================================================',
+    t('generatedSeedReportHeader'),
+    '===========================================================',
+    t('reportDateTime', new Date().toLocaleString()),
+    t('reportWallet', wallet.toUpperCase()),
+    t('reportBlockchain', coin),
+    t('reportDerivation', pattern ? pattern.toUpperCase() : 'STANDARD/PADRÃO'),
+    '-----------------------------------------------------------',
+    'SEED PHRASE / FRASE DA SEMENTE:',
+    `  ${generatedPhrase}`,
+    '-----------------------------------------------------------',
+    `${t('derivedAddressResult')} ${derivedAddr}`,
+    `${t('derivationPathLabel')} ${derivationPath}`,
+    '===========================================================',
+    t('reportFooterSafe'),
+    t('reportFooterDev')
+  ];
+
+  const reportFilename = `semente_gerada_${Date.now()}.txt`;
+  const reportPath = path.join(process.cwd(), reportFilename);
+  fs.writeFileSync(reportPath, reportLines.join('\n'), 'utf8');
+
+  console.log(chalk.cyan(t('seedGeneratedFileSaved', reportPath)) + '\n');
+  console.log(chalk.red.bold(`⚠️  ${t('reportFooterSafe')}\n`));
+}
+
+if (require.main === module) {
+  (async () => {
+    while (true) {
+      // 1. ESCOLHA DO IDIOMA DA INTERFACE DO USUÁRIO (Sempre o primeiro passo)
+      console.clear();
+      console.log(chalk.cyan('================================================================'));
+      console.log(chalk.cyan('   🛡️  CryptoSeedRecovery - Select Interface Language'));
+      console.log(chalk.cyan('================================================================\n'));
+
+      const uiLangAnswers = await inquirer.prompt([{
+        type: 'select',
+        name: 'uiLang',
+        message: 'Choose your interface language / Selecione o idioma da interface:',
+        choices: [
+          { name: 'English (en)', value: 'en' },
+          { name: 'Português (pt)', value: 'pt' },
+          { name: 'Español (es)', value: 'es' },
+          { name: '简体中文 (zh)', value: 'zh' },
+          { name: '日本語 (ja)', value: 'ja' }
+        ]
+      }]);
+
+      currentLocale = uiLangAnswers.uiLang;
+
+      const args = process.argv.slice(2);
+      if (args.includes('--help') || args.includes('-h')) {
+        printHelp();
+        break;
+      } else if (args.includes('--info') || args.includes('-i')) {
+        printInfo();
+        break;
+      } else if (args.includes('--create') || args.includes('-c')) {
+        const res = await runCreateSeedWizard();
+        if (res === '__back_to_lang__') {
+          continue;
+        }
+        break;
+      } else {
+        // Exibe o menu principal interativo para escolha da ação
+        console.clear();
+        printHeader();
+        const actionAnswer = await inquirer.prompt([{
+          type: 'select',
+          name: 'action',
+          message: t('menuChooseAction'),
+          choices: [
+            { name: t('actionRecover'), value: 'recover' },
+            { name: t('actionCreate'), value: 'create' },
+            { name: chalk.yellow(t('backChoice')), value: '__back__' }
+          ]
+        }]);
+
+        if (actionAnswer.action === '__back__') {
+          continue;
+        }
+
+        if (actionAnswer.action === 'create') {
+          const res = await runCreateSeedWizard();
+          if (res === '__back_to_lang__') {
+            continue;
+          }
+          break;
+        } else {
+          const res = await main();
+          if (res === '__back_to_lang__') {
+            continue;
+          }
+          break;
+        }
+      }
+    }
+  })().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}