httpcat-cli 0.3.0 → 0.3.1

package/dist/commands/tools/index.js

@@ -0,0 +1,2040 @@
+import { Command } from "commander";
+import { HttpcatClient } from "../../client.js";
+import { config } from "../../config.js";
+import chalk from "chalk";
+import { printBox, formatAddress, formatTokenAmount } from "../../utils/formatting.js";
+import { withLoading } from "../../utils/loading.js";
+import { outputJson, outputError } from "../../headless/json-output.js";
+import { handleError, getExitCode } from "../../utils/errors.js";
+import { promptForPrivateKey } from "../../utils/privateKeyPrompt.js";
+import { callX402Endpoint, displayCallResult } from "../call.js";
+// ============================================================================
+// Shared Utilities
+// ============================================================================
+function getPrivateKey(cliPrivateKey, accountIndex) {
+    if (cliPrivateKey)
+        return cliPrivateKey;
+    const envKey = process.env.HTTPCAT_PRIVATE_KEY;
+    if (envKey)
+        return envKey;
+    try {
+        const index = accountIndex !== undefined
+            ? accountIndex
+            : config.getActiveAccountIndex();
+        return config.getAccountPrivateKey(index);
+    }
+    catch (error) {
+        return config.get("privateKey");
+    }
+}
+function isConfigured(cliPrivateKey) {
+    if (cliPrivateKey)
+        return true;
+    return config.isConfigured();
+}
+async function ensureWalletUnlocked() {
+    const password = config.getPassword();
+    if (!password) {
+        config.ensureSessionValid();
+        return;
+    }
+    if (!config.isSessionValid()) {
+        const inquirer = (await import("inquirer")).default;
+        const answers = await inquirer.prompt([
+            {
+                type: "password",
+                name: "password",
+                message: "Enter password to unlock wallet:",
+                mask: "•",
+            },
+        ]);
+        await config.unlockSession(answers.password);
+    }
+}
+// ============================================================================
+// Tools Command Group
+// ============================================================================
+export function createToolsCommand() {
+    const toolsCommand = new Command("tools")
+        .description("EVM development & interaction tools")
+        .addHelpText("after", `
+Examples:
+  httpcat tools address validate 0x...
+  httpcat tools abi encode <abi> transfer <args>
+  httpcat tools tx build <tx-json>
+  httpcat tools signature eip712 <domain> <types> <message>
+    `);
+    // ============================================================================
+    // Address Utilities
+    // ============================================================================
+    const addressCommand = toolsCommand
+        .command("address")
+        .description("Address utilities");
+    addressCommand
+        .command("validate")
+        .description("Validate Ethereum address format ($0.001)")
+        .argument("<address>", "Address to validate")
+        .action(async (address, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/address/validate", {
+                    address,
+                });
+                return data;
+            }, {
+                message: "Validating address...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("address_validate", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("✅ Address Validation"));
+                console.log();
+                const boxData = {
+                    Address: chalk.cyan(address),
+                    Valid: result.valid
+                        ? chalk.green.bold("Yes")
+                        : chalk.red.bold("No"),
+                };
+                if (result.checksummed) {
+                    boxData["Checksummed"] = chalk.yellow(result.checksummed);
+                }
+                printBox("Validation Result", boxData);
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("address_validate", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    addressCommand
+        .command("checksum")
+        .description("Convert address to EIP-55 checksum format ($0.001)")
+        .argument("<address>", "Address to checksum")
+        .action(async (address, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/address/checksum", {
+                    address,
+                });
+                return data;
+            }, {
+                message: "Converting to checksum...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("address_checksum", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔤 Address Checksum"));
+                console.log();
+                printBox("Checksum Result", {
+                    Original: chalk.dim(result.original),
+                    Checksummed: chalk.green.bold(result.address),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("address_checksum", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    addressCommand
+        .command("derive")
+        .description("Derive address from private key ($0.001)")
+        .argument("<privateKey>", "Private key (0x-prefixed hex)")
+        .action(async (privateKey, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let pk = getPrivateKey(globalOpts.privateKey, accountIndex) || privateKey;
+            if (!isConfigured(globalOpts.privateKey) && !privateKey) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                pk = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(pk);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/address/derive", {
+                    privateKey: pk,
+                });
+                return data;
+            }, {
+                message: "Deriving address...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("address_derive", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔑 Address Derivation"));
+                console.log();
+                printBox("Derived Address", {
+                    Address: chalk.green.bold(result.address),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("address_derive", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    addressCommand
+        .command("balance")
+        .description("Get address balance (ETH + tokens) ($0.001)")
+        .argument("<address>", "Address (0x format)")
+        .option("--tokens <tokens>", "Comma-separated token addresses")
+        .action(async (address, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = { address };
+            if (options.tokens) {
+                input.tokens = options.tokens.split(",").map((t) => t.trim());
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/address/balance", input);
+                return data;
+            }, {
+                message: "Fetching balance...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("address_balance", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("💰 Address Balance"));
+                console.log();
+                const boxData = {
+                    Address: chalk.cyan(address),
+                    "ETH Balance": chalk.green.bold(result.ethBalanceFormatted || formatTokenAmount(result.ethBalance)),
+                };
+                printBox("Balance", boxData);
+                if (result.tokens && result.tokens.length > 0) {
+                    console.log();
+                    console.log(chalk.cyan.bold("Token Balances:"));
+                    for (const token of result.tokens) {
+                        console.log(`  ${formatAddress(token.address, 10)}: ${chalk.green(token.balanceFormatted || formatTokenAmount(token.balance))}`);
+                    }
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("address_balance", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // ABI Utilities
+    // ============================================================================
+    const abiCommand = toolsCommand
+        .command("abi")
+        .description("ABI encoding/decoding utilities");
+    abiCommand
+        .command("encode")
+        .description("Encode function call from ABI and arguments ($0.001)")
+        .requiredOption("--abi <abi>", "ABI JSON (as string or file path)")
+        .requiredOption("--function <name>", "Function name")
+        .requiredOption("--args <args>", "Arguments as JSON array")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse ABI (could be file path or JSON string)
+            let abi;
+            try {
+                abi = JSON.parse(options.abi);
+            }
+            catch {
+                // Try as file path
+                const fs = await import("fs");
+                if (fs.existsSync(options.abi)) {
+                    abi = JSON.parse(fs.readFileSync(options.abi, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid ABI: must be JSON string or file path");
+                }
+            }
+            // Parse args
+            let args;
+            try {
+                args = JSON.parse(options.args);
+            }
+            catch {
+                throw new Error("Invalid args: must be JSON array");
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/abi/encode", {
+                    abi,
+                    functionName: options.function,
+                    args,
+                });
+                return data;
+            }, {
+                message: "Encoding function call...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("abi_encode", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📝 ABI Encode"));
+                console.log();
+                printBox("Encoded Data", {
+                    Data: chalk.green.bold(result.data),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("abi_encode", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    abiCommand
+        .command("decode")
+        .description("Decode function result or event log ($0.001)")
+        .requiredOption("--abi <abi>", "ABI JSON (as string or file path)")
+        .requiredOption("--data <data>", "Data to decode (0x-prefixed hex)")
+        .requiredOption("--type <type>", "Type: function or event")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse ABI
+            let abi;
+            try {
+                abi = JSON.parse(options.abi);
+            }
+            catch {
+                const fs = await import("fs");
+                if (fs.existsSync(options.abi)) {
+                    abi = JSON.parse(fs.readFileSync(options.abi, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid ABI: must be JSON string or file path");
+                }
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/abi/decode", {
+                    abi,
+                    data: options.data,
+                    type: options.type,
+                });
+                return data;
+            }, {
+                message: "Decoding data...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("abi_decode", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔍 ABI Decode"));
+                console.log();
+                console.log(chalk.cyan("Decoded:"));
+                console.log(JSON.stringify(result.decoded, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("abi_decode", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    abiCommand
+        .command("parse")
+        .description("Parse ABI JSON and return structured format ($0.001)")
+        .requiredOption("--abi <abi>", "ABI JSON (as string or file path)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse ABI
+            let abi;
+            try {
+                abi = JSON.parse(options.abi);
+            }
+            catch {
+                const fs = await import("fs");
+                if (fs.existsSync(options.abi)) {
+                    abi = JSON.parse(fs.readFileSync(options.abi, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid ABI: must be JSON string or file path");
+                }
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/abi/parse", { abi });
+                return data;
+            }, {
+                message: "Parsing ABI...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("abi_parse", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📋 ABI Parse"));
+                console.log();
+                const boxData = {
+                    Functions: chalk.cyan((result.functions?.length || 0).toString()),
+                    Events: chalk.cyan((result.events?.length || 0).toString()),
+                    Errors: chalk.cyan((result.errors?.length || 0).toString()),
+                };
+                printBox("ABI Structure", boxData);
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("abi_parse", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // Transaction Building
+    // ============================================================================
+    const txCommand = toolsCommand
+        .command("tx")
+        .description("Transaction utilities");
+    txCommand
+        .command("build")
+        .description("Build complete transaction with auto-filled fields ($0.001)")
+        .requiredOption("--to <address>", "To address (0x format)")
+        .option("--data <data>", "Transaction data (0x-prefixed hex)")
+        .option("--value <value>", "Value in wei")
+        .option("--from <address>", "From address (0x format)")
+        .option("--gas-limit <gas>", "Gas limit")
+        .option("--gas-price <price>", "Gas price in wei")
+        .option("--nonce <nonce>", "Nonce")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = { to: options.to };
+            if (options.data)
+                input.data = options.data;
+            if (options.value)
+                input.value = options.value;
+            if (options.from)
+                input.from = options.from;
+            if (options.gasLimit)
+                input.gasLimit = options.gasLimit;
+            if (options.gasPrice)
+                input.gasPrice = options.gasPrice;
+            if (options.nonce)
+                input.nonce = parseInt(options.nonce);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/tx/build", input);
+                return data;
+            }, {
+                message: "Building transaction...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("tx_build", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔨 Transaction Build"));
+                console.log();
+                console.log(JSON.stringify(result.transaction, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("tx_build", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    txCommand
+        .command("encode")
+        .description("Encode transaction to RLP format ($0.001)")
+        .requiredOption("--tx <tx>", "Transaction JSON (as string or file path)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse transaction
+            let transaction;
+            try {
+                transaction = JSON.parse(options.tx);
+            }
+            catch {
+                const fs = await import("fs");
+                if (fs.existsSync(options.tx)) {
+                    transaction = JSON.parse(fs.readFileSync(options.tx, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid transaction: must be JSON string or file path");
+                }
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/tx/encode", {
+                    transaction,
+                });
+                return data;
+            }, {
+                message: "Encoding transaction...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("tx_encode", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📦 Transaction Encode"));
+                console.log();
+                printBox("RLP Encoded", {
+                    RLP: chalk.green.bold(result.rlp),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("tx_encode", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    txCommand
+        .command("decode")
+        .description("Decode RLP transaction ($0.001)")
+        .requiredOption("--rlp <rlp>", "RLP-encoded transaction (0x-prefixed hex)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/tx/decode", {
+                    rlp: options.rlp,
+                });
+                return data;
+            }, {
+                message: "Decoding transaction...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("tx_decode", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔍 Transaction Decode"));
+                console.log();
+                console.log(JSON.stringify(result.transaction, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("tx_decode", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    txCommand
+        .command("simulate")
+        .description("Enhanced transaction simulation with state analysis ($0.001)")
+        .requiredOption("--to <address>", "To address (0x format)")
+        .requiredOption("--data <data>", "Transaction data (0x-prefixed hex)")
+        .requiredOption("--value <value>", "Value in wei")
+        .option("--from <address>", "From address (0x format)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = {
+                transaction: {
+                    to: options.to,
+                    data: options.data,
+                    value: options.value,
+                },
+            };
+            if (options.from)
+                input.from = options.from;
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/tx/simulate", input);
+                return data;
+            }, {
+                message: "Simulating transaction...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("tx_simulate", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🎮 Transaction Simulation"));
+                console.log();
+                const boxData = {
+                    Success: result.success
+                        ? chalk.green.bold("Yes")
+                        : chalk.red.bold("No"),
+                    "Gas Used": chalk.cyan(result.gasUsed || "N/A"),
+                };
+                printBox("Simulation Result", boxData);
+                if (result.logs && result.logs.length > 0) {
+                    console.log();
+                    console.log(chalk.cyan(`Logs (${result.logs.length}):`));
+                    console.log(JSON.stringify(result.logs, null, 2));
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("tx_simulate", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    txCommand
+        .command("estimate-gas")
+        .description("Estimate gas for transaction ($0.001)")
+        .requiredOption("--to <address>", "To address (0x format)")
+        .requiredOption("--data <data>", "Transaction data (0x-prefixed hex)")
+        .requiredOption("--value <value>", "Value in wei")
+        .option("--from <address>", "From address (0x format)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = {
+                transaction: {
+                    to: options.to,
+                    data: options.data,
+                    value: options.value,
+                },
+            };
+            if (options.from)
+                input.from = options.from;
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/tx/estimate-gas", input);
+                return data;
+            }, {
+                message: "Estimating gas...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("tx_estimate_gas", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("⛽ Gas Estimation"));
+                console.log();
+                printBox("Gas Estimate", {
+                    "Gas Estimate": chalk.green.bold(result.gasEstimate),
+                    "Gas Limit": chalk.yellow(result.gasLimit || result.gasEstimate),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("tx_estimate_gas", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    txCommand
+        .command("prepare")
+        .description("Prepare transaction for signing ($0.001)")
+        .requiredOption("--to <address>", "To address (0x format)")
+        .requiredOption("--from <address>", "From address (0x format)")
+        .option("--data <data>", "Transaction data (0x-prefixed hex)")
+        .option("--value <value>", "Value in wei")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = {
+                to: options.to,
+                from: options.from,
+            };
+            if (options.data)
+                input.data = options.data;
+            if (options.value)
+                input.value = options.value;
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/tx/prepare", input);
+                return data;
+            }, {
+                message: "Preparing transaction...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("tx_prepare", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("✍️  Transaction Prepare"));
+                console.log();
+                console.log(JSON.stringify(result.transaction, null, 2));
+                if (result.messageHash) {
+                    console.log();
+                    console.log(chalk.cyan("Message Hash:") + " " + chalk.yellow(result.messageHash));
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("tx_prepare", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // Signature Helpers
+    // ============================================================================
+    const signatureCommand = toolsCommand
+        .command("signature")
+        .description("Signature utilities");
+    signatureCommand
+        .command("eip191")
+        .description("Prepare EIP-191 personal sign message ($0.001)")
+        .requiredOption("--message <message>", "Message to sign")
+        .option("--address <address>", "Address for verification")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = { message: options.message };
+            if (options.address)
+                input.address = options.address;
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/signature/eip191", input);
+                return data;
+            }, {
+                message: "Preparing EIP-191 signature...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("signature_eip191", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("✍️  EIP-191 Signature"));
+                console.log();
+                printBox("Signature Data", {
+                    Message: chalk.cyan(result.message),
+                    "Message Hash": chalk.green.bold(result.messageHash),
+                    Signature: result.signature
+                        ? chalk.yellow(result.signature)
+                        : chalk.dim("Not signed"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("signature_eip191", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    signatureCommand
+        .command("eip712")
+        .description("Prepare EIP-712 structured data signature ($0.001)")
+        .requiredOption("--domain <domain>", "Domain JSON (as string or file path)")
+        .requiredOption("--types <types>", "Types JSON (as string or file path)")
+        .requiredOption("--message <message>", "Message JSON (as string or file path)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse JSON inputs
+            const parseJson = (str) => {
+                try {
+                    return JSON.parse(str);
+                }
+                catch {
+                    const fs = require("fs");
+                    if (fs.existsSync(str)) {
+                        return JSON.parse(fs.readFileSync(str, "utf-8"));
+                    }
+                    throw new Error(`Invalid JSON: ${str}`);
+                }
+            };
+            const domain = parseJson(options.domain);
+            const types = parseJson(options.types);
+            const message = parseJson(options.message);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/signature/eip712", {
+                    domain,
+                    types,
+                    message,
+                });
+                return data;
+            }, {
+                message: "Preparing EIP-712 signature...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("signature_eip712", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("✍️  EIP-712 Signature"));
+                console.log();
+                printBox("Signature Data", {
+                    "Message Hash": chalk.green.bold(result.messageHash),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("signature_eip712", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    signatureCommand
+        .command("permit2")
+        .description("Prepare Permit2 signature message ($0.001)")
+        .requiredOption("--token <address>", "Token address (0x format)")
+        .requiredOption("--amount <amount>", "Amount in wei")
+        .requiredOption("--spender <address>", "Spender address (0x format)")
+        .requiredOption("--nonce <nonce>", "Nonce")
+        .requiredOption("--deadline <deadline>", "Deadline (Unix timestamp)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/signature/permit2", {
+                    token: options.token,
+                    amount: options.amount,
+                    spender: options.spender,
+                    nonce: parseInt(options.nonce),
+                    deadline: parseInt(options.deadline),
+                });
+                return data;
+            }, {
+                message: "Preparing Permit2 signature...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("signature_permit2", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("✍️  Permit2 Signature"));
+                console.log();
+                printBox("Signature Data", {
+                    "Message Hash": chalk.green.bold(result.messageHash),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("signature_permit2", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // Multicall Operations
+    // ============================================================================
+    const multicallCommand = toolsCommand
+        .command("multicall")
+        .description("Multicall operations");
+    multicallCommand
+        .command("encode")
+        .description("Encode multicall operation ($0.001)")
+        .requiredOption("--calls <calls>", "Calls JSON array (as string or file path)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse calls
+            let calls;
+            try {
+                calls = JSON.parse(options.calls);
+            }
+            catch {
+                const fs = await import("fs");
+                if (fs.existsSync(options.calls)) {
+                    calls = JSON.parse(fs.readFileSync(options.calls, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid calls: must be JSON array string or file path");
+                }
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/multicall/encode", {
+                    calls,
+                });
+                return data;
+            }, {
+                message: "Encoding multicall...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("multicall_encode", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📦 Multicall Encode"));
+                console.log();
+                printBox("Encoded Data", {
+                    Data: chalk.green.bold(result.data),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("multicall_encode", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    multicallCommand
+        .command("decode")
+        .description("Decode multicall results ($0.001)")
+        .requiredOption("--data <data>", "Multicall result data (0x-prefixed hex)")
+        .requiredOption("--calls <calls>", "Original calls JSON array (as string or file path)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse calls
+            let calls;
+            try {
+                calls = JSON.parse(options.calls);
+            }
+            catch {
+                const fs = await import("fs");
+                if (fs.existsSync(options.calls)) {
+                    calls = JSON.parse(fs.readFileSync(options.calls, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid calls: must be JSON array string or file path");
+                }
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/multicall/decode", {
+                    data: options.data,
+                    calls,
+                });
+                return data;
+            }, {
+                message: "Decoding multicall results...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("multicall_decode", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔍 Multicall Decode"));
+                console.log();
+                console.log(JSON.stringify(result.results, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("multicall_decode", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // Nonce Management
+    // ============================================================================
+    const nonceCommand = toolsCommand
+        .command("nonce")
+        .description("Nonce management");
+    nonceCommand
+        .command("get")
+        .description("Get current nonce for address ($0.001)")
+        .argument("<address>", "Address (0x format)")
+        .action(async (address, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/nonce/get", { address });
+                return data;
+            }, {
+                message: "Fetching nonce...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("nonce_get", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔢 Nonce"));
+                console.log();
+                printBox("Nonce Info", {
+                    Address: chalk.cyan(address),
+                    "Current Nonce": chalk.green.bold(result.nonce?.toString() || "N/A"),
+                    "Pending Nonce": chalk.yellow(result.pendingNonce?.toString() || "N/A"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("nonce_get", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    nonceCommand
+        .command("predict")
+        .description("Predict next nonce accounting for pending transactions ($0.001)")
+        .argument("<address>", "Address (0x format)")
+        .action(async (address, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/nonce/predict", {
+                    address,
+                });
+                return data;
+            }, {
+                message: "Predicting nonce...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("nonce_predict", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔮 Nonce Prediction"));
+                console.log();
+                printBox("Nonce Prediction", {
+                    Address: chalk.cyan(address),
+                    "Current Nonce": chalk.green(result.currentNonce?.toString() || "N/A"),
+                    "Pending Count": chalk.yellow(result.pendingCount?.toString() || "0"),
+                    "Predicted Nonce": chalk.green.bold(result.predictedNonce?.toString() || "N/A"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("nonce_predict", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // Gas Utilities
+    // ============================================================================
+    const gasCommand = toolsCommand
+        .command("gas")
+        .description("Gas utilities");
+    gasCommand
+        .command("price")
+        .description("Get current gas price ($0.001)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/gas/price", {});
+                return data;
+            }, {
+                message: "Fetching gas price...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("gas_price", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("⛽ Gas Price"));
+                console.log();
+                printBox("Gas Prices", {
+                    "Gas Price": chalk.green(result.gasPrice || "N/A"),
+                    "Max Fee Per Gas": chalk.yellow(result.maxFeePerGas || "N/A"),
+                    "Max Priority Fee Per Gas": chalk.cyan(result.maxPriorityFeePerGas || "N/A"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("gas_price", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    gasCommand
+        .command("estimate")
+        .description("Estimate gas for operation ($0.001)")
+        .requiredOption("--to <address>", "To address (0x format)")
+        .requiredOption("--data <data>", "Transaction data (0x-prefixed hex)")
+        .requiredOption("--value <value>", "Value in wei")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/gas/estimate", {
+                    transaction: {
+                        to: options.to,
+                        data: options.data,
+                        value: options.value,
+                    },
+                });
+                return data;
+            }, {
+                message: "Estimating gas...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("gas_estimate", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("⛽ Gas Estimate"));
+                console.log();
+                printBox("Gas Estimate", {
+                    "Gas Estimate": chalk.green.bold(result.gasEstimate),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("gas_estimate", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    gasCommand
+        .command("optimize")
+        .description("Optimize gas settings for transaction ($0.001)")
+        .requiredOption("--to <address>", "To address (0x format)")
+        .requiredOption("--data <data>", "Transaction data (0x-prefixed hex)")
+        .requiredOption("--value <value>", "Value in wei")
+        .option("--priority <priority>", "Priority: low, medium, high", "medium")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const input = {
+                transaction: {
+                    to: options.to,
+                    data: options.data,
+                    value: options.value,
+                },
+            };
+            if (options.priority)
+                input.priority = options.priority;
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/gas/optimize", input);
+                return data;
+            }, {
+                message: "Optimizing gas settings...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("gas_optimize", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("⚡ Gas Optimization"));
+                console.log();
+                printBox("Optimized Gas", {
+                    "Gas Price": chalk.green(result.gasPrice || "N/A"),
+                    "Max Fee Per Gas": chalk.yellow(result.maxFeePerGas || "N/A"),
+                    "Max Priority Fee Per Gas": chalk.cyan(result.maxPriorityFeePerGas || "N/A"),
+                    "Estimated Cost": chalk.magenta(result.estimatedCost || "N/A"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("gas_optimize", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // Key Utilities
+    // ============================================================================
+    const keyCommand = toolsCommand
+        .command("key")
+        .description("Key utilities");
+    keyCommand
+        .command("derive")
+        .description("Derive address from private key ($0.001)")
+        .argument("<privateKey>", "Private key (0x-prefixed hex)")
+        .action(async (privateKey, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let pk = getPrivateKey(globalOpts.privateKey, accountIndex) || privateKey;
+            if (!isConfigured(globalOpts.privateKey) && !privateKey) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                pk = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(pk);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/key/derive", {
+                    privateKey: pk,
+                });
+                return data;
+            }, {
+                message: "Deriving address...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("key_derive", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🔑 Key Derivation"));
+                console.log();
+                printBox("Derived Address", {
+                    Address: chalk.green.bold(result.address),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("key_derive", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    keyCommand
+        .command("validate")
+        .description("Validate private key format ($0.001)")
+        .argument("<privateKey>", "Private key")
+        .action(async (privateKey, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKeyToUse = getPrivateKey(globalOpts.privateKey, accountIndex) || privateKey;
+            if (!isConfigured(globalOpts.privateKey) && !privateKey) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKeyToUse = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKeyToUse);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/key/validate", {
+                    privateKey: privateKeyToUse,
+                });
+                return data;
+            }, {
+                message: "Validating private key...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("key_validate", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("✅ Key Validation"));
+                console.log();
+                printBox("Validation Result", {
+                    Valid: result.valid
+                        ? chalk.green.bold("Yes")
+                        : chalk.red.bold("No"),
+                    Format: result.format ? chalk.cyan(result.format) : chalk.dim("N/A"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("key_validate", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // RPC Utilities
+    // ============================================================================
+    const rpcCommand = toolsCommand
+        .command("rpc")
+        .description("RPC utilities");
+    rpcCommand
+        .command("proxy")
+        .description("Enhanced JSON-RPC proxy ($0.001)")
+        .requiredOption("--method <method>", "RPC method (e.g., 'eth_getBalance')")
+        .requiredOption("--params <params>", "Params as JSON array")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse params
+            let params;
+            try {
+                params = JSON.parse(options.params);
+            }
+            catch {
+                throw new Error("Invalid params: must be JSON array");
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/rpc/proxy", {
+                    method: options.method,
+                    params,
+                });
+                return data;
+            }, {
+                message: "Calling RPC...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("rpc_proxy", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🌐 RPC Proxy"));
+                console.log();
+                console.log(JSON.stringify(result, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("rpc_proxy", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    rpcCommand
+        .command("batch")
+        .description("Batch multiple RPC calls ($0.001)")
+        .requiredOption("--requests <requests>", "Requests JSON array (as string or file path)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse requests
+            let requests;
+            try {
+                requests = JSON.parse(options.requests);
+            }
+            catch {
+                const fs = await import("fs");
+                if (fs.existsSync(options.requests)) {
+                    requests = JSON.parse(fs.readFileSync(options.requests, "utf-8"));
+                }
+                else {
+                    throw new Error("Invalid requests: must be JSON array string or file path");
+                }
+            }
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/rpc/batch", {
+                    requests,
+                });
+                return data;
+            }, {
+                message: "Batching RPC calls...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("rpc_batch", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📦 RPC Batch"));
+                console.log();
+                console.log(JSON.stringify(result.results, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("rpc_batch", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    rpcCommand
+        .command("health")
+        .description("Check RPC endpoint health ($0.001)")
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("tools/rpc/health", {});
+                return data;
+            }, {
+                message: "Checking RPC health...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("rpc_health", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("🏥 RPC Health"));
+                console.log();
+                printBox("Health Status", {
+                    Healthy: result.healthy
+                        ? chalk.green.bold("Yes")
+                        : chalk.red.bold("No"),
+                    Latency: result.latency
+                        ? chalk.cyan(`${result.latency}ms`)
+                        : "N/A",
+                    "Chain ID": result.chainId
+                        ? chalk.yellow(result.chainId.toString())
+                        : "N/A",
+                    "Block Number": result.blockNumber
+                        ? chalk.cyan(result.blockNumber.toString())
+                        : "N/A",
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("rpc_health", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // x402 Endpoint Call
+    // ============================================================================
+    toolsCommand
+        .command("call")
+        .description("Call an arbitrary x402-protected HTTP endpoint with automatic payment handling")
+        .argument("<url>", "The x402 endpoint URL")
+        .option("-m, --method <method>", "HTTP method (GET, POST, PUT, DELETE, PATCH)", "POST")
+        .option("-b, --body <body>", "Request body as JSON string (or '-' to read from stdin)")
+        .option("-H, --header <header>", "Additional HTTP headers (format: 'Key: Value')", (val, prev) => {
+        const headers = prev || [];
+        headers.push(val);
+        return headers;
+    })
+        .addHelpText("after", `
+Examples:
+  httpcat tools call https://example.com/api/endpoint --method POST --body '{"key": "value"}'
+  httpcat tools call https://example.com/api/endpoint --method GET
+  echo '{"data": "test"}' | httpcat tools call https://example.com/api/endpoint --body -
+  httpcat tools call https://example.com/api/endpoint --header "X-Custom-Header: value" --header "Authorization: Bearer token"
+    `)
+        .action(async (url, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            // Ensure wallet is unlocked
+            await ensureWalletUnlocked();
+            let privateKey = getPrivateKey(globalOpts.privateKey, accountIndex);
+            // If not configured and not in JSON mode, prompt interactively
+            if (!isConfigured(globalOpts.privateKey)) {
+                if (globalOpts.json) {
+                    console.error('❌ Not configured. Run "httpcat config" first or use --private-key flag.');
+                    process.exit(2);
+                }
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Parse body
+            let body = undefined;
+            if (options.body !== undefined) {
+                if (options.body === "-") {
+                    // Read from stdin
+                    const { readFileSync } = await import("fs");
+                    const stdin = readFileSync(0, "utf-8").trim();
+                    if (stdin) {
+                        try {
+                            body = JSON.parse(stdin);
+                        }
+                        catch {
+                            body = stdin;
+                        }
+                    }
+                }
+                else {
+                    try {
+                        body = JSON.parse(options.body);
+                    }
+                    catch {
+                        body = options.body;
+                    }
+                }
+            }
+            // Parse headers
+            const headers = {};
+            if (options.header && Array.isArray(options.header)) {
+                for (const header of options.header) {
+                    const colonIndex = header.indexOf(":");
+                    if (colonIndex === -1) {
+                        throw new Error(`Invalid header format: ${header}. Expected format: "Key: Value"`);
+                    }
+                    const key = header.substring(0, colonIndex).trim();
+                    const value = header.substring(colonIndex + 1).trim();
+                    headers[key] = value;
+                }
+            }
+            else if (options.header) {
+                // Single header
+                const colonIndex = options.header.indexOf(":");
+                if (colonIndex === -1) {
+                    throw new Error(`Invalid header format: ${options.header}. Expected format: "Key: Value"`);
+                }
+                const key = options.header.substring(0, colonIndex).trim();
+                const value = options.header.substring(colonIndex + 1).trim();
+                headers[key] = value;
+            }
+            const result = await withLoading(() => callX402Endpoint(client, url, {
+                method: options.method,
+                body,
+                headers,
+            }), {
+                message: "Calling x402 endpoint...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("call", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayCallResult(result);
+            }
+            // Exit with non-zero code if status is error
+            process.exit(result.status >= 400 ? 1 : 0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("call", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    return toolsCommand;
+}
+//# sourceMappingURL=index.js.map