httpcat-cli 0.3.0 → 0.3.1-rc.2

package/dist/commands/send.js

@@ -0,0 +1,733 @@
+import chalk from "chalk";
+import { printBox, formatAddress, } from "../utils/formatting.js";
+import { printSuccess } from "../interactive/art.js";
+import { resolveTokenId } from "../utils/token-resolver.js";
+import { createPublicClient, createWalletClient, parseAbi, formatUnits, parseUnits, parseEther, formatEther, isAddress, getAddress, encodeFunctionData, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { config } from "../config.js";
+import { createRpcTransport } from "../utils/rpc-transport.js";
+import { getNetworkConfig } from "../utils/constants.js";
+import inquirer from "inquirer";
+import { readFileSync } from "fs";
+import Table from "cli-table3";
+// ERC20 ABI for token operations
+const ERC20_ABI = parseAbi([
+    "function transfer(address to, uint256 amount) returns (bool)",
+    "function balanceOf(address owner) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+    "function name() view returns (string)",
+]);
+/**
+ * Validate and checksum an Ethereum address
+ */
+function validateAddress(address) {
+    if (!isAddress(address)) {
+        throw new Error(`Invalid address format: ${address}`);
+    }
+    return getAddress(address);
+}
+/**
+ * Parse amount string to bigint
+ */
+function parseAmount(amount, decimals = 18) {
+    try {
+        return parseUnits(amount, decimals);
+    }
+    catch (error) {
+        throw new Error(`Invalid amount format: ${amount}. ${error instanceof Error ? error.message : ""}`);
+    }
+}
+/**
+ * Get gas price configuration
+ */
+async function getGasConfig(publicClient, options) {
+    const gasConfig = {};
+    // Legacy gas price
+    if (options.gasPrice) {
+        const gwei = parseFloat(options.gasPrice);
+        gasConfig.gasPrice = parseUnits(gwei.toString(), 9); // Convert gwei to wei
+    }
+    // EIP-1559 fees
+    if (options.maxFeePerGas || options.maxPriorityFeePerGas) {
+        if (options.maxFeePerGas) {
+            const gwei = parseFloat(options.maxFeePerGas);
+            gasConfig.maxFeePerGas = parseUnits(gwei.toString(), 9);
+        }
+        if (options.maxPriorityFeePerGas) {
+            const gwei = parseFloat(options.maxPriorityFeePerGas);
+            gasConfig.maxPriorityFeePerGas = parseUnits(gwei.toString(), 9);
+        }
+    }
+    else if (!options.gasPrice) {
+        // Auto-estimate EIP-1559 fees if not provided
+        try {
+            const feeData = await publicClient.estimateFeesPerGas();
+            if (feeData) {
+                gasConfig.maxFeePerGas = feeData.maxFeePerGas;
+                gasConfig.maxPriorityFeePerGas =
+                    feeData.maxPriorityFeePerGas || feeData.maxFeePerGas / 2n;
+            }
+        }
+        catch {
+            // Fallback to legacy gas price
+            try {
+                const gasPrice = await publicClient.getGasPrice();
+                gasConfig.gasPrice = gasPrice;
+            }
+            catch {
+                // Use default if all else fails
+            }
+        }
+    }
+    // Gas limit
+    if (options.gasLimit) {
+        gasConfig.gas = options.gasLimit;
+    }
+    return gasConfig;
+}
+/**
+ * Prompt for confirmation before sending
+ */
+async function promptConfirmation(summary, options) {
+    if (options.noConfirm || options.silent) {
+        return true;
+    }
+    if (options.confirm || !process.stdin.isTTY) {
+        // Force confirmation prompt
+        const answers = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: `Send ${summary.amount} ${summary.tokenSymbol || "ETH"} to ${summary.to}?`,
+                default: false,
+            },
+        ]);
+        return answers.confirm;
+    }
+    // Default: show summary but don't require confirmation in non-interactive mode
+    return true;
+}
+/**
+ * Send native currency (ETH)
+ */
+export async function sendNativeCurrency(client, to, amount, privateKey, options = {}) {
+    const account = privateKeyToAccount(privateKey);
+    const from = account.address;
+    const network = client.getNetwork();
+    const { chain } = await getNetworkConfig(network);
+    const publicClient = createPublicClient({
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    // Validate address
+    const toAddress = validateAddress(to);
+    // Parse amount
+    const amountWei = parseEther(amount);
+    // Check balance
+    const balance = await publicClient.getBalance({ address: from });
+    if (balance < amountWei) {
+        throw new Error(`Insufficient balance. Have ${formatEther(balance)} ETH, need ${amount} ETH`);
+    }
+    // Get gas configuration
+    const gasConfig = await getGasConfig(publicClient, options);
+    // Estimate gas (don't include gas config in estimation)
+    let estimatedGas;
+    try {
+        estimatedGas = await publicClient.estimateGas({
+            account: from,
+            to: toAddress,
+            value: amountWei,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to estimate gas: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    // Check if we have enough for gas
+    const totalNeeded = amountWei +
+        (gasConfig.gas || estimatedGas) *
+            (gasConfig.gasPrice || gasConfig.maxFeePerGas || 0n);
+    if (balance < totalNeeded) {
+        throw new Error(`Insufficient balance for transaction. Need ${formatEther(totalNeeded)} ETH (${amount} ETH + gas)`);
+    }
+    // Show summary and prompt for confirmation
+    const estimatedGasEth = formatEther((gasConfig.gas || estimatedGas) *
+        (gasConfig.gasPrice || gasConfig.maxFeePerGas || 0n));
+    const confirmed = await promptConfirmation({
+        type: "native",
+        from,
+        to: toAddress,
+        amount,
+        estimatedGas: estimatedGasEth,
+    }, options);
+    if (!confirmed) {
+        throw new Error("Transaction cancelled by user");
+    }
+    // Dry run mode
+    if (options.dryRun) {
+        if (!options.silent) {
+            console.log(chalk.yellow("\n🔍 Dry Run Mode - Transaction not broadcast\n"));
+            console.log(chalk.cyan(`From: ${from}`));
+            console.log(chalk.cyan(`To: ${toAddress}`));
+            console.log(chalk.cyan(`Amount: ${amount} ETH`));
+            console.log(chalk.cyan(`Estimated Gas: ${estimatedGas.toString()}`));
+            console.log(chalk.cyan(`Estimated Gas Cost: ${estimatedGasEth} ETH`));
+        }
+        return {
+            success: true,
+            type: "native",
+            from,
+            to: toAddress,
+            amount,
+            gasUsed: estimatedGas,
+        };
+    }
+    // Build transaction
+    // Note: Don't include 'account' field - walletClient already has it configured
+    const txRequest = {
+        to: toAddress,
+        value: amountWei,
+        gas: gasConfig.gas || estimatedGas,
+        ...gasConfig,
+    };
+    // Set nonce if provided
+    if (options.nonce !== undefined) {
+        txRequest.nonce = options.nonce;
+    }
+    // Send transaction
+    if (!options.silent) {
+        console.log(chalk.cyan(`\n📤 Sending ${amount} ETH to ${toAddress}...`));
+    }
+    const txHash = await walletClient.sendTransaction(txRequest);
+    let result = {
+        success: true,
+        type: "native",
+        txHash,
+        from,
+        to: toAddress,
+        amount,
+    };
+    // Wait for confirmation if requested
+    if (options.wait) {
+        if (!options.silent) {
+            console.log(chalk.cyan(`⏳ Waiting for confirmation...`));
+        }
+        const receipt = await publicClient.waitForTransactionReceipt({
+            hash: txHash,
+            timeout: (options.timeout || 300) * 1000,
+        });
+        result.gasUsed = receipt.gasUsed;
+        result.blockNumber = receipt.blockNumber;
+        result.confirmations = 1; // At least 1 confirmation
+        if (!options.silent) {
+            console.log(chalk.green(`✅ Transaction confirmed in block ${receipt.blockNumber.toString()}`));
+        }
+    }
+    return result;
+}
+/**
+ * Send ERC20 token
+ */
+export async function sendToken(client, tokenIdentifier, to, amount, privateKey, options = {}) {
+    const account = privateKeyToAccount(privateKey);
+    const from = account.address;
+    const network = client.getNetwork();
+    const { chain } = await getNetworkConfig(network);
+    const publicClient = createPublicClient({
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    // Validate address
+    const toAddress = validateAddress(to);
+    // Resolve token identifier to address
+    let tokenAddress;
+    try {
+        const resolved = await resolveTokenId(tokenIdentifier, client, options.silent);
+        tokenAddress = validateAddress(resolved);
+    }
+    catch (error) {
+        // If resolution fails, try treating it as an address directly
+        if (isAddress(tokenIdentifier)) {
+            tokenAddress = getAddress(tokenIdentifier);
+        }
+        else {
+            throw new Error(`Failed to resolve token "${tokenIdentifier}": ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    // Get token metadata
+    let tokenDecimals = options.decimals;
+    let tokenSymbol = "TOKEN";
+    let tokenName = "Token";
+    try {
+        if (!tokenDecimals) {
+            tokenDecimals = (await publicClient.readContract({
+                address: tokenAddress,
+                abi: ERC20_ABI,
+                functionName: "decimals",
+            }));
+        }
+        tokenSymbol = (await publicClient.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: "symbol",
+        }));
+        tokenName = (await publicClient.readContract({
+            address: tokenAddress,
+            abi: ERC20_ABI,
+            functionName: "name",
+        }));
+    }
+    catch (error) {
+        if (!tokenDecimals) {
+            throw new Error(`Failed to get token decimals. Use --decimals flag or ensure token contract is valid. ${error instanceof Error ? error.message : ""}`);
+        }
+        // Use provided decimals if available
+    }
+    // Parse amount
+    const amountWei = parseAmount(amount, tokenDecimals);
+    // Check balance
+    const balance = (await publicClient.readContract({
+        address: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [from],
+    }));
+    if (balance < amountWei) {
+        throw new Error(`Insufficient token balance. Have ${formatUnits(balance, tokenDecimals)} ${tokenSymbol}, need ${amount} ${tokenSymbol}`);
+    }
+    // Get gas configuration
+    const gasConfig = await getGasConfig(publicClient, options);
+    // Estimate gas for transfer (don't include gas config in estimation)
+    let estimatedGas;
+    try {
+        estimatedGas = await publicClient.estimateGas({
+            account: from,
+            to: tokenAddress,
+            data: encodeFunctionData({
+                abi: ERC20_ABI,
+                functionName: "transfer",
+                args: [toAddress, amountWei],
+            }),
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to estimate gas: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    // Check ETH balance for gas
+    const ethBalance = await publicClient.getBalance({ address: from });
+    const estimatedGasCost = (gasConfig.gas || estimatedGas) *
+        (gasConfig.gasPrice || gasConfig.maxFeePerGas || 0n);
+    if (ethBalance < estimatedGasCost) {
+        throw new Error(`Insufficient ETH for gas. Need ${formatEther(estimatedGasCost)} ETH`);
+    }
+    // Show summary and prompt for confirmation
+    const estimatedGasEth = formatEther(estimatedGasCost);
+    const confirmed = await promptConfirmation({
+        type: "token",
+        from,
+        to: toAddress,
+        amount,
+        tokenSymbol,
+        estimatedGas: estimatedGasEth,
+    }, options);
+    if (!confirmed) {
+        throw new Error("Transaction cancelled by user");
+    }
+    // Dry run mode
+    if (options.dryRun) {
+        if (!options.silent) {
+            console.log(chalk.yellow("\n🔍 Dry Run Mode - Transaction not broadcast\n"));
+            console.log(chalk.cyan(`From: ${from}`));
+            console.log(chalk.cyan(`To: ${toAddress}`));
+            console.log(chalk.cyan(`Token: ${tokenName} (${tokenSymbol})`));
+            console.log(chalk.cyan(`Token Address: ${tokenAddress}`));
+            console.log(chalk.cyan(`Amount: ${amount} ${tokenSymbol}`));
+            console.log(chalk.cyan(`Estimated Gas: ${estimatedGas.toString()}`));
+            console.log(chalk.cyan(`Estimated Gas Cost: ${estimatedGasEth} ETH`));
+        }
+        return {
+            success: true,
+            type: "token",
+            from,
+            to: toAddress,
+            amount,
+            tokenAddress,
+            tokenSymbol,
+            gasUsed: estimatedGas,
+        };
+    }
+    // Build transaction
+    // Note: Don't include 'account' field - walletClient already has it configured
+    const txRequest = {
+        to: tokenAddress,
+        data: encodeFunctionData({
+            abi: ERC20_ABI,
+            functionName: "transfer",
+            args: [toAddress, amountWei],
+        }),
+        gas: gasConfig.gas || estimatedGas,
+        ...gasConfig,
+    };
+    // Set nonce if provided
+    if (options.nonce !== undefined) {
+        txRequest.nonce = options.nonce;
+    }
+    // Send transaction
+    if (!options.silent) {
+        console.log(chalk.cyan(`\n📤 Sending ${amount} ${tokenSymbol} to ${toAddress}...`));
+    }
+    const txHash = await walletClient.sendTransaction(txRequest);
+    let result = {
+        success: true,
+        type: "token",
+        txHash,
+        from,
+        to: toAddress,
+        amount,
+        tokenAddress,
+        tokenSymbol,
+    };
+    // Wait for confirmation if requested
+    if (options.wait) {
+        if (!options.silent) {
+            console.log(chalk.cyan(`⏳ Waiting for confirmation...`));
+        }
+        const receipt = await publicClient.waitForTransactionReceipt({
+            hash: txHash,
+            timeout: (options.timeout || 300) * 1000,
+        });
+        result.gasUsed = receipt.gasUsed;
+        result.blockNumber = receipt.blockNumber;
+        result.confirmations = 1;
+        if (!options.silent) {
+            console.log(chalk.green(`✅ Transaction confirmed in block ${receipt.blockNumber.toString()}`));
+        }
+    }
+    return result;
+}
+/**
+ * Resolve recipient (account index or address) - helper for batch sends
+ */
+function resolveRecipientForBatch(to) {
+    // Check if it's a number (account index)
+    const accountIndex = parseInt(to, 10);
+    if (!isNaN(accountIndex) && to.trim() === accountIndex.toString()) {
+        // It's a number - try to resolve to account address
+        const accounts = config.getAllAccounts();
+        const account = accounts.find((acc) => acc.index === accountIndex);
+        if (!account) {
+            throw new Error(`Account at index ${accountIndex} not found. Use "httpcat account list" to see available accounts.`);
+        }
+        return account.address;
+    }
+    // Not a number - treat as address
+    return to;
+}
+/**
+ * Send batch transactions
+ */
+export async function sendBatch(client, batchInput, privateKey, options = {}) {
+    // Parse batch input if it's a string (file path or JSON)
+    let batch;
+    if (typeof batchInput === "string") {
+        try {
+            // Try to read as file first
+            try {
+                const fileContent = readFileSync(batchInput, "utf-8");
+                batch = JSON.parse(fileContent);
+            }
+            catch {
+                // If file read fails, try parsing as JSON string
+                batch = JSON.parse(batchInput);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse batch input: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    else {
+        batch = batchInput;
+    }
+    const results = [];
+    // Process native currency sends
+    if (batch.native && batch.native.length > 0) {
+        if (!options.silent) {
+            console.log(chalk.cyan(`\n📦 Processing ${batch.native.length} native currency send(s)...`));
+        }
+        for (const item of batch.native) {
+            try {
+                // Resolve recipient (account index or address)
+                const recipientAddress = resolveRecipientForBatch(item.to);
+                const result = await sendNativeCurrency(client, recipientAddress, item.amount, privateKey, { ...options, silent: true } // Suppress individual confirmations in batch
+                );
+                results.push(result);
+                if (!options.silent) {
+                    console.log(chalk.green(`  ✅ Sent ${item.amount} ETH to ${recipientAddress}`));
+                }
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    type: "native",
+                    from: privateKeyToAccount(privateKey).address,
+                    to: item.to,
+                    amount: item.amount,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+                if (!options.silent) {
+                    console.log(chalk.red(`  ❌ Failed to send ${item.amount} ETH to ${item.to}: ${error instanceof Error ? error.message : "Unknown error"}`));
+                }
+            }
+        }
+    }
+    // Process token sends
+    if (batch.tokens && batch.tokens.length > 0) {
+        if (!options.silent) {
+            console.log(chalk.cyan(`\n📦 Processing ${batch.tokens.length} token send(s)...`));
+        }
+        for (const item of batch.tokens) {
+            if (!item.token) {
+                results.push({
+                    success: false,
+                    type: "token",
+                    from: privateKeyToAccount(privateKey).address,
+                    to: item.to,
+                    amount: item.amount,
+                    error: "Token identifier required",
+                });
+                continue;
+            }
+            try {
+                // Resolve recipient (account index or address)
+                const recipientAddress = resolveRecipientForBatch(item.to);
+                const result = await sendToken(client, item.token, recipientAddress, item.amount, privateKey, { ...options, silent: true } // Suppress individual confirmations in batch
+                );
+                results.push(result);
+                if (!options.silent) {
+                    console.log(chalk.green(`  ✅ Sent ${item.amount} ${result.tokenSymbol || "tokens"} to ${recipientAddress}`));
+                }
+            }
+            catch (error) {
+                results.push({
+                    success: false,
+                    type: "token",
+                    from: privateKeyToAccount(privateKey).address,
+                    to: item.to,
+                    amount: item.amount,
+                    tokenAddress: item.token,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+                if (!options.silent) {
+                    console.log(chalk.red(`  ❌ Failed to send ${item.amount} ${item.token} to ${item.to}: ${error instanceof Error ? error.message : "Unknown error"}`));
+                }
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Send custom transaction
+ */
+export async function sendCustomTransaction(client, to, data, privateKey, value = 0n, options = {}) {
+    const account = privateKeyToAccount(privateKey);
+    const from = account.address;
+    const network = client.getNetwork();
+    const { chain } = await getNetworkConfig(network);
+    const publicClient = createPublicClient({
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: createRpcTransport({
+            chainId: chain.id,
+            httpcatClient: client,
+        }),
+    });
+    // Validate address
+    const toAddress = validateAddress(to);
+    // Validate data
+    if (!data || !data.startsWith("0x")) {
+        throw new Error("Invalid transaction data. Must be hex string starting with 0x");
+    }
+    // Get gas configuration
+    const gasConfig = await getGasConfig(publicClient, options);
+    // Estimate gas (don't include gas config in estimation)
+    let estimatedGas;
+    try {
+        estimatedGas = await publicClient.estimateGas({
+            account: from,
+            to: toAddress,
+            data,
+            value,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to estimate gas: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    // Check ETH balance for gas + value
+    const ethBalance = await publicClient.getBalance({ address: from });
+    const estimatedGasCost = (gasConfig.gas || estimatedGas) *
+        (gasConfig.gasPrice || gasConfig.maxFeePerGas || 0n);
+    const totalNeeded = value + estimatedGasCost;
+    if (ethBalance < totalNeeded) {
+        throw new Error(`Insufficient ETH. Need ${formatEther(totalNeeded)} ETH (${formatEther(value)} value + ${formatEther(estimatedGasCost)} gas)`);
+    }
+    // Show summary
+    if (!options.silent) {
+        console.log(chalk.cyan(`\n📤 Sending custom transaction to ${toAddress}...`));
+        console.log(chalk.dim(`Data: ${data.substring(0, 66)}...`));
+        console.log(chalk.dim(`Value: ${formatEther(value)} ETH`));
+        console.log(chalk.dim(`Estimated Gas: ${estimatedGas.toString()}`));
+    }
+    // Dry run mode
+    if (options.dryRun) {
+        if (!options.silent) {
+            console.log(chalk.yellow("\n🔍 Dry Run Mode - Transaction not broadcast\n"));
+        }
+        return {
+            success: true,
+            type: "custom",
+            from,
+            to: toAddress,
+            gasUsed: estimatedGas,
+        };
+    }
+    // Build transaction
+    // Note: Don't include 'account' field - walletClient already has it configured
+    const txRequest = {
+        to: toAddress,
+        data,
+        value,
+        gas: gasConfig.gas || estimatedGas,
+        ...gasConfig,
+    };
+    // Set nonce if provided
+    if (options.nonce !== undefined) {
+        txRequest.nonce = options.nonce;
+    }
+    const txHash = await walletClient.sendTransaction(txRequest);
+    let result = {
+        success: true,
+        type: "custom",
+        txHash,
+        from,
+        to: toAddress,
+    };
+    // Wait for confirmation if requested
+    if (options.wait) {
+        if (!options.silent) {
+            console.log(chalk.cyan(`⏳ Waiting for confirmation...`));
+        }
+        const receipt = await publicClient.waitForTransactionReceipt({
+            hash: txHash,
+            timeout: (options.timeout || 300) * 1000,
+        });
+        result.gasUsed = receipt.gasUsed;
+        result.blockNumber = receipt.blockNumber;
+        result.confirmations = 1;
+        if (!options.silent) {
+            console.log(chalk.green(`✅ Transaction confirmed in block ${receipt.blockNumber.toString()}`));
+        }
+    }
+    return result;
+}
+/**
+ * Display send result for interactive mode
+ */
+export function displaySendResult(result) {
+    console.log();
+    printSuccess(result.success ? "Transaction sent successfully!" : "Transaction failed");
+    const boxData = {
+        Type: chalk.cyan(result.type.toUpperCase()),
+        From: formatAddress(result.from),
+        To: formatAddress(result.to),
+    };
+    if (result.amount) {
+        boxData["Amount"] = chalk.green(result.amount + (result.tokenSymbol ? ` ${result.tokenSymbol}` : " ETH"));
+    }
+    if (result.tokenAddress) {
+        boxData["Token"] = formatAddress(result.tokenAddress);
+    }
+    if (result.txHash) {
+        boxData["Transaction"] = chalk.blue(result.txHash);
+    }
+    if (result.gasUsed) {
+        boxData["Gas Used"] = result.gasUsed.toString();
+    }
+    if (result.blockNumber) {
+        boxData["Block"] = result.blockNumber.toString();
+    }
+    if (result.error) {
+        boxData["Error"] = chalk.red(result.error);
+    }
+    printBox("Send Result", boxData);
+    console.log();
+}
+/**
+ * Display batch send results
+ */
+export function displayBatchResults(results) {
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    console.log();
+    printSuccess(`Batch send completed: ${successful.length} successful, ${failed.length} failed`);
+    console.log(chalk.magenta.bold("📦 Batch Send Summary"));
+    console.log();
+    const table = new Table({
+        head: [
+            chalk.blue.bold("Status"),
+            chalk.cyan.bold("Type"),
+            chalk.green.bold("To"),
+            chalk.yellow.bold("Amount"),
+            chalk.magenta.bold("Tx Hash"),
+        ],
+        colAligns: ["left", "left", "left", "right", "left"],
+    });
+    for (const result of results) {
+        const status = result.success ? chalk.green("✅") : chalk.red("❌");
+        const type = result.type.toUpperCase();
+        const to = formatAddress(result.to);
+        const amount = result.amount
+            ? result.amount + (result.tokenSymbol ? ` ${result.tokenSymbol}` : " ETH")
+            : "-";
+        const txHash = result.txHash
+            ? chalk.blue(result.txHash.substring(0, 20) + "...")
+            : chalk.red(result.error || "-");
+        table.push([status, type, to, amount, txHash]);
+    }
+    console.log(table.toString());
+    console.log();
+    console.log(chalk.green(`✅ Successful: ${successful.length}`));
+    if (failed.length > 0) {
+        console.log(chalk.red(`❌ Failed: ${failed.length}`));
+    }
+    console.log();
+}
+//# sourceMappingURL=send.js.map