@pasosdejesus/m 0.15.0

package/dist/tasks/wallet.js

@@ -0,0 +1,697 @@
+// src/tasks/wallet.ts
+// Wallet management commands: generate, approve, list, send, balance, etc.
+//
+// Wallets stored in ~/.m/wallets/ with chmod 600.
+// Uses viem for all blockchain interactions.
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { success, warn, problem } from '../util/colors.js';
+import { createTranslator } from '../i18n/createTranslator.js';
+import { detectLocale } from '../util/locale.js';
+import commonCli from '../i18n/common-cli.js';
+const t = createTranslator(detectLocale(), {
+    en: {
+        'wallet.unknown': 'Unknown command: wallet:{{0}}',
+        'wallet.no_wallets': 'No wallets found. Use wallet:generate or wallet:import first.',
+    },
+    es: {
+        'wallet.unknown': 'Comando desconocido: wallet:{{0}}',
+        'wallet.no_wallets': 'No se encontraron billeteras. Use wallet:generate o wallet:import primero.',
+    },
+}, commonCli);
+// ==================== STORAGE ====================
+function getWalletsDir() {
+    return process.env.M_WALLETS_DIR || path.join(os.homedir(), '.m', 'wallets');
+}
+function ensureWalletDir() {
+    fs.mkdirSync(getWalletsDir(), { recursive: true, mode: 0o700 });
+}
+function ensurePermissions(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory() && (stat.mode & 0o777) !== 0o700) {
+            warn(`Fixing permissions on ${filePath} (was ${(stat.mode & 0o777).toString(8)}, setting 700)`);
+            fs.chmodSync(filePath, 0o700);
+        }
+        else if (stat.isFile() && (stat.mode & 0o777) !== 0o600) {
+            warn(`Fixing permissions on ${filePath} (was ${(stat.mode & 0o777).toString(8)}, setting 600)`);
+            fs.chmodSync(filePath, 0o600);
+        }
+    }
+    catch { /* file may not exist yet */ }
+}
+function getWalletPath(name) {
+    return path.join(getWalletsDir(), `${name}.json`);
+}
+function loadWallet(name) {
+    const p = getWalletPath(name);
+    if (!fs.existsSync(p))
+        return null;
+    ensurePermissions(p);
+    return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+function saveWallet(name, address, privateKey, mnemonic) {
+    ensureWalletDir();
+    ensurePermissions(getWalletsDir());
+    const p = getWalletPath(name);
+    const data = { name, address, privateKey };
+    if (mnemonic)
+        data.mnemonic = mnemonic;
+    fs.writeFileSync(p, JSON.stringify(data, null, 2), { mode: 0o600 });
+    ensurePermissions(p);
+}
+// ==================== HELPERS ====================
+function getArg(args, name) {
+    const idx = args.indexOf(name);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+/**
+ * Produce a user-friendly error message from an RPC failure.
+ * Detects common viem/HTTP errors: missing API keys, timeouts, network issues.
+ */
+function formatRpcError(err, rpc) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes('403') || msg.includes('Forbidden'))
+        return `RPC unavailable — the endpoint may require an API key. Try --rpc with a valid URL.\n   URL: ${rpc}`;
+    if (msg.includes('401') || msg.includes('Unauthorized'))
+        return `RPC authentication failed — check your API key.\n   URL: ${rpc}`;
+    if (msg.includes('ECONNREFUSED') || msg.includes('ENOTFOUND') || msg.includes('ETIMEDOUT'))
+        return `Cannot reach RPC — network error. Verify the URL or your connection.\n   URL: ${rpc}`;
+    if (msg.includes('HTTP error'))
+        return `RPC error: ${msg}\n   URL: ${rpc}`;
+    return `RPC error: ${msg}\n   URL: ${rpc}`;
+}
+/**
+ * Parse a function signature like "pause()" or "transfer(address,uint256)"
+ * with optional comma-separated args "0x1234, 100".
+ */
+function parseFunctionSignature(sig, argsStr) {
+    const match = sig.match(/^(\w+)\(([^)]*)\)$/);
+    if (!match)
+        throw new Error(`Invalid function signature: ${sig}. Use "name(type1,type2,...)"`);
+    const name = match[1];
+    const typeStr = match[2];
+    const types = typeStr ? typeStr.split(',').map(t => t.trim()).filter(Boolean) : [];
+    if (!argsStr) {
+        if (types.length > 0)
+            throw new Error(`--args required for function ${name}(${types.join(',')})`);
+        return { name, types, args: [] };
+    }
+    const rawArgs = argsStr.split(',').map(a => a.trim());
+    const parsedArgs = types.map((t, i) => {
+        const raw = rawArgs[i];
+        if (!raw)
+            throw new Error(`Missing arg ${i} (type: ${t}) for function ${name}`);
+        if (t.startsWith('uint') || t.startsWith('int'))
+            return BigInt(raw);
+        if (t === 'bool')
+            return raw === 'true';
+        return raw;
+    });
+    return { name, types, args: parsedArgs };
+}
+async function resolveToAddress(value) {
+    if (value.startsWith('0x'))
+        return value;
+    const w = loadWallet(value);
+    if (w)
+        return w.address;
+    throw new Error(`Wallet not found and not a valid address: ${value}`);
+}
+// ==================== wallet:generate ====================
+async function cmdGenerate(args) {
+    const name = getArg(args, '--name');
+    const index = parseInt(getArg(args, '--index') || '0');
+    const outputEnv = getArg(args, '--output-env');
+    if (!name)
+        throw new Error('--name required');
+    const targetPath = getWalletPath(name);
+    if (fs.existsSync(targetPath)) {
+        throw new Error(`Wallet "${name}" already exists at ${targetPath}. Use a different --name.`);
+    }
+    const { generateMnemonic, mnemonicToAccount, english } = await import('viem/accounts');
+    const mnemonic = generateMnemonic(english);
+    const account = mnemonicToAccount(mnemonic, { accountIndex: index, addressIndex: 0 });
+    const hdKey = account.getHdKey();
+    const privateKey = `0x${Buffer.from(hdKey.privateKey).toString('hex')}`;
+    saveWallet(name, account.address, privateKey, mnemonic);
+    success(`\n✅ Wallet generated: ${name}`);
+    console.log(`   Address:    ${account.address}`);
+    console.log(`   PrivateKey: ${privateKey}`);
+    console.log(`   Mnemonic:   ${mnemonic}`);
+    warn(`   ⚠️  SAVE THE MNEMONIC — it will not be shown again.`);
+    console.log(`   Stored:    ${targetPath}`);
+    if (outputEnv) {
+        console.log(`\n${outputEnv}=${account.address}`);
+    }
+}
+// ==================== wallet:approve ====================
+async function cmdApprove(args) {
+    const name = getArg(args, '--name');
+    const token = getArg(args, '--token');
+    const spenderRaw = getArg(args, '--spender');
+    const amount = getArg(args, '--amount');
+    const network = getArg(args, '--network') || 'celoSepolia';
+    const rpcUrl = getArg(args, '--rpc');
+    if (!name || !token || !spenderRaw || !amount) {
+        throw new Error('--name, --token, --spender, --amount required');
+    }
+    const wallet = loadWallet(name);
+    if (!wallet)
+        throw new Error(`Wallet "${name}" not found. Use wallet:generate or wallet:import first.`);
+    if (!wallet.privateKey)
+        throw new Error(`Wallet "${name}" has no private key stored.`);
+    const spender = await resolveToAddress(spenderRaw);
+    const { createPublicClient, createWalletClient, http, parseUnits } = await import('viem');
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const account = privateKeyToAccount(wallet.privateKey);
+    const chain = await resolveChain(network);
+    const rpc = rpcUrl || getDefaultRpc(network);
+    const pc = createPublicClient({ chain, transport: http(rpc) });
+    const wc = createWalletClient({ chain, transport: http(rpc), account });
+    // Read token decimals (with fallback)
+    let decimals = 6;
+    try {
+        decimals = await pc.readContract({
+            address: token,
+            abi: [{ name: 'decimals', type: 'function', outputs: [{ type: 'uint8' }] }],
+            functionName: 'decimals',
+        });
+    }
+    catch {
+        // Some tokens (proxies, non-standard) don't expose decimals. Default to 6.
+    }
+    const maxUint256 = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+    const parsedAmount = amount === 'max'
+        ? BigInt(maxUint256)
+        : parseUnits(amount, decimals);
+    const erc20Abi = [{
+            name: 'approve',
+            type: 'function',
+            inputs: [
+                { name: 'spender', type: 'address' },
+                { name: 'value', type: 'uint256' },
+            ],
+            outputs: [{ type: 'bool' }],
+        }];
+    const hash = await wc.writeContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: 'approve',
+        args: [spender, parsedAmount],
+        chain,
+        account,
+    });
+    success(`✅ Approved ${amount} tokens for spender ${spender}`);
+    console.log(`   TX: ${hash}`);
+}
+// ==================== CHAIN RESOLUTION ====================
+async function resolveChain(network) {
+    const chains = {
+        celo: () => import('viem/chains').then(m => m.celo),
+        celoSepolia: () => import('viem/chains').then(m => m.celoSepolia),
+        celoAlfajores: () => import('viem/chains').then(m => m.celoAlfajores),
+        base: () => import('viem/chains').then(m => m.base),
+        baseSepolia: () => import('viem/chains').then(m => m.baseSepolia),
+    };
+    const loader = chains[network];
+    if (!loader)
+        throw new Error(`Unknown network: ${network}. Use celo, celoSepolia, base, or baseSepolia.`);
+    return loader();
+}
+function getDefaultRpc(network) {
+    const fromEnv = process.env.NEXT_PUBLIC_RPC_URL || process.env.RPC_URL;
+    if (fromEnv)
+        return fromEnv;
+    const defaults = {
+        celo: 'https://forno.celo.org',
+        celoSepolia: 'https://forno.celo-sepolia.celo-testnet.org',
+        celoAlfajores: 'https://alfajores-forno.celo-testnet.org',
+        base: 'https://mainnet.base.org',
+        baseSepolia: 'https://sepolia.base.org',
+    };
+    return defaults[network] || '';
+}
+// ==================== wallet:import ====================
+async function cmdImport(args) {
+    const name = getArg(args, '--name');
+    const mnemonic = getArg(args, '--mnemonic');
+    const privateKey = getArg(args, '--private-key');
+    const index = parseInt(getArg(args, '--index') || '0');
+    if (!name)
+        throw new Error('--name required');
+    if (!mnemonic && !privateKey)
+        throw new Error('--mnemonic or --private-key required');
+    const targetPath = getWalletPath(name);
+    if (fs.existsSync(targetPath))
+        throw new Error(`Wallet "${name}" already exists.`);
+    let address;
+    let pk;
+    if (privateKey) {
+        const { privateKeyToAddress } = await import('viem/accounts');
+        pk = privateKey;
+        address = privateKeyToAddress(privateKey);
+    }
+    else {
+        const { mnemonicToAccount } = await import('viem/accounts');
+        const account = mnemonicToAccount(mnemonic, { accountIndex: index, addressIndex: 0 });
+        const hdKey = account.getHdKey();
+        pk = `0x${Buffer.from(hdKey.privateKey).toString('hex')}`;
+        address = account.address;
+    }
+    saveWallet(name, address, pk);
+    success(`✅ Wallet imported: ${name}`);
+    console.log(`   Address: ${address}`);
+}
+// ==================== wallet:list ====================
+async function cmdList(args) {
+    const nameFilter = getArg(args, '--name');
+    const addressOnly = args.includes('--address-only');
+    const showBalance = args.includes('--balance');
+    const network = getArg(args, '--network') || 'celoSepolia';
+    const rpcUrl = getArg(args, '--rpc');
+    ensureWalletDir();
+    ensurePermissions(getWalletsDir());
+    const files = fs.readdirSync(getWalletsDir()).filter(f => f.endsWith('.json'));
+    if (files.length === 0) {
+        console.log('No wallets found. Use wallet:generate or wallet:import to create one.');
+        return;
+    }
+    for (const file of files) {
+        const w = JSON.parse(fs.readFileSync(path.join(getWalletsDir(), file), 'utf-8'));
+        if (nameFilter && w.name !== nameFilter)
+            continue;
+        if (addressOnly) {
+            console.log(w.address);
+        }
+        else if (showBalance) {
+            const chain = await resolveChain(network);
+            const rpc = rpcUrl || getDefaultRpc(network);
+            const { createPublicClient, http, formatEther } = await import('viem');
+            const pc = createPublicClient({ chain, transport: http(rpc) });
+            try {
+                const bal = await pc.getBalance({ address: w.address });
+                console.log(`${w.name.padEnd(20)} ${w.address}  ${formatEther(bal)} ${chain.nativeCurrency?.symbol || 'ETH'}`);
+            }
+            catch (err) {
+                console.log(`${w.name.padEnd(20)} ${w.address}  (balance unavailable: ${formatRpcError(err, rpc)})`);
+            }
+        }
+        else {
+            console.log(`${w.name.padEnd(20)} ${w.address}`);
+        }
+    }
+}
+// ==================== wallet:send ====================
+async function cmdSend(args) {
+    const name = getArg(args, '--name');
+    const toRaw = getArg(args, '--to');
+    const amount = getArg(args, '--amount');
+    const token = getArg(args, '--token');
+    const rawData = getArg(args, '--data');
+    const func = getArg(args, '--function');
+    const funcArgs = getArg(args, '--args');
+    const network = getArg(args, '--network') || 'celoSepolia';
+    const rpcUrl = getArg(args, '--rpc');
+    if (!name || !toRaw)
+        throw new Error('--name, --to required');
+    if (!amount && !token && !rawData && !func)
+        throw new Error('--amount, --token, --data, or --function required');
+    // Validate function signature early (before wallet lookup)
+    if (func) {
+        parseFunctionSignature(func, funcArgs);
+    }
+    // Validate function signature early (before wallet lookup)
+    let parsedFunc = null;
+    if (func) {
+        parsedFunc = parseFunctionSignature(func, funcArgs);
+    }
+    const wallet = loadWallet(name);
+    if (!wallet)
+        throw new Error(`Wallet "${name}" not found.`);
+    if (!wallet.privateKey)
+        throw new Error(`Wallet "${name}" has no private key.`);
+    const to = await resolveToAddress(toRaw);
+    const { createPublicClient, createWalletClient, http, parseUnits, encodeFunctionData, formatEther } = await import('viem');
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const account = privateKeyToAccount(wallet.privateKey);
+    const chain = await resolveChain(network);
+    const rpc = rpcUrl || getDefaultRpc(network);
+    if (!rpc)
+        throw new Error(`No RPC URL for network "${network}". Provide --rpc.`);
+    // Compute calldata from --function + --args
+    let data;
+    if (parsedFunc) {
+        const { name, types, args } = parsedFunc;
+        data = encodeFunctionData({
+            abi: [{ name, type: 'function', inputs: types.map(t => ({ type: t })) }],
+            functionName: name,
+            args,
+        });
+    }
+    else if (rawData) {
+        data = rawData;
+    }
+    if (data) {
+        // Raw contract call (arbitrary function via --data or --function + --args)
+        const wc = createWalletClient({ chain, transport: http(rpc), account });
+        const hash = await wc.sendTransaction({
+            to, data, chain, account,
+        });
+        console.log(`✅ Transaction sent to ${to}`);
+        console.log(`   TX: ${hash}`);
+    }
+    else if (token) {
+        if (!amount)
+            throw new Error('--amount required for token transfers');
+        // ERC20 transfer
+        const pc = createPublicClient({ chain, transport: http(rpc) });
+        const decimals = await pc.readContract({
+            address: token,
+            abi: [{ name: 'decimals', type: 'function', outputs: [{ type: 'uint8' }] }],
+            functionName: 'decimals',
+        });
+        const parsedAmount = parseUnits(amount, decimals);
+        const wc = createWalletClient({ chain, transport: http(rpc), account });
+        const hash = await wc.writeContract({
+            address: token,
+            abi: [{ name: 'transfer', type: 'function', inputs: [
+                        { name: 'to', type: 'address' }, { name: 'value', type: 'uint256' }
+                    ], outputs: [{ type: 'bool' }] }],
+            functionName: 'transfer',
+            args: [to, parsedAmount],
+            chain, account,
+        });
+        console.log(`✅ Sent ${amount} token(s) to ${to}`);
+        console.log(`   TX: ${hash}`);
+    }
+    else {
+        if (!amount)
+            throw new Error('--amount required for native transfers');
+        // Native token transfer
+        const wc = createWalletClient({ chain, transport: http(rpc), account });
+        const hash = await wc.sendTransaction({
+            to,
+            value: parseUnits(amount, 18),
+            chain, account,
+        });
+        const pc = createPublicClient({ chain, transport: http(rpc) });
+        const receipt = await pc.waitForTransactionReceipt({ hash });
+        console.log(`✅ Sent ${amount} ${chain.nativeCurrency?.symbol || 'ETH'} to ${to}`);
+        console.log(`   TX: ${hash}`);
+    }
+}
+// ==================== wallet:balance ====================
+async function cmdBalance(args) {
+    const name = getArg(args, '--name');
+    const token = getArg(args, '--token');
+    const network = getArg(args, '--network') || 'celoSepolia';
+    const rpcUrl = getArg(args, '--rpc');
+    if (!name)
+        throw new Error('--name required');
+    const wallet = loadWallet(name);
+    if (!wallet)
+        throw new Error(`Wallet "${name}" not found.`);
+    const { createPublicClient, http, formatEther } = await import('viem');
+    const chain = await resolveChain(network);
+    const rpc = rpcUrl || getDefaultRpc(network);
+    const pc = createPublicClient({ chain, transport: http(rpc) });
+    if (token) {
+        try {
+            const bal = await pc.readContract({
+                address: token,
+                abi: [{ name: 'balanceOf', type: 'function', inputs: [{ type: 'address' }], outputs: [{ type: 'uint256' }] }],
+                functionName: 'balanceOf',
+                args: [wallet.address],
+            });
+            const decimals = await pc.readContract({
+                address: token,
+                abi: [{ name: 'decimals', type: 'function', outputs: [{ type: 'uint8' }] }],
+                functionName: 'decimals',
+            });
+            const { formatUnits } = await import('viem');
+            console.log(`${formatUnits(bal, decimals)} tokens`);
+        }
+        catch (err) {
+            problem(formatRpcError(err, rpc));
+        }
+    }
+    else {
+        try {
+            const bal = await pc.getBalance({ address: wallet.address });
+            console.log(`${formatEther(bal)} ${chain.nativeCurrency?.symbol || 'ETH'}`);
+        }
+        catch (err) {
+            problem(formatRpcError(err, rpc));
+        }
+    }
+}
+// ==================== wallet:call ====================
+async function cmdCall(args) {
+    const name = getArg(args, '--name');
+    const to = getArg(args, '--to');
+    const func = getArg(args, '--function');
+    const funcArgs = getArg(args, '--args');
+    const network = getArg(args, '--network') || 'celoSepolia';
+    const rpcUrl = getArg(args, '--rpc');
+    if (!name || !to || !func)
+        throw new Error('--name, --to, --function required');
+    const wallet = loadWallet(name);
+    if (!wallet)
+        throw new Error(`Wallet "${name}" not found.`);
+    if (!wallet.privateKey)
+        throw new Error(`Wallet "${name}" has no private key.`);
+    const { createPublicClient, http } = await import('viem');
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const chain = await resolveChain(network);
+    const rpc = rpcUrl || getDefaultRpc(network);
+    if (!rpc)
+        throw new Error(`No RPC URL for network "${network}". Provide --rpc.`);
+    const account = privateKeyToAccount(wallet.privateKey);
+    const pc = createPublicClient({ chain, transport: http(rpc) });
+    // Parse function signature: "balanceOf(address)" or "totalSupply()(uint256)"
+    const match = func.match(/^(\w+)\(([^)]*)\)(?:\((\w+)\))?$/);
+    if (!match)
+        throw new Error(`Invalid function signature: ${func}. Use "name(type1,type2,...)" or "name()(returnType)"`);
+    const funcName = match[1];
+    const typeStr = match[2];
+    const returnType = match[3] || 'address'; // default: address (most common)
+    const types = typeStr ? typeStr.split(',').map(t => t.trim()).filter(Boolean) : [];
+    // Parse args
+    const parsedArgs = funcArgs ? funcArgs.split(',').map(a => a.trim()) : [];
+    const result = await pc.readContract({
+        address: to,
+        abi: [{ name: funcName, type: 'function', inputs: types.map((t, i) => ({ type: t })), outputs: [{ type: returnType }], stateMutability: 'view' }],
+        functionName: funcName,
+        args: parsedArgs,
+    });
+    console.log(result);
+}
+// ==================== wallet:derive ====================
+async function cmdDerive(args) {
+    const parentName = getArg(args, '--name');
+    const asName = getArg(args, '--as');
+    const index = parseInt(getArg(args, '--index') || '1');
+    if (!parentName || !asName)
+        throw new Error('--name and --as required');
+    const parent = loadWallet(parentName);
+    if (!parent)
+        throw new Error(`Wallet "${parentName}" not found.`);
+    const parentMnemonic = parent.mnemonic;
+    if (!parentMnemonic) {
+        throw new Error(`Cannot derive from "${parentName}" — no mnemonic stored. ` +
+            `Re-generate the wallet with wallet:generate.`);
+    }
+    const targetPath = getWalletPath(asName);
+    if (fs.existsSync(targetPath)) {
+        throw new Error(`Wallet "${asName}" already exists at ${targetPath}. Use a different --as.`);
+    }
+    const { mnemonicToAccount } = await import('viem/accounts');
+    const account = mnemonicToAccount(parentMnemonic, { accountIndex: index, addressIndex: 0 });
+    const hdKey = account.getHdKey();
+    const privateKey = `0x${Buffer.from(hdKey.privateKey).toString('hex')}`;
+    saveWallet(asName, account.address, privateKey, parentMnemonic);
+    success(`\n✅ Wallet derived: ${asName}`);
+    console.log(`   Address:    ${account.address}`);
+    console.log(`   PrivateKey: ${privateKey}`);
+    console.log(`   Derived from: ${parentName} (index ${index})`);
+    console.log(`   Stored:    ${targetPath}`);
+}
+// ==================== wallet:sign (airgapped) ====================
+async function cmdSign(args) {
+    const name = getArg(args, '--name');
+    const txFile = getArg(args, '--tx');
+    if (!name)
+        throw new Error('--name required');
+    if (!txFile)
+        throw new Error('--tx <json-file> required');
+    const wallet = loadWallet(name);
+    if (!wallet)
+        throw new Error(`Wallet "${name}" not found.`);
+    if (!wallet.privateKey)
+        throw new Error(`Wallet "${name}" has no private key.`);
+    const tx = JSON.parse(fs.readFileSync(txFile, 'utf-8'));
+    const { privateKeyToAccount } = await import('viem/accounts');
+    const account = privateKeyToAccount(wallet.privateKey);
+    // Accept hex or decimal for gas/chainId
+    const signed = await account.signTransaction({
+        to: tx.to,
+        value: tx.value ? BigInt(tx.value) : undefined,
+        data: tx.data || undefined,
+        chainId: typeof tx.chainId === 'string' ? parseInt(tx.chainId) : tx.chainId,
+        nonce: tx.nonce,
+        gasLimit: tx.gasLimit ? BigInt(tx.gasLimit) : undefined,
+        gasPrice: tx.gasPrice ? BigInt(tx.gasPrice) : undefined,
+        maxFeePerGas: tx.maxFeePerGas ? BigInt(tx.maxFeePerGas) : undefined,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? BigInt(tx.maxPriorityFeePerGas) : undefined,
+    });
+    const signedPath = txFile.replace(/\.json$/, '-signed.json');
+    fs.writeFileSync(signedPath, JSON.stringify({ signedTx: signed }, null, 2));
+    success(`✅ Signed transaction saved to ${signedPath}`);
+}
+// ==================== wallet:broadcast ====================
+async function cmdBroadcast(args) {
+    const signedFile = getArg(args, '--signed-tx');
+    const rpcUrl = getArg(args, '--rpc');
+    if (!signedFile)
+        throw new Error('--signed-tx <json> required');
+    if (!rpcUrl)
+        throw new Error('--rpc <url> required');
+    const data = JSON.parse(fs.readFileSync(signedFile, 'utf-8'));
+    if (!data.signedTx)
+        throw new Error('Signed transaction file must contain { signedTx: "0x..." }');
+    const { createPublicClient, http } = await import('viem');
+    const client = createPublicClient({ transport: http(rpcUrl) });
+    const hash = await client.sendRawTransaction({ serializedTransaction: data.signedTx });
+    success(`✅ Transaction broadcasted`);
+    console.log(`   Hash: ${hash}`);
+}
+// ==================== KECCAK ====================
+async function cmdKeccak(args) {
+    if (args.length === 0) {
+        throw new Error('Usage: bin/m wallet:keccak <string>');
+    }
+    const input = args.join(' ');
+    const { keccak256, toHex } = await import('viem');
+    const hash = keccak256(toHex(input));
+    console.log(hash);
+}
+// ==================== USAGE ====================
+function usage(command) {
+    if (command === 'send') {
+        console.log('Usage: bin/m wallet:send --name <n> --to <addr|name> [--amount <eth>] [--token <addr>] [--function "name(type,...)"] [--args "v1,v2"] [--data 0x...] [--network celoSepolia] [--rpc <url>]');
+        return;
+    }
+    if (command === 'generate') {
+        console.log('Usage: bin/m wallet:generate --name <n> [--index 0] [--output-env <VAR>]');
+        return;
+    }
+    if (command === 'approve') {
+        console.log('Usage: bin/m wallet:approve --name <n> --token <addr> --spender <addr|name> --amount <u> [--network celoSepolia] [--rpc <url>]');
+        return;
+    }
+    if (command === 'list') {
+        console.log('Usage: bin/m wallet:list [--name <n>] [--address-only] [--balance] [--network celoSepolia] [--rpc <url>]');
+        return;
+    }
+    if (command === 'import') {
+        console.log('Usage: bin/m wallet:import --name <n> [--mnemonic "..."] [--private-key 0x...] [--index 0]');
+        return;
+    }
+    if (command === 'balance') {
+        console.log('Usage: bin/m wallet:balance --name <n> [--token <addr>] [--network celoSepolia] [--rpc <url>]');
+        return;
+    }
+    if (command === 'sign') {
+        console.log('Usage: bin/m wallet:sign --name <n> --tx <json-file>');
+        return;
+    }
+    if (command === 'broadcast') {
+        console.log('Usage: bin/m wallet:broadcast --signed-tx <json> [--rpc <url>]');
+        return;
+    }
+    if (command === 'keccak') {
+        console.log('Usage: bin/m wallet:keccak <string>');
+        return;
+    }
+    if (command === 'call') {
+        console.log('Usage: bin/m wallet:call --name <n> --to <addr> --function "name(type,...)" [--args "v1,v2"] [--network celoSepolia] [--rpc <url>]');
+        return;
+    }
+    console.log('Wallet commands:');
+    console.log('  bin/m wallet:generate --name <n> [--index 0] [--output-env <VAR>]');
+    console.log('  bin/m wallet:approve  --name <n> --token <addr> --spender <addr|name> --amount <u> [--network celoSepolia] [--rpc <url>]');
+    console.log('  bin/m wallet:list     [--name <n>] [--address-only] [--balance]');
+    console.log('  bin/m wallet:import   --name <n> [--mnemonic "..."] [--private-key 0x...] [--index 0]');
+    console.log('  bin/m wallet:send     --name <n> --to <addr|name> [--amount <eth>] [--token <addr>] [--function "name(type,...)"] [--args "v1,v2"] [--data 0x...]');
+    console.log('  bin/m wallet:balance  --name <n> [--token <addr>]');
+    console.log('  bin/m wallet:sign     --name <n> --tx <json-file>');
+    console.log('  bin/m wallet:broadcast --signed-tx <json> [--rpc <url>]');
+    console.log('  bin/m wallet:keccak   <string>');
+    console.log('  bin/m wallet:call     --name <n> --to <addr> --function "name(type,...)" [--args "v1,v2"]');
+}
+// ==================== ENTRY POINT ====================
+export async function runWallet(args) {
+    if (args.length === 0) {
+        usage();
+        return;
+    }
+    // Per-command help: wallet:send --help
+    if (args.length >= 2 && (args[1] === '--help' || args[1] === '-h')) {
+        usage(args[0]);
+        return;
+    }
+    // Generic help: wallet --help or wallet:send --help (when command is --help directly)
+    if (args.includes('--help') || args.includes('-h')) {
+        usage();
+        return;
+    }
+    const command = args[0];
+    const rest = args.slice(1);
+    try {
+        switch (command) {
+            case 'generate':
+                await cmdGenerate(rest);
+                break;
+            case 'approve':
+                await cmdApprove(rest);
+                break;
+            case 'list':
+                await cmdList(rest);
+                break;
+            case 'import':
+                await cmdImport(rest);
+                break;
+            case 'send':
+                await cmdSend(rest);
+                break;
+            case 'balance':
+                await cmdBalance(rest);
+                break;
+            case 'call':
+                await cmdCall(rest);
+                break;
+            case 'derive':
+                await cmdDerive(rest);
+                break;
+            case 'sign':
+                await cmdSign(rest);
+                break;
+            case 'broadcast':
+                await cmdBroadcast(rest);
+                break;
+            case 'keccak':
+                await cmdKeccak(rest);
+                break;
+            default:
+                problem(t('wallet.unknown', command));
+                usage();
+                throw new Error(t('wallet.unknown', command));
+        }
+    }
+    catch (err) {
+        problem(err.message || String(err));
+        throw err;
+    }
+}