httpcat-cli 0.3.0 → 0.3.1

package/dist/commands/launchpad.js

@@ -0,0 +1,708 @@
+import { Command } from "commander";
+import { HttpcatClient } from "../client.js";
+import { config } from "../config.js";
+import { randomUUID } from "crypto";
+import chalk from "chalk";
+import { privateKeyToAccount } from "viem/accounts";
+// Import command functions
+import { createToken, displayCreateResult, processPhotoUrl, isFilePath, } from "./create.js";
+import { buyToken, displayBuyResult, displayBuyResultCompact, } from "./buy.js";
+import { sellToken, displaySellResult } from "./sell.js";
+import { listTokens, displayTokenList } from "./list.js";
+import { getTokenInfo, displayTokenInfo } from "./info.js";
+import { getPositions, displayPositions } from "./positions.js";
+import { viewFees, claimFees, displayFees, displayClaimResult, getUserCreatedTokens, getAllTokenFees, displayAllFees, displayTokenCreationGuide, claimAllFees, } from "./claim.js";
+// Import utilities
+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 (duplicated from index.ts to avoid circular dependencies)
+// ============================================================================
+function getPrivateKey(cliPrivateKey, accountIndex) {
+    if (cliPrivateKey)
+        return cliPrivateKey;
+    const envKey = process.env.HTTPCAT_PRIVATE_KEY;
+    if (envKey)
+        return envKey;
+    // Use account system
+    try {
+        const index = accountIndex !== undefined
+            ? accountIndex
+            : config.getActiveAccountIndex();
+        return config.getAccountPrivateKey(index);
+    }
+    catch (error) {
+        // Fall back to legacy format if account system not set up
+        return config.get("privateKey");
+    }
+}
+function isConfigured(cliPrivateKey) {
+    if (cliPrivateKey)
+        return true;
+    return config.isConfigured();
+}
+async function ensureWalletUnlocked() {
+    const password = config.getPassword();
+    if (!password) {
+        // No password required - ensure session is initialized
+        config.ensureSessionValid();
+        return;
+    }
+    if (!config.isSessionValid()) {
+        // Need to prompt for password
+        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);
+    }
+}
+// ============================================================================
+// Launchpad Command Group
+// ============================================================================
+export function createLaunchpadCommand() {
+    const launchpadCommand = new Command("launchpad")
+        .description("402.cat Launchpad operations (bonding curve tokens)")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad create "My Token" "MTK"
+  httpcat launchpad buy MTK 0.10
+  httpcat launchpad sell MTK 50%
+  httpcat launchpad list --sort mcap
+  httpcat launchpad info MTK
+  httpcat launchpad positions
+  httpcat launchpad claim view MTK
+  httpcat launchpad claim execute MTK --execute
+    `);
+    // Create subcommand
+    launchpadCommand
+        .command("create")
+        .alias("new")
+        .description("Create a new launchpad token ($0.01)")
+        .argument("<name>", 'Token name (e.g., "My Token")')
+        .argument("<symbol>", 'Token symbol/ticker (e.g., "MTK", 3-10 characters)')
+        .option("-p, --photo <url|path>", "Photo URL or file path for token logo")
+        .option("-w, --website <url>", "Website URL")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad create "My Token" "MTK"
+  httpcat launchpad create "Moon Cat" "MOON" --website https://mooncat.io
+  httpcat launchpad create "Test" "TEST" --photo https://example.com/logo.png
+  httpcat launchpad create "Test" "TEST" --photo ./logo.png
+  `)
+        .action(async (name, symbol, options, command) => {
+        try {
+            // Fallback: get arguments from command object if not provided as parameters
+            const args = command.processedArgs || command.args || [];
+            const actualName = name || args[0];
+            const actualSymbol = symbol || args[1];
+            // Validate required arguments
+            if (!actualName || typeof actualName !== "string") {
+                throw new Error("Token name is required. Usage: httpcat launchpad create <name> <symbol> [options]");
+            }
+            if (!actualSymbol || typeof actualSymbol !== "string") {
+                throw new Error("Token symbol is required. Usage: httpcat launchpad create <name> <symbol> [options]");
+            }
+            const globalOpts = command.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);
+                }
+                // Interactive prompt for private key
+                privateKey = await promptForPrivateKey();
+            }
+            const client = await HttpcatClient.create(privateKey);
+            // Generate default robohash URL if no photo provided
+            let photoToUse = options.photo;
+            if (!photoToUse) {
+                const uuid = randomUUID();
+                photoToUse = `https://robohash.org/${uuid}?set=set4`;
+            }
+            // Process photo if it's a file path (show loading state)
+            let processedPhotoUrl = photoToUse;
+            if (photoToUse && isFilePath(photoToUse)) {
+                processedPhotoUrl = await withLoading(async () => processPhotoUrl(photoToUse), {
+                    message: "Uploading image...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+            }
+            // Create token (show loading state)
+            const result = await withLoading(() => createToken(client, {
+                name: actualName.trim(),
+                symbol: actualSymbol.trim(),
+                photoUrl: processedPhotoUrl,
+                websiteUrl: options.website,
+            }), {
+                message: "Creating token...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("create_token", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayCreateResult(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            // Handle errors normally - show the actual error from the backend
+            if (globalOpts.json) {
+                outputError("create_token", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Buy subcommand
+    launchpadCommand
+        .command("buy")
+        .alias("b")
+        .description("Buy tokens from bonding curve")
+        .argument("<identifier>", "Token identifier (address, symbol, or ID)")
+        .argument("<amount>", "Amount to buy (ETH/USDC)")
+        .option("-r, --repeat <count>", "Execute multiple buys in sequence", parseInt)
+        .option("-d, --delay <ms>", "Delay between repeated buys (milliseconds)", parseInt)
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad buy MTK 0.10
+  httpcat launchpad buy 0x123... 0.05
+  httpcat launchpad buy MTK 0.01 --repeat 10 --delay 1000
+  `)
+        .action(async (identifier, amount, options, command) => {
+        try {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            const accountIndex = globalOpts.account;
+            // Ensure wallet is unlocked
+            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 network = client.getNetwork();
+            const isTestMode = network === "eip155:84532" ||
+                network === "eip155:11155111" ||
+                network.includes("sepolia");
+            const silent = globalOpts.json || globalOpts.quiet;
+            // Amount validation is handled by buyToken function
+            // It validates only for active tokens in DB, skips for universal buys
+            const repeat = options.repeat || 1;
+            const delay = options.delay || 0;
+            if (repeat > 1 && !globalOpts.quiet) {
+                console.log(chalk.cyan(`\nExecuting ${repeat} buys with ${delay}ms delay\n`));
+            }
+            const results = [];
+            for (let i = 0; i < repeat; i++) {
+                if (repeat > 1 && !silent) {
+                    console.log(chalk.dim(`Buy ${i + 1}/${repeat}...`));
+                }
+                const result = await withLoading(() => buyToken(client, identifier, amount.toString(), isTestMode, silent || i > 0, privateKey), {
+                    message: repeat > 1 ? `Buying (${i + 1}/${repeat})...` : "Buying...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+                results.push(result);
+                if (!silent) {
+                    if (repeat > 1) {
+                        displayBuyResultCompact(result);
+                    }
+                    else {
+                        displayBuyResult(result);
+                    }
+                }
+                // Delay between buys (except after the last one)
+                if (i < repeat - 1 && delay > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+            if (globalOpts.json) {
+                outputJson("buy_token", repeat > 1 ? results : results[0]);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("buy_token", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Sell subcommand
+    launchpadCommand
+        .command("sell")
+        .alias("s")
+        .description("Sell tokens to bonding curve ($0.01)")
+        .argument("<identifier>", "Token identifier (address, symbol, or ID)")
+        .argument("<amount>", "Amount to sell (tokens or percentage like '50%')")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad sell MTK 1000
+  httpcat launchpad sell MTK 50%
+  httpcat launchpad sell 0x123... 100%
+  `)
+        .action(async (identifier, amount, 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 silent = globalOpts.json || globalOpts.quiet;
+            const result = await withLoading(() => sellToken(client, identifier, amount.toString(), silent, privateKey), {
+                message: "Selling...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("sell_token", result);
+            }
+            else if (!globalOpts.quiet) {
+                displaySellResult(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("sell_token", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // List subcommand
+    launchpadCommand
+        .command("list")
+        .alias("ls")
+        .description("List all launchpad tokens (FREE)")
+        .option("-p, --page <number>", "Page number", "1")
+        .option("-l, --limit <number>", "Items per page", "20")
+        .option("-s, --sort <sort>", "Sort by: mcap, created, name, volume", "mcap")
+        .option("-f, --filter <filter>", "Filter: active, graduated, all", "active")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad list
+  httpcat launchpad list --sort mcap --limit 50
+  httpcat launchpad list --filter graduated
+  `)
+        .action(async (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(() => listTokens(client, parseInt(options.page), parseInt(options.limit), options.sort), {
+                message: "Fetching tokens...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("list_tokens", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayTokenList(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("list_tokens", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Info subcommand
+    launchpadCommand
+        .command("info")
+        .alias("i")
+        .description("Get launchpad token information (FREE)")
+        .argument("<identifier>", "Token identifier (address, symbol, or ID)")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad info MTK
+  httpcat launchpad info 0x123...
+  `)
+        .action(async (identifier, 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 silent = globalOpts.json || globalOpts.quiet;
+            const result = await withLoading(() => getTokenInfo(client, identifier, undefined, silent), {
+                message: "Fetching token info...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            if (globalOpts.json) {
+                outputJson("token_info", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayTokenInfo(result);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("token_info", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Positions subcommand
+    launchpadCommand
+        .command("positions")
+        .description("Get launchpad token positions (FREE)")
+        .option("--active", "Show only active tokens (on bonding curve)")
+        .option("--graduated", "Show only graduated tokens (on Uniswap)")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad positions
+  httpcat launchpad positions --active
+  httpcat launchpad positions --graduated
+  `)
+        .action(async (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);
+            // Derive user address from private key
+            const account = privateKeyToAccount(privateKey);
+            const userAddress = account.address;
+            let result = await withLoading(() => getPositions(client, userAddress), {
+                message: "Fetching positions...",
+                json: globalOpts.json,
+                quiet: globalOpts.quiet,
+                spinner: "cat",
+                clearOnSuccess: true,
+            });
+            // Determine filter
+            const filter = options.active
+                ? "active"
+                : options.graduated
+                    ? "graduated"
+                    : "all";
+            // Filter results for JSON output
+            if (globalOpts.json && filter !== "all") {
+                const filteredPositions = result.positions.filter((p) => filter === "active"
+                    ? p.token.status !== "graduated"
+                    : p.token.status === "graduated");
+                result = {
+                    ...result,
+                    positions: filteredPositions,
+                    total: filteredPositions.length,
+                };
+                outputJson("positions", result);
+            }
+            else if (globalOpts.json) {
+                outputJson("positions", result);
+            }
+            else if (!globalOpts.quiet) {
+                displayPositions(result, filter);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("positions", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    // Claim subgroup
+    const claimCommand = launchpadCommand
+        .command("claim")
+        .description("View and claim launchpad fees (claims)");
+    claimCommand
+        .command("view")
+        .description("View accumulated claims (FREE)")
+        .argument("[identifier]", "Optional token identifier. If omitted, shows all your tokens.")
+        .option("--all", "Show all your tokens")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad claim view              # View all your tokens
+  httpcat launchpad claim view MTK            # View specific token
+  httpcat launchpad claim view 0x123...
+  `)
+        .action(async (identifier, 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 silent = globalOpts.json || globalOpts.quiet;
+            const account = privateKeyToAccount(privateKey);
+            const callerAddress = account.address;
+            if (!identifier || options.all) {
+                // View all tokens
+                const userTokens = await withLoading(() => getUserCreatedTokens(client, callerAddress), {
+                    message: "Finding your tokens...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+                if (userTokens.length === 0) {
+                    if (globalOpts.json) {
+                        outputJson("user_tokens", { tokens: [] });
+                    }
+                    else if (!globalOpts.quiet) {
+                        displayTokenCreationGuide();
+                    }
+                    process.exit(0);
+                }
+                const allFees = await withLoading(() => getAllTokenFees(client, userTokens, silent), {
+                    message: "Fetching available claims...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+                if (globalOpts.json) {
+                    outputJson("all_claims", allFees);
+                }
+                else if (!globalOpts.quiet) {
+                    displayAllFees(allFees);
+                }
+            }
+            else {
+                // View specific token
+                const result = await withLoading(() => viewFees(client, identifier, silent), {
+                    message: "Fetching claim information...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+                if (globalOpts.json) {
+                    outputJson("view_fees", result);
+                }
+                else if (!globalOpts.quiet) {
+                    displayFees(result);
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("view_fees", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    claimCommand
+        .command("execute")
+        .alias("claim")
+        .description("Claim accumulated fees ($0.01)")
+        .argument("[identifier]", "Optional token identifier. If omitted and --all is used, claims all tokens.")
+        .option("--execute", "Execute the claim transaction (required)")
+        .option("--all", "Claim fees for all your tokens")
+        .addHelpText("after", `
+Examples:
+  httpcat launchpad claim execute --all      # Claim all tokens
+  httpcat launchpad claim execute MTK         # Claim specific token
+  httpcat launchpad claim execute MTK --execute
+  `)
+        .action(async (identifier, 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 silent = globalOpts.json || globalOpts.quiet;
+            const account = privateKeyToAccount(privateKey);
+            const callerAddress = account.address;
+            if ((!identifier && options.all) || options.all) {
+                // Claim all tokens
+                const userTokens = await withLoading(() => getUserCreatedTokens(client, callerAddress), {
+                    message: "Finding your tokens...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+                if (userTokens.length === 0) {
+                    if (globalOpts.json) {
+                        outputJson("user_tokens", { tokens: [] });
+                    }
+                    else if (!globalOpts.quiet) {
+                        displayTokenCreationGuide();
+                    }
+                    process.exit(0);
+                }
+                const results = await claimAllFees(client, userTokens, callerAddress, silent);
+                if (globalOpts.json) {
+                    outputJson("claim_all_fees", {
+                        success: results.success,
+                        failed: results.failed,
+                    });
+                }
+                else if (!globalOpts.quiet) {
+                    console.log();
+                    console.log(chalk.magenta.bold(`✅ Claimed fees for ${results.success.length} token(s)`));
+                    if (results.failed.length > 0) {
+                        console.log(chalk.yellow(`⚠️  Failed to claim fees for ${results.failed.length} token(s)`));
+                    }
+                    console.log();
+                }
+            }
+            else if (identifier) {
+                // Claim specific token
+                if (!options.execute) {
+                    // Preview mode - just view fees
+                    const viewResult = await withLoading(() => viewFees(client, identifier, silent), {
+                        message: "Fetching fees...",
+                        json: globalOpts.json,
+                        quiet: globalOpts.quiet,
+                        spinner: "cat",
+                        clearOnSuccess: true,
+                    });
+                    if (globalOpts.json) {
+                        outputJson("claim_fees_preview", viewResult);
+                    }
+                    else if (!globalOpts.quiet) {
+                        displayFees(viewResult);
+                        console.log();
+                        console.log(chalk.yellow("⚠️  This is a preview. Use --execute to claim."));
+                    }
+                    process.exit(0);
+                    return;
+                }
+                // Execute claim
+                const result = await withLoading(() => claimFees(client, identifier, callerAddress, silent), {
+                    message: "Claiming fees...",
+                    json: globalOpts.json,
+                    quiet: globalOpts.quiet,
+                    spinner: "cat",
+                    clearOnSuccess: true,
+                });
+                if (globalOpts.json) {
+                    outputJson("claim_fees", result);
+                }
+                else if (!globalOpts.quiet) {
+                    displayClaimResult(result);
+                }
+            }
+            else {
+                throw new Error("Please specify a token identifier or use --all flag");
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const globalOpts = command.parent?.parent?.parent?.opts() || {};
+            if (globalOpts.json) {
+                outputError("claim_fees", error, getExitCode(error));
+            }
+            else {
+                handleError(error, globalOpts.verbose);
+            }
+            process.exit(getExitCode(error));
+        }
+    });
+    return launchpadCommand;
+}
+//# sourceMappingURL=launchpad.js.map