@bankr/cli 0.3.1 → 0.3.8

package/dist/commands/llm.js

@@ -5,8 +5,7 @@ import { spawn } from "child_process";
 import { CLI_USER_AGENT, getApiUrl, getLlmKey, getLlmUrl, requireApiKey, } from "../lib/config.js";
 import { getBalances } from "../lib/api.js";
 import * as output from "../lib/output.js";
-import { bankrTheme } from "../lib/output.js";
-const ERR_LLM_NOT_ENABLED = "LLM Gateway not enabled on this API key. Enable at bankr.bot/api";
+const ERR_LLM_NOT_ENABLED = "LLM Gateway not enabled on this API key. Enable at bankr.bot/api-keys";
 /**
  * Fallback model catalog — used when the gateway is unreachable or unauthenticated.
  * resolveModels() fetches live data from GET /v1/models; this list is the offline safety net.
@@ -171,6 +170,15 @@ const GATEWAY_MODELS = [
         cost: { input: 0.05, output: 0.4, cacheRead: 0.005, cacheWrite: 0 },
     },
     // Other providers
+    {
+        id: "grok-4.3",
+        name: "Grok 4.3",
+        owned_by: "x-ai",
+        contextWindow: 1000000,
+        maxTokens: 1000000,
+        input: IMAGE_INPUT,
+        cost: { input: 1.25, output: 2.5, cacheRead: 0.2, cacheWrite: 0 },
+    },
     {
         id: "grok-4.1-fast",
         name: "Grok 4.1 Fast",
@@ -198,6 +206,24 @@ const GATEWAY_MODELS = [
         input: TEXT_INPUT,
         cost: { input: 0.12, output: 0.75, cacheRead: 0.06, cacheWrite: 0 },
     },
+    {
+        id: "qwen3.7-plus",
+        name: "Qwen3.7 Plus",
+        owned_by: "qwen",
+        contextWindow: 1000000,
+        maxTokens: 65536,
+        input: TEXT_INPUT,
+        cost: { input: 0.4, output: 1.6, cacheRead: 0.04, cacheWrite: 0 },
+    },
+    {
+        id: "qwen3.6-flash",
+        name: "Qwen3.6 Flash",
+        owned_by: "qwen",
+        contextWindow: 1000000,
+        maxTokens: 65536,
+        input: TEXT_INPUT,
+        cost: { input: 0.25, output: 1.5, cacheRead: 0, cacheWrite: 0 },
+    },
     {
         id: "qwen3.5-plus",
         name: "Qwen3.5 Plus",
@@ -216,6 +242,15 @@ const GATEWAY_MODELS = [
         input: TEXT_INPUT,
         cost: { input: 0.1, output: 0.4, cacheRead: 0, cacheWrite: 0 },
     },
+    {
+        id: "kimi-k2.7-code",
+        name: "Kimi K2.7 Code",
+        owned_by: "moonshotai",
+        contextWindow: 262144,
+        maxTokens: 262144,
+        input: TEXT_INPUT,
+        cost: { input: 0.95, output: 4.0, cacheRead: 0.19, cacheWrite: 0 },
+    },
     {
         id: "kimi-k2.6",
         name: "Kimi K2.6",
@@ -422,6 +457,89 @@ export async function creditsCommand() {
     }
 }
 /* ─────────────────────── bankr llm credits add ──────────────────────────── */
