forgex-cli 1.0.59 → 1.0.61

package/dist/src/commands/wallet/index.js

@@ -1,5 +1,5 @@
 /**
- * 钱包组管理命令组
+ * Wallet group management command group
  *
  * forgex wallet create-group | list-groups | group-info | delete-group |
  *                  generate | add | remove | import | export |
@@ -15,48 +15,48 @@ import { output, success, error, warn, getOutputFormat } from '../../output.js';
 export function registerWalletCommands(program) {
     const walletCmd = program
         .command('wallet')
-        .description('钱包组管理');
+        .description('Wallet group management');
     // ============================================================
     // forgex wallet create-group
     // ============================================================
     walletCmd
         .command('create-group')
-        .description('创建钱包组')
-        .requiredOption('--name <name>', '钱包组名称')
-        .option('--type <type>', '类型: local | monitor', 'local')
-        .option('--remark <remark>', '备注', '')
-        .option('--monitor-type <type>', '监控类型: normal | top100 | retail', 'normal')
-        .option('--monitor-ca <ca>', '监控代币 CA')
-        .option('--filter-group-ids <ids>', '过滤钱包组 ID（逗号分隔）')
+        .description('Create wallet group')
+        .requiredOption('--name <name>', 'Wallet group name')
+        .option('--type <type>', 'Type: local | monitor', 'local')
+        .option('--remark <remark>', 'Remark', '')
+        .option('--monitor-type <type>', 'Monitor type: normal | top100 | retail', 'normal')
+        .option('--monitor-ca <ca>', 'Monitor token CA')
+        .option('--filter-group-ids <ids>', 'Filter wallet group IDs (comma-separated)')
         .action(async (options) => {
         try {
-            // 验证 --type 参数
+            // Validate --type parameter
             if (options.type !== 'local' && options.type !== 'monitor') {
-                error(`无效的类型 "${options.type}"，只支持 local 或 monitor`);
+                error(`Invalid type "${options.type}", only local or monitor supported`);
                 process.exit(1);
             }
             const groupType = options.type;
-            // 验证 --monitor-type 参数
+            // Validate --monitor-type parameter
             const validMonitorTypes = ['normal', 'top100', 'retail'];
             if (!validMonitorTypes.includes(options.monitorType)) {
-                error(`无效的监控类型 "${options.monitorType}"，只支持 normal、top100 或 retail`);
+                error(`Invalid monitor type "${options.monitorType}", only normal, top100 or retail supported`);
                 process.exit(1);
             }
             const monitorType = options.monitorType;
             const filterGroupIds = options.filterGroupIds
                 ? options.filterGroupIds.split(',')
                 : [];
-            // 验证 filterGroupIds 中的值是否为有效数字
+            // Validate filterGroupIds values are valid numbers
             const filterGroupIdsNum = filterGroupIds.map(Number);
             if (filterGroupIdsNum.some(isNaN)) {
-                error('--filter-group-ids 包含无效的 ID，请使用逗号分隔的数字');
+                error('--filter-group-ids contains invalid IDs, use comma-separated numbers');
                 process.exit(1);
             }
-            // 纯本地操作: 生成本地 group ID
+            // Local-only: generate local group ID
             const existingGroups = getAllGroups();
             const maxId = existingGroups.reduce((max, g) => Math.max(max, g.groupId), 0);
             const groupId = maxId + 1;
-            // 本地存储
+            // Local storage
             const newGroup = {
                 name: options.name,
                 groupId,
@@ -76,7 +76,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('创建钱包组失败', e.message);
+            error('Failed to create wallet group', e.message);
             process.exit(1);
         }
     });
@@ -85,13 +85,13 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('list-groups')
-        .description('列出所有钱包组')
-        .option('--type <type>', '按类型过滤: local | monitor')
+        .description('List all wallet groups')
+        .option('--type <type>', 'Filter by type: local | monitor')
         .action((options) => {
         try {
-            // 验证 --type 参数
+            // Validate --type parameter
             if (options.type && options.type !== 'local' && options.type !== 'monitor') {
-                error(`无效的类型 "${options.type}"，只支持 local 或 monitor`);
+                error(`Invalid type "${options.type}", only local or monitor supported`);
                 process.exit(1);
             }
             let groups = getAllGroups();
@@ -99,8 +99,8 @@ export function registerWalletCommands(program) {
                 groups = groups.filter(g => g.groupType === options.type);
             }
             if (groups.length === 0) {
-                const filterMsg = options.type ? `（类型: ${options.type}）` : '';
-                warn(`没有找到钱包组${filterMsg}`);
+                const filterMsg = options.type ? `(type: ${options.type})` : '';
+                warn(`No wallet groups found${filterMsg}`);
             }
             const result = groups.map(g => ({
                 groupId: g.groupId,
@@ -113,16 +113,16 @@ export function registerWalletCommands(program) {
             output(result, {
                 columns: [
                     { key: 'groupId', header: 'ID' },
-                    { key: 'name', header: '名称' },
-                    { key: 'type', header: '类型' },
-                    { key: 'walletCount', header: '钱包数' },
-                    { key: 'monitorType', header: '监控类型' },
-                    { key: 'note', header: '备注' },
+                    { key: 'name', header: 'Name' },
+                    { key: 'type', header: 'Type' },
+                    { key: 'walletCount', header: 'Wallet Count' },
+                    { key: 'monitorType', header: 'Monitor Type' },
+                    { key: 'note', header: 'Note' },
                 ],
             });
         }
         catch (e) {
-            error('获取钱包组列表失败', e.message);
+            error('Failed to list wallet groups', e.message);
             process.exit(1);
         }
     });
@@ -131,24 +131,24 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('group-info')
-        .description('查看钱包组详情')
-        .requiredOption('--id <groupId>', '钱包组 ID')
-        .option('--show-keys', '显示私钥（危险操作）', false)
+        .description('View wallet group details')
+        .requiredOption('--id <groupId>', 'Wallet group ID')
+        .option('--show-keys', 'Show private keys (dangerous)', false)
         .action(async (options) => {
         try {
             const groupId = Number(options.id);
             if (isNaN(groupId)) {
-                error(`无效的钱包组 ID "${options.id}"，请提供数字 ID`);
+                error(`Invalid wallet group ID "${options.id}", provide a numeric ID`);
                 process.exit(1);
             }
-            // 如果需要显示私钥，先确保密码已设置且正确
+            // If showing private keys, ensure password is set and correct first
             if (options.showKeys) {
-                warn('警告：即将显示私钥明文，请确保当前环境安全，切勿在公共场所或共享屏幕时使用此命令');
+                warn('Warning: About to display plaintext private keys. Ensure a secure environment. Never use this command in public or screen-sharing sessions');
                 await ensurePasswordAndValidate();
             }
             const group = getGroup(groupId);
             if (!group) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
             const walletsList = group.wallets.map(w => {
@@ -173,7 +173,7 @@ export function registerWalletCommands(program) {
             output(result);
         }
         catch (e) {
-            error('获取钱包组详情失败', e.message);
+            error('Failed to get wallet group details', e.message);
             process.exit(1);
         }
     });
@@ -182,40 +182,40 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('delete-group')
-        .description('删除钱包组')
-        .requiredOption('--id <groupId>', '钱包组 ID')
-        .option('--force', '跳过确认', false)
+        .description('Delete wallet group')
+        .requiredOption('--id <groupId>', 'Wallet group ID')
+        .option('--force', 'Skip confirmation', false)
         .action(async (options) => {
         try {
             const groupId = Number(options.id);
             if (isNaN(groupId)) {
-                error(`无效的钱包组 ID "${options.id}"，请提供数字 ID`);
+                error(`Invalid wallet group ID "${options.id}", provide a numeric ID`);
                 process.exit(1);
             }
-            // 检查本地是否存在该钱包组
+            // Check if wallet group exists locally
             const group = getGroup(groupId);
             if (!group) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
-            // 非 --force 模式下，提示用户确认
+            // In non --force mode, prompt user for confirmation
             if (!options.force) {
                 const { confirm } = await import('@inquirer/prompts');
                 const confirmed = await confirm({
-                    message: `确认删除钱包组 "${group.name}" (ID: ${groupId}, ${group.wallets.length} 个钱包)？此操作不可恢复。`,
+                    message: `Confirm delete wallet group "${group.name}" (ID: ${groupId}, ${group.wallets.length} wallets)? This action is irreversible.`,
                     default: false,
                 });
                 if (!confirmed) {
-                    warn('已取消删除操作');
+                    warn('Delete operation cancelled');
                     return;
                 }
             }
-            // 纯本地删除
+            // Pure local deletion
             removeGroup(groupId);
-            output({ success: true, groupId, message: '钱包组已删除' });
+            output({ success: true, groupId, message: 'Wallet group deleted' });
         }
         catch (e) {
-            error('删除钱包组失败', e.message);
+            error('Failed to delete wallet group', e.message);
             process.exit(1);
         }
     });
@@ -224,40 +224,40 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('generate')
-        .description('生成新钱包')
-        .requiredOption('--group <groupId>', '目标钱包组 ID')
-        .option('--count <n>', '生成数量', '1')
+        .description('Generate new wallets')
+        .requiredOption('--group <groupId>', 'Target wallet group ID')
+        .option('--count <n>', 'Count to generate', '1')
         .action(async (options) => {
         try {
             await ensurePasswordAndValidate();
             const groupId = Number(options.group);
             if (isNaN(groupId)) {
-                error(`无效的钱包组 ID "${options.group}"，请提供数字 ID`);
+                error(`Invalid wallet group ID "${options.group}", provide a numeric ID`);
                 process.exit(1);
             }
             const count = Number(options.count);
             if (isNaN(count) || !Number.isInteger(count) || count <= 0) {
-                error(`无效的生成数量 "${options.count}"，请提供正整数`);
+                error(`Invalid count "${options.count}", provide a positive integer`);
                 process.exit(1);
             }
             const group = getGroup(groupId);
             if (!group) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
             if (group.wallets.length + count > 100) {
-                error(`钱包数量超限：当前 ${group.wallets.length} 个，最多再生成 ${100 - group.wallets.length} 个（上限 100）`);
+                error(`Wallet count exceeded: currently ${group.wallets.length}, max ${100 - group.wallets.length} more (limit 100)`);
                 process.exit(1);
             }
             const wallets = generateWallets(count);
-            // 保存明文私钥用于输出（addWalletsToGroup 可能会加密 wallets 中的 privateKey）
+            // Save plaintext private keys for output (addWalletsToGroup may encrypt privateKey in wallets)
             const plaintextKeys = wallets.map(w => ({
                 address: w.walletAddress,
                 privateKey: w.privateKey,
             }));
-            // 纯本地存储（如果存储已加密，此函数会加密 wallets 的 privateKey 字段）
+            // Pure local storage (if store is encrypted, this function encrypts privateKey fields)
             addWalletsToGroup(groupId, wallets);
-            // Bug 1 fix: JSON 保持原结构; table/minimal 用 columns 展示生成的钱包列表
+            // Bug 1 fix: JSON keeps original structure; table/minimal use columns to display generated wallet list
             const fmt = getOutputFormat();
             if (fmt === 'json') {
                 output({
@@ -267,7 +267,7 @@ export function registerWalletCommands(program) {
                 });
             }
             else {
-                success(`已生成 ${plaintextKeys.length} 个钱包到组 ${groupId}`);
+                success(`Generated ${plaintextKeys.length} wallets to group ${groupId}`);
                 output(plaintextKeys.map((w, i) => ({
                     index: i + 1,
                     address: w.address,
@@ -275,14 +275,14 @@ export function registerWalletCommands(program) {
                 })), {
                     columns: [
                         { key: 'index', header: '#' },
-                        { key: 'address', header: '地址' },
-                        { key: 'privateKey', header: '私钥' },
+                        { key: 'address', header: 'Address' },
+                        { key: 'privateKey', header: 'Private Key' },
                     ],
                 });
             }
         }
         catch (e) {
-            error('生成钱包失败', e.message);
+            error('Failed to generate wallets', e.message);
             process.exit(1);
         }
     });
@@ -291,37 +291,37 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('add')
-        .description('添加钱包到钱包组')
-        .requiredOption('--group <groupId>', '目标钱包组 ID')
-        .requiredOption('--private-key <key>', '私钥（Base58 编码）')
-        .option('--note <note>', '备注', '')
+        .description('Add wallet to group')
+        .requiredOption('--group <groupId>', 'Target wallet group ID')
+        .requiredOption('--private-key <key>', 'Private key (Base58 encoded)')
+        .option('--note <note>', 'Note', '')
         .action(async (options) => {
         try {
             await ensurePasswordAndValidate();
             const groupId = Number(options.group);
             if (isNaN(groupId)) {
-                error(`无效的钱包组 ID "${options.group}"，请提供数字 ID`);
+                error(`Invalid wallet group ID "${options.group}", provide a numeric ID`);
                 process.exit(1);
             }
-            // 验证钱包组存在
+            // Verify wallet group exists
             const group = getGroup(groupId);
             if (!group) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
-            // 验证私钥有效性
+            // Validate private key validity
             let wallet;
             try {
                 wallet = walletFromPrivateKey(options.privateKey, options.note);
             }
             catch {
-                error('无效的私钥：请提供有效的 Base58 编码私钥');
+                error('Invalid private key: provide a valid Base58 encoded private key');
                 process.exit(1);
             }
-            // 检查地址是否已存在于该组
+            // Check if address already exists in group
             const exists = group.wallets.some(w => w.walletAddress === wallet.walletAddress);
             if (exists) {
-                warn(`钱包 ${wallet.walletAddress} 已存在于钱包组 ${groupId} 中，跳过重复添加`);
+                warn(`Wallet ${wallet.walletAddress} already exists in group ${groupId}, skipping duplicate`);
                 output({
                     success: true,
                     groupId,
@@ -330,7 +330,7 @@ export function registerWalletCommands(program) {
                 });
                 return;
             }
-            // 纯本地存储
+            // Pure local storage
             addWalletsToGroup(groupId, [wallet]);
             output({
                 success: true,
@@ -339,7 +339,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('添加钱包失败', e.message);
+            error('Failed to add wallet', e.message);
             process.exit(1);
         }
     });
@@ -348,29 +348,29 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('remove')
-        .description('从钱包组移除钱包')
-        .requiredOption('--group <groupId>', '目标钱包组 ID')
-        .requiredOption('--address <addr>', '钱包地址')
+        .description('Remove wallet from group')
+        .requiredOption('--group <groupId>', 'Target wallet group ID')
+        .requiredOption('--address <addr>', 'Wallet address')
         .action(async (options) => {
         try {
             const groupId = Number(options.group);
             if (isNaN(groupId)) {
-                error(`无效的钱包组 ID "${options.group}"，请提供数字 ID`);
+                error(`Invalid wallet group ID "${options.group}", provide a numeric ID`);
                 process.exit(1);
             }
-            // 验证钱包组存在
+            // Verify wallet group exists
             const group = getGroup(groupId);
             if (!group) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
-            // 验证地址是否存在于该钱包组中
+            // Verify address exists in wallet group
             const walletExists = group.wallets.some(w => w.walletAddress === options.address);
             if (!walletExists) {
-                error(`钱包 ${options.address} 不在钱包组 ${groupId} 中`);
+                error(`Wallet ${options.address} is not in wallet group ${groupId}`);
                 process.exit(1);
             }
-            // 纯本地移除
+            // Pure local removal
             removeWalletsFromGroup(groupId, [options.address]);
             output({
                 success: true,
@@ -379,7 +379,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('移除钱包失败', e.message);
+            error('Failed to remove wallet', e.message);
             process.exit(1);
         }
     });
@@ -388,35 +388,35 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('import')
-        .description('从 CSV 文件导入钱包')
-        .requiredOption('--group <groupId>', '目标钱包组 ID')
-        .requiredOption('--file <csvPath>', 'CSV 文件路径')
+        .description('Import wallets from CSV file')
+        .requiredOption('--group <groupId>', 'Target wallet group ID')
+        .requiredOption('--file <csvPath>', 'CSV file path')
         .action(async (options) => {
         try {
             await ensurePasswordAndValidate();
             const groupId = Number(options.group);
             if (isNaN(groupId) || !Number.isInteger(groupId) || groupId <= 0) {
-                error(`无效的钱包组 ID "${options.group}"，请提供正整数`);
+                error(`Invalid wallet group ID "${options.group}", provide a positive integer`);
                 process.exit(1);
             }
-            // 验证钱包组存在
+            // Verify wallet group exists
             const group = getGroup(groupId);
             if (!group) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
-            // 验证文件存在
+            // Verify file exists
             if (!fs.existsSync(options.file)) {
-                error(`CSV 文件不存在: ${options.file}`);
+                error(`CSV file does not exist: ${options.file}`);
                 process.exit(1);
             }
             const csvContent = fs.readFileSync(options.file, 'utf-8');
             const wallets = importWalletsFromCsv(csvContent);
             if (wallets.length === 0) {
-                error('CSV 文件中没有有效的钱包数据');
+                error('No valid wallet data in CSV file');
                 process.exit(1);
             }
-            // 纯本地存储
+            // Pure local storage
             addWalletsToGroup(groupId, wallets);
             output({
                 success: true,
@@ -426,7 +426,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('导入钱包失败', e.message);
+            error('Failed to import wallets', e.message);
             process.exit(1);
         }
     });
@@ -435,20 +435,20 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('export')
-        .description('导出钱包组为 CSV 文件')
-        .requiredOption('--group <groupId>', '钱包组 ID')
-        .requiredOption('--file <csvPath>', '输出文件路径')
+        .description('Export wallet group as CSV file')
+        .requiredOption('--group <groupId>', 'Wallet group ID')
+        .requiredOption('--file <csvPath>', 'Output file path')
         .action(async (options) => {
         try {
             await ensurePasswordAndValidate();
             const groupId = Number(options.group);
             if (isNaN(groupId) || !Number.isInteger(groupId) || groupId <= 0) {
-                error(`无效的钱包组 ID "${options.group}"，请提供正整数`);
+                error(`Invalid wallet group ID "${options.group}", provide a positive integer`);
                 process.exit(1);
             }
             const csv = exportGroupToCsv(groupId);
             if (!csv) {
-                error(`钱包组 ${groupId} 不存在`);
+                error(`Wallet group ${groupId} does not exist`);
                 process.exit(1);
             }
             fs.writeFileSync(options.file, csv, { encoding: 'utf-8', mode: 0o600 });
@@ -459,7 +459,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('导出钱包失败', e.message);
+            error('Failed to export wallets', e.message);
             process.exit(1);
         }
     });
@@ -468,33 +468,33 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('import-group')
-        .description('从 JSON 文件导入钱包组')
-        .requiredOption('--file <jsonPath>', 'JSON 文件路径')
-        .option('--password <pwd>', '解密密码（加密文件需要）')
+        .description('Import wallet groups from JSON file')
+        .requiredOption('--file <jsonPath>', 'JSON file path')
+        .option('--password <pwd>', 'Decryption password (required for encrypted files)')
         .action(async (options) => {
         try {
             await ensurePasswordAndValidate();
-            // 验证文件存在
+            // Verify file exists
             if (!fs.existsSync(options.file)) {
-                error(`JSON 文件不存在: ${options.file}`);
+                error(`JSON file does not exist: ${options.file}`);
                 process.exit(1);
             }
             const content = fs.readFileSync(options.file, 'utf-8');
             const groups = importGroupsFromJson(content, options.password);
             if (!groups || groups.length === 0) {
-                error('JSON 文件中没有有效的钱包组数据（如果是加密文件，请检查 --password 是否正确）');
+                error('No valid wallet group data in JSON file (if encrypted, check --password)');
                 process.exit(1);
             }
-            // 纯本地存储（通过 saveGroup + addWalletsToGroup 确保私钥正确加密）
+            // Pure local storage (ensure private keys are encrypted via saveGroup + addWalletsToGroup)
             const existingGroups = getAllGroups();
             let nextLocalId = existingGroups.reduce((max, g) => Math.max(max, g.groupId), 0) + 1;
             groups.forEach((g) => {
                 const newId = nextLocalId++;
                 const wallets = g.wallets;
                 g.groupId = newId;
-                g.wallets = []; // 先保存空钱包组
+                g.wallets = []; // Save empty wallet group first
                 saveGroup(g);
-                // 通过 addWalletsToGroup 添加钱包，该函数会自动处理加密
+                // Add wallets via addWalletsToGroup, which handles encryption automatically
                 if (wallets.length > 0) {
                     addWalletsToGroup(newId, wallets);
                 }
@@ -506,7 +506,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('导入钱包组失败', e.message);
+            error('Failed to import wallet groups', e.message);
             process.exit(1);
         }
     });
@@ -515,16 +515,16 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('export-group')
-        .description('导出所有钱包组为 JSON 文件')
-        .requiredOption('--file <jsonPath>', '输出文件路径')
-        .option('--encrypt', '加密导出', false)
-        .option('--password <pwd>', '加密密码')
+        .description('Export all wallet groups as JSON file')
+        .requiredOption('--file <jsonPath>', 'Output file path')
+        .option('--encrypt', 'Encrypted export', false)
+        .option('--password <pwd>', 'Encryption password')
         .action(async (options) => {
         try {
             await ensurePasswordAndValidate();
             const groups = getAllGroups();
             if (groups.length === 0) {
-                warn('没有钱包组可导出');
+                warn('No wallet groups to export');
                 output({ success: true, file: options.file, encrypted: options.encrypt, groupCount: 0 });
                 return;
             }
@@ -532,7 +532,7 @@ export function registerWalletCommands(program) {
             if (options.encrypt) {
                 const password = options.password || process.env.FORGEX_PASSWORD;
                 if (!password) {
-                    error('加密导出需要密码，使用 --password 或设置 FORGEX_PASSWORD 环境变量');
+                    error('Encrypted export requires password, use --password or set FORGEX_PASSWORD env var');
                     process.exit(1);
                 }
                 content = exportEncryptedGroupsJson(password);
@@ -549,7 +549,7 @@ export function registerWalletCommands(program) {
             });
         }
         catch (e) {
-            error('导出钱包组失败', e.message);
+            error('Failed to export wallet groups', e.message);
             process.exit(1);
         }
     });
@@ -558,30 +558,30 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('overview')
-        .description('查看钱包组概览')
-        .requiredOption('--groups <ids>', '钱包组 ID（逗号分隔）')
-        .option('--token <ca>', '按代币过滤')
+        .description('View wallet group overview')
+        .requiredOption('--groups <ids>', 'Wallet group IDs (comma-separated)')
+        .option('--token <ca>', 'Filter by token')
         .action(async (options) => {
         try {
             const groupIds = options.groups.split(',').map(Number);
-            // 验证所有 groupId 都是有效正整数
+            // Validate all groupIds are valid positive integers
             if (groupIds.some(id => isNaN(id) || !Number.isInteger(id) || id <= 0)) {
-                error(`无效的钱包组 ID 列表 "${options.groups}"，请提供逗号分隔的正整数`);
+                error(`Invalid wallet group ID list "${options.groups}", provide comma-separated positive integers`);
                 process.exit(1);
             }
-            // 验证本地是否存在这些钱包组
+            // Verify wallet groups exist locally
             const missingIds = groupIds.filter(id => !getGroup(id));
             if (missingIds.length > 0) {
-                warn(`以下钱包组在本地不存在: ${missingIds.join(', ')}`);
+                warn(`The following wallet groups do not exist locally: ${missingIds.join(', ')}`);
             }
             const ds = getDataSource();
-            // 从 DataStore 本地数据构建概览
+            // Build overview from DataStore local data
             const overviewResults = [];
             for (const gid of groupIds) {
                 const group = getGroup(gid);
                 if (!group)
                     continue;
-                // 确定要查询的代币列表
+                // Determine token list to query
                 const tokenCAs = options.token ? [options.token] : ds.listTokens();
                 let totalValueSol = 0;
                 let totalRealizedPnl = 0;
@@ -592,14 +592,14 @@ export function registerWalletCommands(program) {
                     const holdings = ds.getHoldings(ca, gid);
                     if (!holdings || holdings.wallets.length === 0)
                         continue;
-                    // 尝试获取代币价格
+                    // Try to get token price
                     let priceSol = 0;
                     try {
                         const priceData = await ds.getTokenPrice(ca);
                         priceSol = priceData.priceSol;
                     }
                     catch {
-                        // 价格不可用，跳过价值计算
+                        // Price unavailable, skip value calculation
                     }
                     for (const w of holdings.wallets) {
                         const positionValue = w.tokenBalance * priceSol;
@@ -623,22 +623,22 @@ export function registerWalletCommands(program) {
                 });
             }
             if (overviewResults.length === 0) {
-                warn('暂无钱包组概览数据');
+                warn('No wallet group overview data');
             }
             output(overviewResults, {
                 columns: [
                     { key: 'groupId', header: 'ID' },
-                    { key: 'groupName', header: '名称' },
-                    { key: 'totalValue', header: '总价值(SOL)' },
-                    { key: 'pnl', header: '总盈亏(SOL)' },
-                    { key: 'donePnl', header: '已实现' },
-                    { key: 'unDonePnl', header: '未实现' },
-                    { key: 'avgCost', header: '均价' },
+                    { key: 'groupName', header: 'Name' },
+                    { key: 'totalValue', header: 'Total Value(SOL)' },
+                    { key: 'pnl', header: 'Total P&L(SOL)' },
+                    { key: 'donePnl', header: 'Realized' },
+                    { key: 'unDonePnl', header: 'Unrealized' },
+                    { key: 'avgCost', header: 'Avg Cost' },
                 ],
             });
         }
         catch (e) {
-            error('获取钱包组概览失败', e.message);
+            error('Failed to get wallet group overview', e.message);
             process.exit(1);
         }
     });
@@ -647,43 +647,43 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('grind')
-        .description('生成靓号地址（自定义后缀/前缀）')
-        .requiredOption('--suffix <suffix>', '地址后缀（如 pump）')
-        .option('--prefix <prefix>', '地址前缀')
-        .option('--count <n>', '生成数量', '1')
-        .option('--threads <n>', 'grind 线程数')
+        .description('Generate vanity address (custom suffix/prefix)')
+        .requiredOption('--suffix <suffix>', 'Address suffix (e.g. pump)')
+        .option('--prefix <prefix>', 'Address prefix')
+        .option('--count <n>', 'Count to generate', '1')
+        .option('--threads <n>', 'Grind thread count')
         .action(async (options) => {
         try {
-            // 检查 solana-keygen 是否可用
+            // Check if solana-keygen is available
             try {
                 execSync('solana-keygen --version', { stdio: 'ignore' });
             }
             catch {
-                error('未检测到 solana-keygen，请先安装 Solana CLI 工具链', '安装方式: sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)" 或访问 https://docs.solanalabs.com/cli/install');
+                error('solana-keygen not found, please install Solana CLI toolchain first', 'Install: sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)" or visit https://docs.solanalabs.com/cli/install');
                 process.exit(1);
             }
             const count = Number(options.count);
             if (isNaN(count) || !Number.isInteger(count) || count <= 0) {
-                error(`无效的生成数量 "${options.count}"，请提供正整数`);
+                error(`Invalid count "${options.count}", provide a positive integer`);
                 process.exit(1);
             }
             const suffix = options.suffix.trim();
             if (!suffix) {
-                error('--suffix 不能为空');
+                error('--suffix cannot be empty');
                 process.exit(1);
             }
-            // 验证后缀只包含 Base58 字符
+            // Verify suffix contains only Base58 characters
             const base58Chars = /^[1-9A-HJ-NP-Za-km-z]+$/;
             if (!base58Chars.test(suffix)) {
-                error(`无效的后缀 "${suffix}"，只支持 Base58 字符（不含 0, O, I, l）`);
+                error(`Invalid suffix "${suffix}", only Base58 characters supported (no 0, O, I, l)`);
                 process.exit(1);
             }
             if (options.prefix && !base58Chars.test(options.prefix)) {
-                error(`无效的前缀 "${options.prefix}"，只支持 Base58 字符（不含 0, O, I, l）`);
+                error(`Invalid prefix "${options.prefix}", only Base58 characters supported (no 0, O, I, l)`);
                 process.exit(1);
             }
             ensureConfigDir();
-            // 构建 solana-keygen grind 参数
+            // Build solana-keygen grind arguments
             const args = ['grind'];
             if (options.prefix) {
                 args.push('--starts-and-ends-with', `${options.prefix}:${suffix}`);
@@ -694,19 +694,19 @@ export function registerWalletCommands(program) {
             if (options.threads) {
                 const threads = Number(options.threads);
                 if (isNaN(threads) || !Number.isInteger(threads) || threads <= 0) {
-                    error(`无效的线程数 "${options.threads}"，请提供正整数`);
+                    error(`Invalid thread count "${options.threads}", provide a positive integer`);
                     process.exit(1);
                 }
                 args.push('--num-threads', String(threads));
             }
             const fmt = getOutputFormat();
             if (fmt !== 'json') {
-                success(`正在生成 ${count} 个以 "${suffix}" 结尾的靓号地址，请耐心等待...`);
+                success(`Generating ${count} vanity addresses ending with "${suffix}", please wait...`);
                 if (suffix.length >= 5) {
-                    warn('后缀较长，生成时间可能需要数分钟甚至更久');
+                    warn('Long suffix, generation may take minutes or longer');
                 }
             }
-            // 在 VANITY_DIR 下执行 grind，生成的 .json 文件会落在该目录
+            // Execute grind in VANITY_DIR, generated .json files will be in that directory
             const child = spawn('solana-keygen', args, {
                 cwd: VANITY_DIR,
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -719,10 +719,10 @@ export function registerWalletCommands(program) {
                 child.on('close', resolve);
             });
             if (exitCode !== 0) {
-                error('solana-keygen grind 执行失败', stderr || stdout);
+                error('solana-keygen grind execution failed', stderr || stdout);
                 process.exit(1);
             }
-            // 解析生成结果，solana-keygen 输出格式: "Wrote keypair to <address>.json"
+            // Parse generation results, solana-keygen output format: "Wrote keypair to <address>.json"
             const generatedFiles = [];
             const lines = stdout.split('\n');
             for (const line of lines) {
@@ -734,12 +734,12 @@ export function registerWalletCommands(program) {
                     generatedFiles.push({ address, path: filePath });
                 }
             }
-            // --starts-and-ends-with 模式下需要手动控制 count
+            // In --starts-and-ends-with mode, need to manually control count
             if (options.prefix && generatedFiles.length > count) {
                 generatedFiles.splice(count);
             }
             if (generatedFiles.length === 0) {
-                warn('未能解析到生成的密钥文件');
+                warn('Unable to parse generated key files');
                 process.exit(1);
             }
             if (fmt === 'json') {
@@ -753,7 +753,7 @@ export function registerWalletCommands(program) {
                 });
             }
             else {
-                success(`成功生成 ${generatedFiles.length} 个靓号地址，已保存到 ${VANITY_DIR}`);
+                success(`Successfully generated ${generatedFiles.length} vanity addresses, saved to ${VANITY_DIR}`);
                 output(generatedFiles.map((f, i) => ({
                     index: i + 1,
                     address: f.address,
@@ -761,14 +761,14 @@ export function registerWalletCommands(program) {
                 })), {
                     columns: [
                         { key: 'index', header: '#' },
-                        { key: 'address', header: '地址' },
-                        { key: 'path', header: '文件路径' },
+                        { key: 'address', header: 'Address' },
+                        { key: 'path', header: 'File Path' },
                     ],
                 });
             }
         }
         catch (e) {
-            error('生成靓号地址失败', e.message);
+            error('Failed to generate vanity addresses', e.message);
             process.exit(1);
         }
     });
@@ -777,19 +777,19 @@ export function registerWalletCommands(program) {
     // ============================================================
     walletCmd
         .command('grind-list')
-        .description('列出已生成的靓号地址')
-        .option('--suffix <suffix>', '按后缀过滤')
+        .description('List generated vanity addresses')
+        .option('--suffix <suffix>', 'Filter by suffix')
         .action((options) => {
         try {
             ensureConfigDir();
             if (!fs.existsSync(VANITY_DIR)) {
-                warn('暂无靓号地址，请先运行 forgex wallet grind 生成');
+                warn('No vanity addresses yet, run forgex wallet grind first');
                 output([]);
                 return;
             }
             const files = fs.readdirSync(VANITY_DIR).filter(f => f.endsWith('.json'));
             if (files.length === 0) {
-                warn('暂无靓号地址，请先运行 forgex wallet grind 生成');
+                warn('No vanity addresses yet, run forgex wallet grind first');
                 output([]);
                 return;
             }
@@ -808,19 +808,19 @@ export function registerWalletCommands(program) {
                 results = results.filter(r => r.address.toLowerCase().endsWith(suffixLower));
             }
             if (results.length === 0) {
-                const filterMsg = options.suffix ? `（后缀: ${options.suffix}）` : '';
-                warn(`没有找到匹配的靓号地址${filterMsg}`);
+                const filterMsg = options.suffix ? `(suffix: ${options.suffix})` : '';
+                warn(`No matching vanity addresses found${filterMsg}`);
             }
             output(results, {
                 columns: [
-                    { key: 'address', header: '地址' },
-                    { key: 'createdAt', header: '创建时间' },
-                    { key: 'path', header: '文件路径' },
+                    { key: 'address', header: 'Address' },
+                    { key: 'createdAt', header: 'Created At' },
+                    { key: 'path', header: 'File Path' },
                 ],
             });
         }
         catch (e) {
-            error('获取靓号地址列表失败', e.message);
+            error('Failed to list vanity addresses', e.message);
             process.exit(1);
         }
     });