forgex-cli 1.0.0

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

@@ -0,0 +1,828 @@
+/**
+ * 钱包组管理命令组
+ *
+ * forgex wallet create-group | list-groups | group-info | delete-group |
+ *                  generate | add | remove | import | export |
+ *                  import-group | export-group | overview | grind
+ */
+import { execSync, spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { getAllGroups, getGroup, saveGroup, removeGroup, addWalletsToGroup, removeWalletsFromGroup, generateWallets, walletFromPrivateKey, exportGroupToCsv, importWalletsFromCsv, exportAllGroupsJson, exportEncryptedGroupsJson, importGroupsFromJson, ensurePasswordAndValidate, getDecryptedPrivateKey, } from '../../wallet-store.js';
+import { getDataSource } from '../../data-source.js';
+import { VANITY_DIR, ensureConfigDir } from '../../config.js';
+import { output, success, error, warn, getOutputFormat } from '../../output.js';
+export function registerWalletCommands(program) {
+    const walletCmd = program
+        .command('wallet')
+        .description('钱包组管理');
+    // ============================================================
+    // 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（逗号分隔）')
+        .action(async (options) => {
+        try {
+            // 验证 --type 参数
+            if (options.type !== 'local' && options.type !== 'monitor') {
+                error(`无效的类型 "${options.type}"，只支持 local 或 monitor`);
+                process.exit(1);
+            }
+            const groupType = options.type;
+            // 验证 --monitor-type 参数
+            const validMonitorTypes = ['normal', 'top100', 'retail'];
+            if (!validMonitorTypes.includes(options.monitorType)) {
+                error(`无效的监控类型 "${options.monitorType}"，只支持 normal、top100 或 retail`);
+                process.exit(1);
+            }
+            const monitorType = options.monitorType;
+            const filterGroupIds = options.filterGroupIds
+                ? options.filterGroupIds.split(',')
+                : [];
+            // 验证 filterGroupIds 中的值是否为有效数字
+            const filterGroupIdsNum = filterGroupIds.map(Number);
+            if (filterGroupIdsNum.some(isNaN)) {
+                error('--filter-group-ids 包含无效的 ID，请使用逗号分隔的数字');
+                process.exit(1);
+            }
+            // 纯本地操作: 生成本地 group ID
+            const existingGroups = getAllGroups();
+            const maxId = existingGroups.reduce((max, g) => Math.max(max, g.groupId), 0);
+            const groupId = maxId + 1;
+            // 本地存储
+            const newGroup = {
+                name: options.name,
+                groupId,
+                groupType,
+                wallets: [],
+                monitorType,
+                note: options.remark,
+                monitorCA: options.monitorCa,
+                filterGroupIds: filterGroupIdsNum,
+            };
+            saveGroup(newGroup);
+            output({
+                success: true,
+                groupId: newGroup.groupId,
+                name: newGroup.name,
+                type: newGroup.groupType,
+            });
+        }
+        catch (e) {
+            error('创建钱包组失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet list-groups
+    // ============================================================
+    walletCmd
+        .command('list-groups')
+        .description('列出所有钱包组')
+        .option('--type <type>', '按类型过滤: local | monitor')
+        .action((options) => {
+        try {
+            // 验证 --type 参数
+            if (options.type && options.type !== 'local' && options.type !== 'monitor') {
+                error(`无效的类型 "${options.type}"，只支持 local 或 monitor`);
+                process.exit(1);
+            }
+            let groups = getAllGroups();
+            if (options.type) {
+                groups = groups.filter(g => g.groupType === options.type);
+            }
+            if (groups.length === 0) {
+                const filterMsg = options.type ? `（类型: ${options.type}）` : '';
+                warn(`没有找到钱包组${filterMsg}`);
+            }
+            const result = groups.map(g => ({
+                groupId: g.groupId,
+                name: g.name,
+                type: g.groupType,
+                walletCount: g.wallets.length,
+                monitorType: g.monitorType,
+                note: g.note,
+            }));
+            output(result, {
+                columns: [
+                    { key: 'groupId', header: 'ID' },
+                    { key: 'name', header: '名称' },
+                    { key: 'type', header: '类型' },
+                    { key: 'walletCount', header: '钱包数' },
+                    { key: 'monitorType', header: '监控类型' },
+                    { key: 'note', header: '备注' },
+                ],
+            });
+        }
+        catch (e) {
+            error('获取钱包组列表失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet group-info
+    // ============================================================
+    walletCmd
+        .command('group-info')
+        .description('查看钱包组详情')
+        .requiredOption('--id <groupId>', '钱包组 ID')
+        .option('--show-keys', '显示私钥（危险操作）', false)
+        .action(async (options) => {
+        try {
+            const groupId = Number(options.id);
+            if (isNaN(groupId)) {
+                error(`无效的钱包组 ID "${options.id}"，请提供数字 ID`);
+                process.exit(1);
+            }
+            // 如果需要显示私钥，先确保密码已设置且正确
+            if (options.showKeys) {
+                warn('警告：即将显示私钥明文，请确保当前环境安全，切勿在公共场所或共享屏幕时使用此命令');
+                await ensurePasswordAndValidate();
+            }
+            const group = getGroup(groupId);
+            if (!group) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            const walletsList = group.wallets.map(w => {
+                const entry = {
+                    address: w.walletAddress,
+                    note: w.note,
+                };
+                if (options.showKeys) {
+                    entry.privateKey = getDecryptedPrivateKey(w);
+                }
+                return entry;
+            });
+            const result = {
+                groupId: group.groupId,
+                name: group.name,
+                type: group.groupType,
+                walletCount: group.wallets.length,
+                monitorType: group.monitorType,
+                note: group.note,
+                wallets: walletsList,
+            };
+            output(result);
+        }
+        catch (e) {
+            error('获取钱包组详情失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet delete-group
+    // ============================================================
+    walletCmd
+        .command('delete-group')
+        .description('删除钱包组')
+        .requiredOption('--id <groupId>', '钱包组 ID')
+        .option('--force', '跳过确认', false)
+        .action(async (options) => {
+        try {
+            const groupId = Number(options.id);
+            if (isNaN(groupId)) {
+                error(`无效的钱包组 ID "${options.id}"，请提供数字 ID`);
+                process.exit(1);
+            }
+            // 检查本地是否存在该钱包组
+            const group = getGroup(groupId);
+            if (!group) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            // 非 --force 模式下，提示用户确认
+            if (!options.force) {
+                const { confirm } = await import('@inquirer/prompts');
+                const confirmed = await confirm({
+                    message: `确认删除钱包组 "${group.name}" (ID: ${groupId}, ${group.wallets.length} 个钱包)？此操作不可恢复。`,
+                    default: false,
+                });
+                if (!confirmed) {
+                    warn('已取消删除操作');
+                    return;
+                }
+            }
+            // 纯本地删除
+            removeGroup(groupId);
+            output({ success: true, groupId, message: '钱包组已删除' });
+        }
+        catch (e) {
+            error('删除钱包组失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet generate
+    // ============================================================
+    walletCmd
+        .command('generate')
+        .description('生成新钱包')
+        .requiredOption('--group <groupId>', '目标钱包组 ID')
+        .option('--count <n>', '生成数量', '1')
+        .action(async (options) => {
+        try {
+            await ensurePasswordAndValidate();
+            const groupId = Number(options.group);
+            if (isNaN(groupId)) {
+                error(`无效的钱包组 ID "${options.group}"，请提供数字 ID`);
+                process.exit(1);
+            }
+            const count = Number(options.count);
+            if (isNaN(count) || !Number.isInteger(count) || count <= 0) {
+                error(`无效的生成数量 "${options.count}"，请提供正整数`);
+                process.exit(1);
+            }
+            const group = getGroup(groupId);
+            if (!group) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            if (group.wallets.length + count > 100) {
+                error(`钱包数量超限：当前 ${group.wallets.length} 个，最多再生成 ${100 - group.wallets.length} 个（上限 100）`);
+                process.exit(1);
+            }
+            const wallets = generateWallets(count);
+            // 保存明文私钥用于输出（addWalletsToGroup 可能会加密 wallets 中的 privateKey）
+            const plaintextKeys = wallets.map(w => ({
+                address: w.walletAddress,
+                privateKey: w.privateKey,
+            }));
+            // 纯本地存储（如果存储已加密，此函数会加密 wallets 的 privateKey 字段）
+            addWalletsToGroup(groupId, wallets);
+            // Bug 1 fix: JSON 保持原结构; table/minimal 用 columns 展示生成的钱包列表
+            const fmt = getOutputFormat();
+            if (fmt === 'json') {
+                output({
+                    success: true,
+                    groupId,
+                    generated: plaintextKeys,
+                });
+            }
+            else {
+                success(`已生成 ${plaintextKeys.length} 个钱包到组 ${groupId}`);
+                output(plaintextKeys.map((w, i) => ({
+                    index: i + 1,
+                    address: w.address,
+                    privateKey: w.privateKey,
+                })), {
+                    columns: [
+                        { key: 'index', header: '#' },
+                        { key: 'address', header: '地址' },
+                        { key: 'privateKey', header: '私钥' },
+                    ],
+                });
+            }
+        }
+        catch (e) {
+            error('生成钱包失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet add
+    // ============================================================
+    walletCmd
+        .command('add')
+        .description('添加钱包到钱包组')
+        .requiredOption('--group <groupId>', '目标钱包组 ID')
+        .requiredOption('--private-key <key>', '私钥（Base58 编码）')
+        .option('--note <note>', '备注', '')
+        .action(async (options) => {
+        try {
+            await ensurePasswordAndValidate();
+            const groupId = Number(options.group);
+            if (isNaN(groupId)) {
+                error(`无效的钱包组 ID "${options.group}"，请提供数字 ID`);
+                process.exit(1);
+            }
+            // 验证钱包组存在
+            const group = getGroup(groupId);
+            if (!group) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            // 验证私钥有效性
+            let wallet;
+            try {
+                wallet = walletFromPrivateKey(options.privateKey, options.note);
+            }
+            catch {
+                error('无效的私钥：请提供有效的 Base58 编码私钥');
+                process.exit(1);
+            }
+            // 检查地址是否已存在于该组
+            const exists = group.wallets.some(w => w.walletAddress === wallet.walletAddress);
+            if (exists) {
+                warn(`钱包 ${wallet.walletAddress} 已存在于钱包组 ${groupId} 中，跳过重复添加`);
+                output({
+                    success: true,
+                    groupId,
+                    address: wallet.walletAddress,
+                    duplicate: true,
+                });
+                return;
+            }
+            // 纯本地存储
+            addWalletsToGroup(groupId, [wallet]);
+            output({
+                success: true,
+                groupId,
+                address: wallet.walletAddress,
+            });
+        }
+        catch (e) {
+            error('添加钱包失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet remove
+    // ============================================================
+    walletCmd
+        .command('remove')
+        .description('从钱包组移除钱包')
+        .requiredOption('--group <groupId>', '目标钱包组 ID')
+        .requiredOption('--address <addr>', '钱包地址')
+        .action(async (options) => {
+        try {
+            const groupId = Number(options.group);
+            if (isNaN(groupId)) {
+                error(`无效的钱包组 ID "${options.group}"，请提供数字 ID`);
+                process.exit(1);
+            }
+            // 验证钱包组存在
+            const group = getGroup(groupId);
+            if (!group) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            // 验证地址是否存在于该钱包组中
+            const walletExists = group.wallets.some(w => w.walletAddress === options.address);
+            if (!walletExists) {
+                error(`钱包 ${options.address} 不在钱包组 ${groupId} 中`);
+                process.exit(1);
+            }
+            // 纯本地移除
+            removeWalletsFromGroup(groupId, [options.address]);
+            output({
+                success: true,
+                groupId,
+                removed: options.address,
+            });
+        }
+        catch (e) {
+            error('移除钱包失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet import
+    // ============================================================
+    walletCmd
+        .command('import')
+        .description('从 CSV 文件导入钱包')
+        .requiredOption('--group <groupId>', '目标钱包组 ID')
+        .requiredOption('--file <csvPath>', 'CSV 文件路径')
+        .action(async (options) => {
+        try {
+            await ensurePasswordAndValidate();
+            const groupId = Number(options.group);
+            if (isNaN(groupId) || !Number.isInteger(groupId) || groupId <= 0) {
+                error(`无效的钱包组 ID "${options.group}"，请提供正整数`);
+                process.exit(1);
+            }
+            // 验证钱包组存在
+            const group = getGroup(groupId);
+            if (!group) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            // 验证文件存在
+            if (!fs.existsSync(options.file)) {
+                error(`CSV 文件不存在: ${options.file}`);
+                process.exit(1);
+            }
+            const csvContent = fs.readFileSync(options.file, 'utf-8');
+            const wallets = importWalletsFromCsv(csvContent);
+            if (wallets.length === 0) {
+                error('CSV 文件中没有有效的钱包数据');
+                process.exit(1);
+            }
+            // 纯本地存储
+            addWalletsToGroup(groupId, wallets);
+            output({
+                success: true,
+                groupId,
+                imported: wallets.length,
+                addresses: wallets.map(w => w.walletAddress),
+            });
+        }
+        catch (e) {
+            error('导入钱包失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet export
+    // ============================================================
+    walletCmd
+        .command('export')
+        .description('导出钱包组为 CSV 文件')
+        .requiredOption('--group <groupId>', '钱包组 ID')
+        .requiredOption('--file <csvPath>', '输出文件路径')
+        .action(async (options) => {
+        try {
+            await ensurePasswordAndValidate();
+            const groupId = Number(options.group);
+            if (isNaN(groupId) || !Number.isInteger(groupId) || groupId <= 0) {
+                error(`无效的钱包组 ID "${options.group}"，请提供正整数`);
+                process.exit(1);
+            }
+            const csv = exportGroupToCsv(groupId);
+            if (!csv) {
+                error(`钱包组 ${groupId} 不存在`);
+                process.exit(1);
+            }
+            fs.writeFileSync(options.file, csv, { encoding: 'utf-8', mode: 0o600 });
+            output({
+                success: true,
+                groupId,
+                file: options.file,
+            });
+        }
+        catch (e) {
+            error('导出钱包失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet import-group
+    // ============================================================
+    walletCmd
+        .command('import-group')
+        .description('从 JSON 文件导入钱包组')
+        .requiredOption('--file <jsonPath>', 'JSON 文件路径')
+        .option('--password <pwd>', '解密密码（加密文件需要）')
+        .action(async (options) => {
+        try {
+            await ensurePasswordAndValidate();
+            // 验证文件存在
+            if (!fs.existsSync(options.file)) {
+                error(`JSON 文件不存在: ${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 是否正确）');
+                process.exit(1);
+            }
+            // 纯本地存储（通过 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 = []; // 先保存空钱包组
+                saveGroup(g);
+                // 通过 addWalletsToGroup 添加钱包，该函数会自动处理加密
+                if (wallets.length > 0) {
+                    addWalletsToGroup(newId, wallets);
+                }
+            });
+            output({
+                success: true,
+                imported: groups.length,
+                groupIds: groups.map(g => g.groupId),
+            });
+        }
+        catch (e) {
+            error('导入钱包组失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet export-group
+    // ============================================================
+    walletCmd
+        .command('export-group')
+        .description('导出所有钱包组为 JSON 文件')
+        .requiredOption('--file <jsonPath>', '输出文件路径')
+        .option('--encrypt', '加密导出', false)
+        .option('--password <pwd>', '加密密码')
+        .action(async (options) => {
+        try {
+            await ensurePasswordAndValidate();
+            const groups = getAllGroups();
+            if (groups.length === 0) {
+                warn('没有钱包组可导出');
+                output({ success: true, file: options.file, encrypted: options.encrypt, groupCount: 0 });
+                return;
+            }
+            let content;
+            if (options.encrypt) {
+                const password = options.password || process.env.FORGEX_WALLET_PASSWORD;
+                if (!password) {
+                    error('加密导出需要密码，使用 --password 或设置 FORGEX_WALLET_PASSWORD 环境变量');
+                    process.exit(1);
+                }
+                content = exportEncryptedGroupsJson(password);
+            }
+            else {
+                content = exportAllGroupsJson();
+            }
+            fs.writeFileSync(options.file, content, { encoding: 'utf-8', mode: 0o600 });
+            output({
+                success: true,
+                file: options.file,
+                encrypted: options.encrypt,
+                groupCount: groups.length,
+            });
+        }
+        catch (e) {
+            error('导出钱包组失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet overview
+    // ============================================================
+    walletCmd
+        .command('overview')
+        .description('查看钱包组概览')
+        .requiredOption('--groups <ids>', '钱包组 ID（逗号分隔）')
+        .option('--token <ca>', '按代币过滤')
+        .action(async (options) => {
+        try {
+            const groupIds = options.groups.split(',').map(Number);
+            // 验证所有 groupId 都是有效正整数
+            if (groupIds.some(id => isNaN(id) || !Number.isInteger(id) || id <= 0)) {
+                error(`无效的钱包组 ID 列表 "${options.groups}"，请提供逗号分隔的正整数`);
+                process.exit(1);
+            }
+            // 验证本地是否存在这些钱包组
+            const missingIds = groupIds.filter(id => !getGroup(id));
+            if (missingIds.length > 0) {
+                warn(`以下钱包组在本地不存在: ${missingIds.join(', ')}`);
+            }
+            const ds = getDataSource();
+            // 从 DataStore 本地数据构建概览
+            const overviewResults = [];
+            for (const gid of groupIds) {
+                const group = getGroup(gid);
+                if (!group)
+                    continue;
+                // 确定要查询的代币列表
+                const tokenCAs = options.token ? [options.token] : ds.listTokens();
+                let totalValueSol = 0;
+                let totalRealizedPnl = 0;
+                let totalUnrealizedPnl = 0;
+                let totalCostSol = 0;
+                let totalTokenPositions = 0;
+                for (const ca of tokenCAs) {
+                    const holdings = ds.getHoldings(ca, gid);
+                    if (!holdings || holdings.wallets.length === 0)
+                        continue;
+                    // 尝试获取代币价格
+                    let priceSol = 0;
+                    try {
+                        const priceData = await ds.getTokenPrice(ca);
+                        priceSol = priceData.priceSol;
+                    }
+                    catch {
+                        // 价格不可用，跳过价值计算
+                    }
+                    for (const w of holdings.wallets) {
+                        const positionValue = w.tokenBalance * priceSol;
+                        totalValueSol += positionValue;
+                        totalRealizedPnl += w.realizedPnl;
+                        totalUnrealizedPnl += positionValue - w.tokenBalance * w.avgBuyPrice;
+                        totalCostSol += w.totalCostSol;
+                        if (w.tokenBalance > 0)
+                            totalTokenPositions++;
+                    }
+                }
+                const avgCost = totalTokenPositions > 0 ? totalCostSol / totalTokenPositions : 0;
+                overviewResults.push({
+                    groupId: gid,
+                    groupName: group.name,
+                    totalValue: totalValueSol.toFixed(4),
+                    pnl: (totalRealizedPnl + totalUnrealizedPnl).toFixed(4),
+                    donePnl: totalRealizedPnl.toFixed(4),
+                    unDonePnl: totalUnrealizedPnl.toFixed(4),
+                    avgCost: avgCost.toFixed(6),
+                });
+            }
+            if (overviewResults.length === 0) {
+                warn('暂无钱包组概览数据');
+            }
+            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: '均价' },
+                ],
+            });
+        }
+        catch (e) {
+            error('获取钱包组概览失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet grind
+    // ============================================================
+    walletCmd
+        .command('grind')
+        .description('生成靓号地址（自定义后缀/前缀）')
+        .requiredOption('--suffix <suffix>', '地址后缀（如 pump）')
+        .option('--prefix <prefix>', '地址前缀')
+        .option('--count <n>', '生成数量', '1')
+        .option('--threads <n>', 'grind 线程数')
+        .action(async (options) => {
+        try {
+            // 检查 solana-keygen 是否可用
+            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');
+                process.exit(1);
+            }
+            const count = Number(options.count);
+            if (isNaN(count) || !Number.isInteger(count) || count <= 0) {
+                error(`无效的生成数量 "${options.count}"，请提供正整数`);
+                process.exit(1);
+            }
+            const suffix = options.suffix.trim();
+            if (!suffix) {
+                error('--suffix 不能为空');
+                process.exit(1);
+            }
+            // 验证后缀只包含 Base58 字符
+            const base58Chars = /^[1-9A-HJ-NP-Za-km-z]+$/;
+            if (!base58Chars.test(suffix)) {
+                error(`无效的后缀 "${suffix}"，只支持 Base58 字符（不含 0, O, I, l）`);
+                process.exit(1);
+            }
+            if (options.prefix && !base58Chars.test(options.prefix)) {
+                error(`无效的前缀 "${options.prefix}"，只支持 Base58 字符（不含 0, O, I, l）`);
+                process.exit(1);
+            }
+            ensureConfigDir();
+            // 构建 solana-keygen grind 参数
+            const args = ['grind'];
+            if (options.prefix) {
+                args.push('--starts-and-ends-with', `${options.prefix}:${suffix}`);
+            }
+            else {
+                args.push('--ends-with', `${suffix}:${count}`);
+            }
+            if (options.threads) {
+                const threads = Number(options.threads);
+                if (isNaN(threads) || !Number.isInteger(threads) || threads <= 0) {
+                    error(`无效的线程数 "${options.threads}"，请提供正整数`);
+                    process.exit(1);
+                }
+                args.push('--num-threads', String(threads));
+            }
+            const fmt = getOutputFormat();
+            if (fmt !== 'json') {
+                success(`正在生成 ${count} 个以 "${suffix}" 结尾的靓号地址，请耐心等待...`);
+                if (suffix.length >= 5) {
+                    warn('后缀较长，生成时间可能需要数分钟甚至更久');
+                }
+            }
+            // 在 VANITY_DIR 下执行 grind，生成的 .json 文件会落在该目录
+            const child = spawn('solana-keygen', args, {
+                cwd: VANITY_DIR,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => { stdout += data.toString(); });
+            child.stderr.on('data', (data) => { stderr += data.toString(); });
+            const exitCode = await new Promise((resolve) => {
+                child.on('close', resolve);
+            });
+            if (exitCode !== 0) {
+                error('solana-keygen grind 执行失败', stderr || stdout);
+                process.exit(1);
+            }
+            // 解析生成结果，solana-keygen 输出格式: "Wrote keypair to <address>.json"
+            const generatedFiles = [];
+            const lines = stdout.split('\n');
+            for (const line of lines) {
+                const match = line.match(/Wrote keypair to (.+\.json)/);
+                if (match) {
+                    const filename = match[1].trim();
+                    const filePath = path.resolve(VANITY_DIR, filename);
+                    const address = path.basename(filename, '.json');
+                    generatedFiles.push({ address, path: filePath });
+                }
+            }
+            // --starts-and-ends-with 模式下需要手动控制 count
+            if (options.prefix && generatedFiles.length > count) {
+                generatedFiles.splice(count);
+            }
+            if (generatedFiles.length === 0) {
+                warn('未能解析到生成的密钥文件');
+                process.exit(1);
+            }
+            if (fmt === 'json') {
+                output({
+                    success: true,
+                    count: generatedFiles.length,
+                    suffix,
+                    prefix: options.prefix || null,
+                    dir: VANITY_DIR,
+                    keypairs: generatedFiles,
+                });
+            }
+            else {
+                success(`成功生成 ${generatedFiles.length} 个靓号地址，已保存到 ${VANITY_DIR}`);
+                output(generatedFiles.map((f, i) => ({
+                    index: i + 1,
+                    address: f.address,
+                    path: f.path,
+                })), {
+                    columns: [
+                        { key: 'index', header: '#' },
+                        { key: 'address', header: '地址' },
+                        { key: 'path', header: '文件路径' },
+                    ],
+                });
+            }
+        }
+        catch (e) {
+            error('生成靓号地址失败', e.message);
+            process.exit(1);
+        }
+    });
+    // ============================================================
+    // forgex wallet grind-list
+    // ============================================================
+    walletCmd
+        .command('grind-list')
+        .description('列出已生成的靓号地址')
+        .option('--suffix <suffix>', '按后缀过滤')
+        .action((options) => {
+        try {
+            ensureConfigDir();
+            if (!fs.existsSync(VANITY_DIR)) {
+                warn('暂无靓号地址，请先运行 forgex wallet grind 生成');
+                output([]);
+                return;
+            }
+            const files = fs.readdirSync(VANITY_DIR).filter(f => f.endsWith('.json'));
+            if (files.length === 0) {
+                warn('暂无靓号地址，请先运行 forgex wallet grind 生成');
+                output([]);
+                return;
+            }
+            let results = files.map(f => {
+                const address = path.basename(f, '.json');
+                const filePath = path.join(VANITY_DIR, f);
+                const stat = fs.statSync(filePath);
+                return {
+                    address,
+                    path: filePath,
+                    createdAt: stat.birthtime.toISOString().replace('T', ' ').slice(0, 19),
+                };
+            });
+            if (options.suffix) {
+                const suffixLower = options.suffix.toLowerCase();
+                results = results.filter(r => r.address.toLowerCase().endsWith(suffixLower));
+            }
+            if (results.length === 0) {
+                const filterMsg = options.suffix ? `（后缀: ${options.suffix}）` : '';
+                warn(`没有找到匹配的靓号地址${filterMsg}`);
+            }
+            output(results, {
+                columns: [
+                    { key: 'address', header: '地址' },
+                    { key: 'createdAt', header: '创建时间' },
+                    { key: 'path', header: '文件路径' },
+                ],
+            });
+        }
+        catch (e) {
+            error('获取靓号地址列表失败', e.message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=index.js.map