+// Keep in sync with packages/shared/src/chain-config-base/chainConfigBase.ts.
+// CLI is standalone-published and cannot depend on @bankr/shared.
+const TOPUP_CHAINS = ["base", "polygon", "mainnet", "arbitrum", "bnb"];
+const CHAIN_DISPLAY_NAME = {
+    base: "Base",
+    polygon: "Polygon",
+    mainnet: "Ethereum",
+    arbitrum: "Arbitrum",
+    bnb: "BNB Chain",
+};
+// Polygon's native POL is at a precompile, not the 0xeee placeholder.
+const NATIVE_TOKEN_ADDRESS_BY_CHAIN = {
+    base: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+    polygon: "0x0000000000000000000000000000000000001010",
+    mainnet: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+    arbitrum: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+    bnb: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+};
+const BLOCK_EXPLORER_URL = {
+    base: "https://basescan.org",
+    polygon: "https://polygonscan.com",
+    mainnet: "https://etherscan.io",
+    arbitrum: "https://arbiscan.io",
+    bnb: "https://bscscan.com",
+};
+/**
+ * Resolve user input (symbol or 0x address) to the (chain, token) it should
+ * pay with. Scans every supported chain and picks the highest USD balance,
+ * so the user never has to think about chains. Returns null if nothing matches.
+ */
+function resolveTokenAcrossChains(input, balances) {
+    const isAddress = input.startsWith("0x");
+    const sym = isAddress ? null : input.toUpperCase();
+    const candidates = [];
+    for (const chain of TOPUP_CHAINS) {
+        const chainBal = balances[chain];
+        if (!chainBal)
+            continue;
+        if (!isAddress) {
+            const nativeUsd = parseFloat(chainBal.nativeUsd || "0");
+            const nativeSym = nativeSymbolFor(chain);
+            if (sym === nativeSym && nativeUsd > 0) {
+                candidates.push({
+                    chain,
+                    address: NATIVE_TOKEN_ADDRESS_BY_CHAIN[chain],
+                    symbol: nativeSym,
+                    name: nativeSym,
+                    decimals: 18,
+                    balance: parseFloat(chainBal.nativeBalance || "0"),
+                    balanceUsd: nativeUsd,
+                });
+            }
+        }
+        for (const tb of chainBal.tokenBalances) {
+            const matchesSym = sym != null && tb.token.baseToken.symbol.toUpperCase() === sym;
+            const matchesAddr = isAddress &&
+                tb.token.baseToken.address.toLowerCase() === input.toLowerCase();
+            if (!matchesSym && !matchesAddr)
+                continue;
+            candidates.push({
+                chain,
+                address: tb.token.baseToken.address,
+                symbol: tb.token.baseToken.symbol,
+                name: tb.token.baseToken.name,
+                decimals: tb.token.baseToken.decimals,
+                balance: tb.token.balance,
+                balanceUsd: tb.token.balanceUSD,
+                imageUrl: tb.token.baseToken.imgUrl,
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => b.balanceUsd - a.balanceUsd);
+    return candidates[0];
+}
+function nativeSymbolFor(chain) {
+    if (chain === "polygon")
+        return "POL";
+    if (chain === "bnb")
+        return "BNB";
+    return "ETH";
+}
 export async function creditsAddCommand(amount, opts) {
     const apiKey = requireApiKey();
     const apiUrl = getApiUrl();
@@ -433,9 +551,9 @@ export async function creditsAddCommand(amount, opts) {
         output.error("Amount must be between $1 and $1,000");
         process.exit(1);
     }
-    // Fetch current balance for display (skip when --yes since user won't see it)
+    // Fetch current balance for display (skip when --yes/--not-interactive since user won't see it)
     let currentBalance = "unknown";
-    if (llmKey && !opts.yes) {
+    if (llmKey && !opts.yes && !output.isNonInteractive()) {
         const balSpin = output.spinner("Fetching balance…");
         try {
             const balRes = await fetch(`${llmUrl}/v1/credits`, {
@@ -457,18 +575,41 @@ export async function creditsAddCommand(amount, opts) {
             output.dim(`  (Could not fetch balance: ${err.message})`);
         }
     }
+    // When --token is passed, the chain holding the highest USD balance of
+    // that symbol/address wins. Default (no --token) is Base USDC.
+    let resolved = null;
+    if (opts.token) {
+        const resolveSpin = output.spinner("Resolving token…");
+        try {
+            const balData = await getBalances([...TOPUP_CHAINS]);
+            resolved = resolveTokenAcrossChains(opts.token, balData.balances);
+            resolveSpin.stop();
+        }
+        catch (err) {
+            resolveSpin.stop();
+            output.warn(`Could not fetch balances: ${err.message}`);
+        }
+        if (!resolved) {
+            output.error(`Token "${opts.token}" not found in your wallet on any supported chain.`);
+            process.exit(1);
+        }
+    }
+    const targetChain = resolved?.chain ?? "base";
+    const sourceTokenLabel = resolved
+        ? `${resolved.symbol} on ${CHAIN_DISPLAY_NAME[targetChain]}`
+        : `USDC on ${CHAIN_DISPLAY_NAME.base} (default)`;
     // Show confirmation
     console.log();
     output.label("Add Credits", `$${amountUsd.toFixed(2)}`);
-    output.keyValue("Source token", opts.token ?? "USDC (default)");
+    output.keyValue("Pay with", sourceTokenLabel);
     output.keyValue("Current balance", currentBalance);
     console.log();
-    if (!opts.yes) {
+    if (!opts.yes && !output.isNonInteractive()) {
         const { confirm } = await import("@inquirer/prompts");
         const proceed = await confirm({
             message: "Proceed?",
             default: true,
-            theme: bankrTheme,
+            theme: output.bankrTheme,
         });
         if (!proceed) {
             output.dim("Cancelled.");
@@ -477,9 +618,12 @@ export async function creditsAddCommand(amount, opts) {
     }
     const spin = output.spinner("Adding credits…");
     try {
-        const body = { amountUsd };
-        if (opts.token) {
-            body.sourceToken = opts.token;
+        const body = {
+            amountUsd,
+            chain: targetChain,
+        };
+        if (resolved) {
+            body.sourceToken = resolved.address;
         }
         const res = await fetch(`${apiUrl}/llm/credits/topup`, {
             method: "POST",
@@ -516,7 +660,7 @@ export async function creditsAddCommand(amount, opts) {
         output.success(`Added $${result.creditsGranted.toFixed(2)} credits`);
         output.label("New Balance", `$${result.newBalance.toFixed(2)}`);
         if (result.txHash) {
-            output.keyValue("Transaction", `https://basescan.org/tx/${result.txHash}`);
+            output.keyValue("Transaction", `${BLOCK_EXPLORER_URL[targetChain]}/tx/${result.txHash}`);
         }
     }
     catch (err) {
@@ -632,45 +776,27 @@ export async function creditsAutoCommand(opts) {
             process.exit(1);
         }
         const resolved = [];
-        // Fetch balances to resolve both symbols and addresses
+        // Highest USD balance wins when the same symbol exists on multiple chains.
         const spin = output.spinner("Resolving tokens…");
-        let baseTokens = [];
-        let hasNativeEth = false;
+        let balances = {};
         try {
-            const balData = await getBalances(["base"]);
-            const baseChain = balData.balances.base;
-            baseTokens = baseChain?.tokenBalances ?? [];
-            hasNativeEth = !!baseChain && parseFloat(baseChain.nativeBalance) > 0;
+            const balData = await getBalances([...TOPUP_CHAINS]);
+            balances = balData.balances;
         }
         catch {
             output.warn("Could not fetch balances for token resolution");
         }
         spin.stop();
         for (const input of inputs) {
-            const isAddress = input.startsWith("0x");
-            const sym = isAddress ? null : input.toUpperCase();
-            // Native ETH
-            if (sym === "ETH" && hasNativeEth) {
-                resolved.push({
-                    address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-                    chain: "base",
-                    symbol: "ETH",
-                    name: "Ethereum",
-                    decimals: 18,
-                });
-                continue;
-            }
-            const tb = baseTokens.find((t) => isAddress
-                ? t.token.baseToken.address.toLowerCase() === input.toLowerCase()
-                : t.token.baseToken.symbol.toUpperCase() === sym);
-            if (tb) {
+            const hit = resolveTokenAcrossChains(input, balances);
+            if (hit) {
                 resolved.push({
-                    address: tb.token.baseToken.address,
-                    chain: "base",
-                    symbol: tb.token.baseToken.symbol,
-                    name: tb.token.baseToken.name,
-                    decimals: tb.token.baseToken.decimals,
-                    imageUrl: tb.token.baseToken.imgUrl,
+                    address: hit.address,
+                    chain: hit.chain,
+                    symbol: hit.symbol,
+                    name: hit.name,
+                    decimals: hit.decimals,
+                    imageUrl: hit.imageUrl,
                 });
             }
             else {

package/dist/commands/login.d.ts

@@ -13,7 +13,6 @@ export declare function loginCommand(opts: {
     url?: boolean;
     siwe?: boolean;
     privateKey?: string;
-    partnerKey?: string;
     allowedIps?: string;
     allowedRecipients?: string;
 }): Promise<void>;

package/dist/commands/login.js

@@ -4,7 +4,7 @@ import open from "open";
 import { isAddress } from "viem";
 import { CLI_USER_AGENT, DEFAULT_API_URL, getApiUrl, getConfigPath, readConfig, writeConfig, } from "../lib/config.js";
 import * as output from "../lib/output.js";
-const DEFAULT_DASHBOARD_URL = "https://bankr.bot/api";
+const DEFAULT_DASHBOARD_URL = "https://bankr.bot/api-keys";
 const MAX_OTP_ATTEMPTS = 3;
 const INVALID_CODE_STATUSES = [400, 401, 422];
 function fatal(message) {
@@ -15,7 +15,8 @@ function deriveDashboardUrl(apiUrl) {
     if (apiUrl === DEFAULT_API_URL) {
         return DEFAULT_DASHBOARD_URL;
     }
-    return (apiUrl.replace(/\/+$/, "").replace("api.", "").replace("api-", "") + "/api");
+    return (apiUrl.replace(/\/+$/, "").replace("api.", "").replace("api-", "") +
+        "/api-keys");
 }
 async function fetchPrivyConfig(apiUrl) {
     const res = await fetch(`${apiUrl}/cli/config`, {
@@ -220,8 +221,8 @@ async function emailLoginFlow(apiUrl, opts) {
     if (wallet.solAddress) {
         output.dim(`  SOL:  ${wallet.solAddress}`);
     }
-    // Headless mode: when --code is provided, skip all interactive prompts
-    const headless = !!opts.code;
+    // Headless mode: when --code is provided or --ni is set, skip prompts
+    const headless = !!opts.code || output.isNonInteractive();
     // Step 3: Accept terms if needed
     if (!wallet.hasAcceptedTerms) {
         output.blank();
@@ -263,7 +264,7 @@ async function emailLoginFlow(apiUrl, opts) {
     // Fine-grained API flags. walletApi and tokenLaunch default to enabled.
     // --read-write only controls readOnly, not which APIs are enabled.
     const enableWallet = opts.walletApi ?? true;
-    // Agent API must be enabled from the website (bankr.bot/api), not the CLI.
+    // Agent API must be enabled from the website (bankr.bot/api-keys), not the CLI.
     const enableAgent = false;
     const enableTokenLaunch = opts.tokenLaunch ?? true;
     const enableLlm = opts.llm ??
@@ -317,8 +318,8 @@ async function emailLoginFlow(apiUrl, opts) {
         ];
         output.dim(`  Recipients: ${parts.join(", ")}`);
     }
-    output.dim("  Agent API: enable at bankr.bot/api");
-    output.dim("  Manage keys at bankr.bot/api");
+    output.dim("  Agent API: enable at bankr.bot/api-keys");
+    output.dim("  Manage keys at bankr.bot/api-keys");
     return apiKeyResult.apiKey;
 }
 // ── SIWE login flow ─────────────────────────────────────────────────
@@ -365,7 +366,6 @@ async function siweLoginFlow(apiUrl, opts) {
         body: JSON.stringify({
             message,
             signature,
-            partnerApiKey: opts.partnerKey,
             keyName: opts.keyName ?? `SIWE-${new Date().toISOString().slice(0, 10)}`,
             readOnly: opts.readOnly ?? false,
             walletApiEnabled: opts.walletApi ?? true,
@@ -395,7 +395,7 @@ async function siweLoginFlow(apiUrl, opts) {
 async function validateApiKey(apiUrl, apiKey) {
     const spin = output.spinner("Validating Bankr API key...");
     try {
-        const res = await fetch(`${apiUrl}/agent/me`, {
+        const res = await fetch(`${apiUrl}/wallet/me`, {
             headers: { "X-API-Key": apiKey, "User-Agent": CLI_USER_AGENT },
         });
         if (res.ok) {
@@ -404,20 +404,14 @@ async function validateApiKey(apiUrl, apiKey) {
         else if (res.status === 401 || res.status === 403) {
             const body = (await res.json().catch(() => ({})));
             const errorType = body.error ?? "";
-            if (res.status === 403 || errorType === "Agent API access not enabled") {
-                spin.warn("Agent API access is not enabled");
-                output.warn("Your API key is valid but does not have Agent API access enabled.");
-                output.info("Go to https://bankr.bot/api and enable Agent API access for this key.");
-                output.info("Your key has been saved — once enabled, the CLI will work without re-login.");
-            }
-            else if (errorType === "Authentication required") {
+            if (errorType === "Authentication required") {
                 spin.fail("API key is not linked to a wallet");
-                output.error("This API key is not associated with a wallet. Generate a new key at https://bankr.bot/api");
+                output.error("This API key is not associated with a wallet. Generate a new key at https://bankr.bot/api-keys");
                 process.exit(1);
             }
             else {
                 spin.fail("Invalid Bankr API key");
-                output.error("The provided API key is invalid or inactive. Generate a new key at https://bankr.bot/api");
+                output.error("The provided API key is invalid or inactive. Generate a new key at https://bankr.bot/api-keys");
                 process.exit(1);
             }
         }
@@ -497,13 +491,28 @@ export async function loginCommand(opts) {
     if (opts.apiKey !== undefined && !opts.apiKey.trim()) {
         fatal("--api-key requires a non-empty value");
     }
+    // Non-interactive mode requires a headless flag combo. Without one, the
+    // command would hang on a prompt — fail fast with the available paths.
+    // Email step 1 (`login email <addr>` without --code) is also headless:
+    // it sends the OTP and exits.
+    if (output.isNonInteractive()) {
+        const hasHeadlessFlag = opts.apiKey ||
+            opts.url ||
+            (opts.siwe && opts.privateKey) ||
+            (opts.email && opts.email.trim());
+        if (!hasHeadlessFlag) {
+            output.error("Non-interactive login requires one of: --api-key <key>, login siwe --private-key <key>, or login email <address> [--code <otp>]");
+            process.exit(1);
+        }
+    }
     const config = readConfig();
     const resolvedApiUrl = opts.apiUrl ?? getApiUrl();
     if (resolvedApiUrl !== DEFAULT_API_URL) {
         const nonInteractive = !!(opts.apiKey ||
             opts.url ||
             opts.email !== undefined ||
-            opts.siwe);
+            opts.siwe ||
+            output.isNonInteractive());
         if (nonInteractive) {
             config.apiUrl = resolvedApiUrl;
         }
@@ -557,7 +566,6 @@ export async function loginCommand(opts) {
         }
         const { apiKey } = await siweLoginFlow(apiUrl, {
             privateKey: opts.privateKey,
-            partnerKey: opts.partnerKey,
             keyName: opts.keyName,
             readOnly: !opts.readWrite,
             walletApi: opts.walletApi,
@@ -565,9 +573,6 @@ export async function loginCommand(opts) {
             ...getParsedRestrictions(),
         });
         config.apiKey = apiKey;
-        if (opts.partnerKey) {
-            config.partnerKey = opts.partnerKey;
-        }
         writeConfig(config);
         output.success(`Credentials saved to ${getConfigPath()}`);
         return;

package/dist/commands/prompt.js

@@ -6,6 +6,9 @@ import * as output from "../lib/output.js";
  *  Must be manually kept in sync with models in the LLM gateway DB. */
 const VALID_MAX_MODE_MODELS = new Set([
     // Claude (Vertex AI)
+    "claude-fable-5",
+    "claude-opus-4.8",
+    "claude-opus-4.7",
     "claude-opus-4.6",
     "claude-opus-4.5",
     "claude-sonnet-4.6",
@@ -26,11 +29,13 @@ const VALID_MAX_MODE_MODELS = new Set([
     "deepseek-v3.2",
     // Qwen (OpenRouter)
     "qwen3-coder",
+    "qwen3.7-plus",
     "qwen3.5-plus",
     // MiniMax (direct)
     "minimax-m2.5",
     "minimax-m2.7",
     // Other (OpenRouter)
+    "kimi-k2.7-code",
     "kimi-k2.6",
     "kimi-k2.5",
     "glm-5",

package/dist/commands/swap.d.ts

@@ -0,0 +1,8 @@
+export declare function swapCommand(opts: {
+    from: string;
+    to: string;
+    amount: string;
+    chain?: string;
+    quoteOnly?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=swap.d.ts.map

package/dist/commands/swap.js

@@ -0,0 +1,107 @@
+import { getSwapQuote, executeSwap } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { NATIVE_SYMBOLS, VALID_CHAINS } from "../lib/chains.js";
+import { ZERO_ADDRESS, resolveTokenSymbol } from "../lib/tokens.js";
+/**
+ * Resolve a token symbol or address to a contract address for swapping.
+ * - The chain's native ticker (ETH/POL/BNB) or the zero address → native, sent
+ *   as the zero address (the API detects + sanitizes native tokens).
+ * - Otherwise → symbol/address resolution via the shared resolver.
+ */
+async function resolveSwapToken(tokenInput, chain) {
+    const input = tokenInput.trim();
+    const nativeSymbol = NATIVE_SYMBOLS[chain] ?? "ETH";
+    const upper = input.toUpperCase();
+    const isNative = upper === nativeSymbol.toUpperCase() ||
+        input.toLowerCase() === ZERO_ADDRESS;
+    if (isNative) {
+        return { address: ZERO_ADDRESS, symbol: nativeSymbol };
+    }
+    return resolveTokenSymbol(input, chain);
+}
+export async function swapCommand(opts) {
+    const chain = opts.chain ?? "base";
+    if (!VALID_CHAINS.has(chain) || chain === "solana") {
+        output.error(`Unsupported chain "${chain}". Swaps support EVM chains: base, polygon, mainnet, unichain, worldchain, arbitrum, bnb.`);
+        process.exit(1);
+    }
+    // Validate amount client-side so a bad value gives a clear error instead of a
+    // generic 500 from the API's parseUnits(amount, decimals). Number() alone
+    // accepts "1e-3" / "0x10" / "Infinity" that parseUnits rejects, so require a
+    // plain decimal string.
+    if (!/^\d*\.?\d+$/.test(opts.amount) || Number(opts.amount) <= 0) {
+        output.error(`Invalid amount "${opts.amount}". Provide a positive decimal number, e.g. --amount 0.5.`);
+        process.exit(1);
+    }
+    // Resolve from/to tokens (symbol → address, native → zero address)
+    let fromToken;
+    let toToken;
+    const resolveSpin = output.spinner(`Resolving ${opts.from} → ${opts.to} on ${chain}...`);
+    try {
+        [fromToken, toToken] = await Promise.all([
+            resolveSwapToken(opts.from, chain),
+            resolveSwapToken(opts.to, chain),
+        ]);
+        resolveSpin.stop();
+    }
+    catch (err) {
+        resolveSpin.fail(err.message);
+        process.exit(1);
+    }
+    // Quote
+    const quoteSpin = output.spinner(`Fetching quote for ${opts.amount} ${fromToken.symbol} → ${toToken.symbol}...`);
+    let quote;
+    try {
+        quote = await getSwapQuote({
+            fromChain: chain,
+            fromToken: fromToken.address,
+            toChain: chain,
+            toToken: toToken.address,
+            amount: opts.amount,
+        });
+        quoteSpin.stop();
+    }
+    catch (err) {
+        quoteSpin.fail(`Quote failed: ${err.message}`);
+        process.exit(1);
+    }
+    output.blank();
+    output.label("You pay", `${output.formatBalance(quote.from.formattedAmount)} ${quote.from.symbol} (${output.formatUsd(quote.from.usdValue)})`);
+    output.label("You receive", `~${output.formatBalance(quote.to.formattedAmount)} ${quote.to.symbol} (${output.formatUsd(quote.to.usdValue)})`);
+    output.keyValue("Min received", `${output.formatBalance(quote.minBuyAmount)} ${quote.to.symbol}`);
+    output.blank();
+    if (opts.quoteOnly) {
+        return;
+    }
+    // Execute (uses the minBuyAmount from the quote as slippage protection)
+    const swapSpin = output.spinner(`Swapping ${opts.amount} ${fromToken.symbol} → ${toToken.symbol}...`);
+    try {
+        const result = await executeSwap({
+            fromChain: chain,
+            fromToken: fromToken.address,
+            toChain: chain,
+            toToken: toToken.address,
+            amount: opts.amount,
+            minBuyAmount: quote.minBuyAmount,
+        });
+        if (!result.success) {
+            swapSpin.fail(`Swap failed: ${result.error ?? "unknown error"}`);
+            // A reverted tx can come back as { success: false } with a hash — surface
+            // it so the user can inspect the failed transaction on-chain.
+            if (result.hash) {
+                output.label("Tx Hash", result.hash);
+            }
+            process.exit(1);
+        }
+        swapSpin.succeed("Swap successful");
+        output.label("Tx Hash", result.hash ?? "unknown");
+        if (result.amountReceived != null) {
+            output.label("Received", `${output.formatBalance(result.amountReceived)} ${toToken.symbol}`);
+        }
+    }
+    catch (err) {
+        swapSpin.fail(`Swap failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=swap.js.map