httpcat-cli 0.3.0 → 0.3.1

package/dist/commands/market.js

@@ -0,0 +1,960 @@
+import { Command } from "commander";
+import { HttpcatClient } from "../client.js";
+import { config } from "../config.js";
+import chalk from "chalk";
+import { printBox, formatAddress, formatCurrency, formatTokenAmount, createTable } 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";
+// ============================================================================
+// 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);
+    }
+}
+// ============================================================================
+// Market Intelligence Command Group
+// ============================================================================
+export function createMarketCommand() {
+    const marketCommand = new Command("market")
+        .description("Market intelligence & token analysis")
+        .addHelpText("after", `
+Examples:
+  httpcat market price <token>
+  httpcat market ohlc <token> --interval 1h
+  httpcat market liquidity <token>
+  httpcat market price-impact <token> <amount> <side>
+  httpcat market search bitcoin
+  httpcat market coin-data bitcoin --sparkline
+  httpcat market chart bitcoin 7
+    `);
+    marketCommand
+        .command("price")
+        .description("Get token price data ($0.001)")
+        .argument("<tokenIdentifier>", "Token identifier (address, symbol, or name)")
+        .option("--timeframe <timeframe>", "Timeframe: 1h, 24h, 7d, 30d")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({ tokenIdentifier });
+            if (options.timeframe)
+                params.append("timeframe", options.timeframe);
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/market/price?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("market/price", {
+                        tokenIdentifier,
+                        timeframe: options.timeframe,
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching price data...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_price", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("💰 Token Price"));
+                console.log();
+                const boxData = {
+                    Token: chalk.cyan(tokenIdentifier),
+                    Price: chalk.green.bold(formatCurrency(result.price || "0")),
+                };
+                if (result.priceChange24h !== undefined) {
+                    const change24h = parseFloat(result.priceChange24h.toString());
+                    const changeColor = change24h >= 0 ? chalk.green : chalk.red;
+                    boxData["24h Change"] = changeColor(`${change24h >= 0 ? "+" : ""}${change24h.toFixed(2)}%`);
+                }
+                if (result.priceChange7d !== undefined) {
+                    const change7d = parseFloat(result.priceChange7d.toString());
+                    const changeColor = change7d >= 0 ? chalk.green : chalk.red;
+                    boxData["7d Change"] = changeColor(`${change7d >= 0 ? "+" : ""}${change7d.toFixed(2)}%`);
+                }
+                printBox("Price Data", boxData);
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_price", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("ohlc")
+        .description("Get OHLC (Open, High, Low, Close) candle data ($0.01)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .option("--interval <interval>", "Interval: 1m, 5m, 15m, 1h, 4h, 1d", "1h")
+        .option("--limit <limit>", "Limit results", "100")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({
+                tokenIdentifier,
+                interval: options.interval || "1h",
+                limit: options.limit || "100",
+            });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/market/ohlc?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("market/ohlc", {
+                        tokenIdentifier,
+                        interval: options.interval || "1h",
+                        limit: parseInt(options.limit || "100"),
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching OHLC data...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_ohlc", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold(`📊 OHLC Data (${result.candles?.length || 0} candles)`));
+                console.log();
+                if (result.candles && result.candles.length > 0) {
+                    const table = createTable({
+                        head: ["Time", "Open", "High", "Low", "Close", "Volume"],
+                        colWidths: [20, 15, 15, 15, 15, 20],
+                    });
+                    for (const candle of result.candles.slice(0, 20)) {
+                        table.push([
+                            new Date(candle.timestamp).toLocaleString(),
+                            formatCurrency(candle.open),
+                            chalk.green(formatCurrency(candle.high)),
+                            chalk.red(formatCurrency(candle.low)),
+                            formatCurrency(candle.close),
+                            formatTokenAmount(candle.volume),
+                        ]);
+                    }
+                    console.log(table.toString());
+                    if (result.candles.length > 20) {
+                        console.log(chalk.dim(`... and ${result.candles.length - 20} more candles`));
+                    }
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_ohlc", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("liquidity")
+        .description("Get liquidity depth ($0.01)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .option("--depth <depth>", "Depth level", "10")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({
+                tokenIdentifier,
+                depth: options.depth || "10",
+            });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/market/liquidity?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("market/liquidity", {
+                        tokenIdentifier,
+                        depth: parseInt(options.depth || "10"),
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching liquidity data...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_liquidity", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("💧 Liquidity Depth"));
+                console.log();
+                if (result.bids && result.bids.length > 0) {
+                    console.log(chalk.green.bold("Bids:"));
+                    const bidsTable = createTable({
+                        head: ["Price", "Amount"],
+                        colWidths: [20, 20],
+                    });
+                    for (const bid of result.bids.slice(0, 10)) {
+                        bidsTable.push([formatCurrency(bid.price), formatTokenAmount(bid.amount)]);
+                    }
+                    console.log(bidsTable.toString());
+                }
+                if (result.asks && result.asks.length > 0) {
+                    console.log();
+                    console.log(chalk.red.bold("Asks:"));
+                    const asksTable = createTable({
+                        head: ["Price", "Amount"],
+                        colWidths: [20, 20],
+                    });
+                    for (const ask of result.asks.slice(0, 10)) {
+                        asksTable.push([formatCurrency(ask.price), formatTokenAmount(ask.amount)]);
+                    }
+                    console.log(asksTable.toString());
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_liquidity", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("price-impact")
+        .description("Calculate price impact for trade ($0.01)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .argument("<amount>", "Trade amount")
+        .argument("<side>", "Trade side: buy or sell")
+        .action(async (tokenIdentifier, amount, side, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({
+                tokenIdentifier,
+                amount,
+                side,
+            });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/market/price-impact?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("market/price-impact", {
+                        tokenIdentifier,
+                        amount,
+                        side,
+                    });
+                    return data;
+                }
+            }, {
+                message: "Calculating price impact...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_price_impact", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📉 Price Impact"));
+                console.log();
+                const impact = parseFloat(result.priceImpact?.toString() || "0");
+                const impactColor = impact < 0.5
+                    ? chalk.green
+                    : impact < 1
+                        ? chalk.yellow
+                        : impact < 3
+                            ? chalk.red
+                            : chalk.red.bold;
+                printBox("Price Impact", {
+                    "Price Impact": impactColor(`${impact.toFixed(2)}%`),
+                    Amount: chalk.cyan(amount),
+                    Side: chalk.cyan(side),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_price_impact", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("holders-top")
+        .description("Get top token holders ($0.01)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .option("--limit <limit>", "Limit results", "10")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({
+                tokenIdentifier,
+                limit: options.limit || "10",
+            });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/token/holders/top?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("token/holders/top", {
+                        tokenIdentifier,
+                        limit: parseInt(options.limit || "10"),
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching top holders...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_holders_top", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold(`👥 Top Holders (${result.holders?.length || 0})`));
+                console.log();
+                if (result.holders && result.holders.length > 0) {
+                    const table = createTable({
+                        head: ["Rank", "Address", "Balance", "Percentage"],
+                        colWidths: [8, 20, 20, 15],
+                    });
+                    for (const holder of result.holders) {
+                        table.push([
+                            holder.rank?.toString() || "N/A",
+                            formatAddress(holder.address, 12),
+                            formatTokenAmount(holder.balance),
+                            `${parseFloat(holder.percentage?.toString() || "0").toFixed(2)}%`,
+                        ]);
+                    }
+                    console.log(table.toString());
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_holders_top", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("distribution")
+        .description("Get token distribution ($0.01)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({ tokenIdentifier });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/token/distribution?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("token/distribution", {
+                        tokenIdentifier,
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching distribution...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_distribution", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📊 Token Distribution"));
+                console.log();
+                console.log(JSON.stringify(result, null, 2));
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_distribution", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("supply")
+        .description("Get token supply information ($0.001)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({ tokenIdentifier });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/token/supply?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("token/supply", {
+                        tokenIdentifier,
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching supply info...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_supply", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold("📈 Token Supply"));
+                console.log();
+                printBox("Supply Information", {
+                    "Total Supply": chalk.green(formatTokenAmount(result.totalSupply || "0")),
+                    "Circulating Supply": chalk.cyan(formatTokenAmount(result.circulatingSupply || "0")),
+                    "Max Supply": result.maxSupply
+                        ? chalk.yellow(formatTokenAmount(result.maxSupply))
+                        : chalk.dim("Unlimited"),
+                });
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_supply", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("unlocks")
+        .description("Get token unlock schedule ($0.01)")
+        .argument("<tokenIdentifier>", "Token identifier")
+        .action(async (tokenIdentifier, options, command) => {
+        try {
+            const globalOpts = command.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 params = new URLSearchParams({ tokenIdentifier });
+            const result = await withLoading(async () => {
+                try {
+                    const data = await client.get(`/token/unlocks?${params.toString()}`);
+                    return data.output || data;
+                }
+                catch {
+                    const { data } = await client.invoke("token/unlocks", {
+                        tokenIdentifier,
+                    });
+                    return data;
+                }
+            }, {
+                message: "Fetching unlock schedule...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_unlocks", result);
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold(`🔓 Token Unlocks (${result.unlocks?.length || 0})`));
+                console.log();
+                if (result.unlocks && result.unlocks.length > 0) {
+                    const table = createTable({
+                        head: ["Date", "Amount", "Percentage"],
+                        colWidths: [25, 20, 15],
+                    });
+                    for (const unlock of result.unlocks) {
+                        table.push([
+                            new Date(unlock.date).toLocaleString(),
+                            formatTokenAmount(unlock.amount),
+                            `${parseFloat(unlock.percentage?.toString() || "0").toFixed(2)}%`,
+                        ]);
+                    }
+                    console.log(table.toString());
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_unlocks", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // ============================================================================
+    // CoinGecko Commands
+    // ============================================================================
+    marketCommand
+        .command("search")
+        .description("Search cryptocurrencies (FREE)")
+        .argument("<query>", "Search term (name or symbol)")
+        .option("--limit <limit>", "Maximum results", "20")
+        .action(async (query, options, command) => {
+        try {
+            const globalOpts = command.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 limit = Math.min(parseInt(options.limit || "20"), 100);
+            const result = await withLoading(async () => {
+                const { data } = await client.invoke("market/search", {
+                    query,
+                    limit,
+                });
+                return data;
+            }, {
+                message: "Searching cryptocurrencies...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_search", {
+                    command: "market_search",
+                    data: result,
+                });
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                console.log(chalk.magenta.bold(`🔍 Market Search Results (${result.coins?.length || 0} found)`));
+                console.log();
+                if (result.coins && result.coins.length > 0) {
+                    const table = createTable({
+                        head: ["Coin ID", "Symbol", "Name"],
+                        colWidths: [20, 12, 30],
+                    });
+                    for (const coin of result.coins) {
+                        table.push([
+                            chalk.cyan(coin.id || ""),
+                            chalk.yellow(coin.symbol?.toUpperCase() || ""),
+                            coin.name || "",
+                        ]);
+                    }
+                    console.log(table.toString());
+                    console.log();
+                    console.log(chalk.dim(`Total: ${result.total || result.coins.length} results`));
+                }
+                else {
+                    console.log(chalk.dim("No results found."));
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_search", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("coin-data")
+        .description("Get comprehensive coin market data ($0.001)")
+        .argument("<coinId>", "CoinGecko coin ID (e.g., 'bitcoin')")
+        .option("--currency <currency>", "Currency (usd, eur, btc)", "usd")
+        .option("--sparkline", "Include 7-day sparkline")
+        .action(async (coinId, options, command) => {
+        try {
+            const globalOpts = command.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("market/coin-data", {
+                    coinId,
+                    currency: options.currency || "usd",
+                    sparkline: options.sparkline || false,
+                });
+                return data;
+            }, {
+                message: "Fetching coin data ($0.001)...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_coin_data", {
+                    command: "market_coin_data",
+                    data: result,
+                });
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                const symbol = result.symbol?.toUpperCase() || "";
+                const name = result.name || coinId;
+                console.log(chalk.magenta.bold(`💰 Coin Data: ${name} (${symbol})`));
+                console.log();
+                const currency = (options.currency || "usd").toUpperCase();
+                const priceKey = `currentPrice`; // API returns currentPrice
+                const price = result[priceKey] || result.price || 0;
+                const priceChange24h = result.priceChange24h || result.priceChangePercentage24h || 0;
+                const changeColor = priceChange24h >= 0 ? chalk.green : chalk.red;
+                const changeEmoji = priceChange24h >= 0 ? "🟢" : "🔴";
+                const boxData = {
+                    Price: chalk.green.bold(formatCurrency(price)),
+                    "24h Change": changeColor(`${priceChange24h >= 0 ? "+" : ""}${priceChange24h.toFixed(2)}% ${changeEmoji}`),
+                };
+                if (result.marketCap) {
+                    boxData["Market Cap"] = formatCurrency(result.marketCap);
+                }
+                if (result.marketCapRank) {
+                    boxData["Market Cap Rank"] = `#${result.marketCapRank}`;
+                }
+                if (result.totalVolume) {
+                    boxData["Volume 24h"] = formatCurrency(result.totalVolume);
+                }
+                if (result.high24h) {
+                    boxData["High 24h"] = formatCurrency(result.high24h);
+                }
+                if (result.low24h) {
+                    boxData["Low 24h"] = formatCurrency(result.low24h);
+                }
+                if (result.circulatingSupply) {
+                    boxData["Circulating Supply"] = formatTokenAmount(result.circulatingSupply.toString());
+                }
+                if (result.totalSupply) {
+                    boxData["Total Supply"] = formatTokenAmount(result.totalSupply.toString());
+                }
+                if (result.ath) {
+                    const athChange = result.athChangePercentage || 0;
+                    boxData["ATH"] = `${formatCurrency(result.ath)} (${athChange.toFixed(1)}%)`;
+                }
+                if (result.atl) {
+                    const atlChange = result.atlChangePercentage || 0;
+                    boxData["ATL"] = `${formatCurrency(result.atl)} (+${atlChange.toFixed(1)}%)`;
+                }
+                printBox("Coin Data", boxData);
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_coin_data", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    marketCommand
+        .command("chart")
+        .description("Get historical price chart data ($0.01)")
+        .argument("<coinId>", "CoinGecko coin ID")
+        .argument("<days>", "Timeframe: 1, 7, 14, 30, 90, 180, 365, or max")
+        .option("--currency <currency>", "Currency", "usd")
+        .option("--interval <interval>", "Interval: daily or hourly")
+        .action(async (coinId, days, options, command) => {
+        try {
+            const globalOpts = command.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("market/chart", {
+                    coinId,
+                    days,
+                    currency: options.currency || "usd",
+                    interval: options.interval,
+                });
+                return data;
+            }, {
+                message: "Fetching chart data ($0.01)...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("market_chart", {
+                    command: "market_chart",
+                    data: result,
+                });
+            }
+            else if (!globalOpts.quiet) {
+                console.log();
+                const currency = (options.currency || "usd").toUpperCase();
+                console.log(chalk.magenta.bold(`📊 Price Chart: ${coinId} (${days} days)`));
+                console.log();
+                const dataPoints = result.prices?.length || 0;
+                console.log(chalk.dim(`Data Points: ${dataPoints}`));
+                console.log(chalk.dim(`Currency: ${currency}`));
+                console.log();
+                if (result.prices && result.prices.length > 0) {
+                    console.log(chalk.dim("Sample Data:"));
+                    const table = createTable({
+                        head: ["Timestamp", "Price", "Market Cap", "Volume"],
+                        colWidths: [20, 15, 15, 15],
+                    });
+                    // Show first 5 and last 5 data points
+                    const sampleSize = Math.min(10, result.prices.length);
+                    const prices = result.prices.slice(0, sampleSize);
+                    const marketCaps = result.marketCaps?.slice(0, sampleSize) || [];
+                    const totalVolumes = result.totalVolumes?.slice(0, sampleSize) || [];
+                    for (let i = 0; i < prices.length; i++) {
+                        const [timestamp, price] = prices[i];
+                        const marketCap = marketCaps[i]?.[1] || 0;
+                        const volume = totalVolumes[i]?.[1] || 0;
+                        table.push([
+                            new Date(timestamp).toLocaleString(),
+                            formatCurrency(price),
+                            marketCap > 0 ? formatCurrency(marketCap) : "-",
+                            volume > 0 ? formatCurrency(volume) : "-",
+                        ]);
+                    }
+                    console.log(table.toString());
+                    if (result.prices.length > sampleSize) {
+                        console.log(chalk.dim(`... and ${result.prices.length - sampleSize} more data points`));
+                    }
+                    console.log();
+                    console.log(chalk.dim("Use --json to get full data for charting"));
+                }
+                else {
+                    console.log(chalk.dim("No chart data available."));
+                }
+                console.log();
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("market_chart", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    return marketCommand;
+}
+//# sourceMappingURL=market.js.map