codecrypto-cli 1.0.13 → 1.0.15

package/src/commands/generate-keys.ts

@@ -0,0 +1,139 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { ethers } from 'ethers';
+
+interface Account {
+  address: string;
+  private_key: string;
+}
+
+interface KeysFile {
+  mnemonic: string;
+  accounts: Account[];
+}
+
+export const generateKeysCommand = new Command('generate-keys')
+  .description('Generate Foundry keys file with mnemonic and derived accounts')
+  .option('-m, --mnemonic <mnemonic>', 'Mnemonic phrase (if not provided, a random one will be generated)')
+  .option('-n, --count <number>', 'Number of accounts to generate', '10')
+  .option('-o, --output <path>', 'Output file path', '~/.foundry/keys.json')
+  .action(async (options) => {
+    console.log(chalk.blue('\n🔑 CodeCrypto Foundry Keys Generator\n'));
+
+    try {
+      // Parse count
+      const accountCount = parseInt(options.count, 10);
+      if (isNaN(accountCount) || accountCount < 1 || accountCount > 100) {
+        console.error(chalk.red('❌ Error: Account count must be between 1 and 100'));
+        process.exit(1);
+      }
+
+      // Generate or use provided mnemonic
+      let mnemonic: string;
+      if (options.mnemonic) {
+        mnemonic = options.mnemonic.trim();
+        // Validate mnemonic
+        if (!ethers.Mnemonic.isValidMnemonic(mnemonic)) {
+          console.error(chalk.red('❌ Error: Invalid mnemonic phrase'));
+          process.exit(1);
+        }
+      } else {
+        // Generate random mnemonic
+        const spinner = ora('Generating random mnemonic...').start();
+        mnemonic = ethers.Mnemonic.entropyToPhrase(ethers.randomBytes(16));
+        spinner.succeed('Random mnemonic generated');
+      }
+
+      // Derive accounts
+      const accountsSpinner = ora(`Deriving ${accountCount} account(s) from mnemonic...`).start();
+      const accounts: Account[] = [];
+
+      try {
+        for (let i = 0; i < accountCount; i++) {
+          // Use HDNodeWallet.fromPhrase with the full derivation path
+          // This creates a wallet directly from mnemonic at the specified path
+          const wallet = ethers.HDNodeWallet.fromPhrase(mnemonic, `m/44'/60'/0'/0/${i}`);
+          accounts.push({
+            address: wallet.address,
+            private_key: wallet.privateKey,
+          });
+        }
+
+        accountsSpinner.succeed(`Generated ${accountCount} account(s)`);
+      } catch (error: any) {
+        accountsSpinner.fail('Failed to derive accounts');
+        console.error(chalk.red(`❌ Error: ${error.message}`));
+        process.exit(1);
+      }
+
+      // Prepare output data
+      const keysData: KeysFile = {
+        mnemonic,
+        accounts,
+      };
+
+      // Resolve output path
+      let outputPath = options.output;
+      if (outputPath.startsWith('~')) {
+        outputPath = path.join(os.homedir(), outputPath.slice(1));
+      }
+      outputPath = path.resolve(outputPath);
+
+      // Create directory if it doesn't exist
+      const outputDir = path.dirname(outputPath);
+      if (!fs.existsSync(outputDir)) {
+        const dirSpinner = ora(`Creating directory: ${outputDir}`).start();
+        try {
+          fs.mkdirSync(outputDir, { recursive: true });
+          dirSpinner.succeed(`Directory created: ${outputDir}`);
+        } catch (error: any) {
+          dirSpinner.fail('Failed to create directory');
+          console.error(chalk.red(`❌ Error: ${error.message}`));
+          process.exit(1);
+        }
+      }
+
+      // Write file
+      const writeSpinner = ora(`Writing keys to ${outputPath}...`).start();
+      try {
+        fs.writeFileSync(outputPath, JSON.stringify(keysData, null, 2), 'utf-8');
+        writeSpinner.succeed(`Keys saved to ${outputPath}`);
+      } catch (error: any) {
+        writeSpinner.fail('Failed to write file');
+        console.error(chalk.red(`❌ Error: ${error.message}`));
+        process.exit(1);
+      }
+
+      // Display summary
+      console.log(chalk.green('\n✅ Keys generated successfully!\n'));
+      console.log(chalk.gray('Summary:'));
+      console.log(chalk.white(`  Mnemonic: ${chalk.cyan(mnemonic)}`));
+      console.log(chalk.white(`  Accounts: ${chalk.cyan(accountCount)}`));
+      console.log(chalk.white(`  Output: ${chalk.cyan(outputPath)}\n`));
+
+      // Display first few accounts
+      console.log(chalk.gray('First 3 accounts:'));
+      accounts.slice(0, 3).forEach((account, index) => {
+        console.log(chalk.white(`  ${index + 1}. ${chalk.cyan(account.address)}`));
+        console.log(chalk.gray(`     Private Key: ${chalk.dim(account.private_key)}`));
+      });
+
+      if (accountCount > 3) {
+        console.log(chalk.gray(`  ... and ${accountCount - 3} more account(s)\n`));
+      } else {
+        console.log('');
+      }
+
+      console.log(chalk.yellow('⚠️  Warning: Keep your mnemonic and private keys secure!'));
+      console.log(chalk.yellow('   Never share them or commit them to version control.\n'));
+
+    } catch (error: any) {
+      console.error(chalk.red(`\n❌ Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+

package/src/index.ts

@@ -8,6 +8,7 @@ import { deployCommand } from './commands/deploy';
 import { deployScCommand } from './commands/deploy-sc';
 import { authCommand } from './commands/auth';
 import { doctorCommand } from './commands/doctor';
+import { generateKeysCommand } from './commands/generate-keys';
 
 // Cargar variables de entorno desde ~/.codecrypto/.env si existe
 function loadEnvFile() {
@@ -55,5 +56,6 @@ program.addCommand(deployCommand);
 program.addCommand(deployScCommand);
 program.addCommand(authCommand);
 program.addCommand(doctorCommand);
+program.addCommand(generateKeysCommand);
 
 program.parse(process.argv);