@bankr/cli 0.1.3 → 0.2.0

package/dist/commands/llm.js

@@ -125,6 +125,24 @@ const GATEWAY_MODELS = [
         input: IMAGE_INPUT,
         cost: { input: 2.5, output: 15.0, cacheRead: 0.25, cacheWrite: 0 },
     },
+    {
+        id: "gpt-5.4-mini",
+        name: "GPT 5.4 Mini",
+        owned_by: "openai",
+        contextWindow: 400000,
+        maxTokens: 128000,
+        input: IMAGE_INPUT,
+        cost: { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
+    },
+    {
+        id: "gpt-5.4-nano",
+        name: "GPT 5.4 Nano",
+        owned_by: "openai",
+        contextWindow: 400000,
+        maxTokens: 128000,
+        input: IMAGE_INPUT,
+        cost: { input: 0.2, output: 1.25, cacheRead: 0.02, cacheWrite: 0 },
+    },
     {
         id: "gpt-5.2",
         name: "GPT 5.2",
@@ -225,6 +243,24 @@ const GATEWAY_MODELS = [
         input: TEXT_INPUT,
         cost: { input: 0.27, output: 0.95, cacheRead: 0.03, cacheWrite: 0 },
     },
+    {
+        id: "minimax-m2.7",
+        name: "MiniMax M2.7",
+        owned_by: "minimax",
+        contextWindow: 204800,
+        maxTokens: 131072,
+        input: TEXT_INPUT,
+        cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
+    },
+    {
+        id: "glm-5",
+        name: "GLM-5",
+        owned_by: "z-ai",
+        contextWindow: 202752,
+        maxTokens: 131072,
+        input: TEXT_INPUT,
+        cost: { input: 0.72, output: 2.3, cacheRead: 0, cacheWrite: 0 },
+    },
 ];
 /** Fetch live model list from the gateway; falls back to hardcoded catalog. */
 async function resolveModels() {
@@ -261,6 +297,7 @@ async function resolveModels() {
                         cacheRead: 0,
                         cacheWrite: 0,
                     }),
+                ...(m.deprecation && { deprecation: m.deprecation }),
             };
         });
         return { models, live: true };
@@ -306,10 +343,17 @@ export async function modelsCommand() {
     output.brandBold("Bankr LLM Gateway — Available Models");
     console.log();
     const COL = { id: 24, name: 24, provider: 12 };
-    console.log(`  ${output.fmt.brandBold("Model ID".padEnd(COL.id))} ${output.fmt.brandBold("Name".padEnd(COL.name))} ${output.fmt.brandBold("Provider")}`);
-    console.log(output.fmt.dim(`  ${"─".repeat(COL.id + COL.name + COL.provider + 2)}`));
+    const hasDeprecated = models.some((m) => m.deprecation);
+    console.log(`  ${output.fmt.brandBold("Model ID".padEnd(COL.id))} ${output.fmt.brandBold("Name".padEnd(COL.name))} ${output.fmt.brandBold("Provider".padEnd(COL.provider))}${hasDeprecated ? ` ${output.fmt.brandBold("Notes")}` : ""}`);
+    console.log(output.fmt.dim(`  ${"─".repeat(COL.id + COL.name + COL.provider + (hasDeprecated ? 24 : 2))}`));
     for (const m of models) {
-        console.log(`  ${output.fmt.brand(m.id.padEnd(COL.id))} ${m.name.padEnd(COL.name)} ${output.fmt.dim(m.owned_by)}`);
+        let notes = "";
+        if (m.deprecation) {
+            notes = m.deprecation.replaced_by
+                ? `deprecated → ${m.deprecation.replaced_by}`
+                : "deprecated";
+        }
+        console.log(`  ${output.fmt.brand(m.id.padEnd(COL.id))} ${m.name.padEnd(COL.name)} ${output.fmt.dim(m.owned_by.padEnd(COL.provider))} ${notes ? output.fmt.dim(notes) : ""}`);
     }
     console.log();
     output.dim(`  Gateway: ${getLlmUrl()}`);

package/dist/commands/login.d.ts

@@ -6,11 +6,16 @@ export declare function loginCommand(opts: {
     acceptTerms?: boolean;
     keyName?: string;
     readWrite?: boolean;
+    walletApi?: boolean;
+    agentApi?: boolean;
+    tokenLaunch?: boolean;
     llm?: boolean;
     llmKey?: string;
     url?: boolean;
     siwe?: boolean;
     privateKey?: string;
     partnerKey?: string;
+    allowedIps?: string;
+    allowedRecipients?: string;
 }): Promise<void>;
 //# sourceMappingURL=login.d.ts.map

package/dist/commands/login.js

@@ -1,5 +1,7 @@
 import { confirm, input, select } from "@inquirer/prompts";
+import { isIP } from "node:net";
 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";
@@ -218,17 +220,21 @@ 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;
     // Step 3: Accept terms if needed
     if (!wallet.hasAcceptedTerms) {
         output.blank();
         output.dim("  Please review our Terms of Service: https://bankr.bot/terms");
         output.blank();
         const accepted = opts.acceptTerms ??
-            (await confirm({
-                message: "Do you accept the Terms of Service?",
-                default: false,
-                theme: output.bankrTheme,
-            }));
+            (headless
+                ? false
+                : await confirm({
+                    message: "Do you accept the Terms of Service?",
+                    default: false,
+                    theme: output.bankrTheme,
+                }));
         if (!accepted) {
             fatal("Terms must be accepted to continue.");
         }
@@ -246,37 +252,49 @@ async function emailLoginFlow(apiUrl, opts) {
     output.blank();
     const defaultKeyName = `CLI-${new Date().toISOString().slice(0, 10)}`;
     const keyName = opts.keyName ??
-        (await input({
-            message: "Key name:",
-            default: defaultKeyName,
-            theme: output.bankrTheme,
-            validate: (v) => v.trim().length >= 3 ? true : "Name must be at least 3 characters.",
-        }));
-    const enableWrite = opts.readWrite ??
-        (await confirm({
-            message: "Enable write operations?",
-            default: false,
-            theme: output.bankrTheme,
-        }));
-    if (enableWrite) {
-        output.dim("  Includes: transactions, transfers, automations, order management");
-    }
-    else {
-        output.dim("  Read-only: portfolio, balances, prices, research");
-    }
+        (headless
+            ? defaultKeyName
+            : await input({
+                message: "Key name:",
+                default: defaultKeyName,
+                theme: output.bankrTheme,
+                validate: (v) => v.trim().length >= 3 ? true : "Name must be at least 3 characters.",
+            }));
+    // 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;
+    const enableAgent = opts.agentApi ??
+        (headless
+            ? false
+            : await confirm({
+                message: "Enable Agent API? (AI prompts)",
+                default: false,
+                theme: output.bankrTheme,
+            }));
+    const enableTokenLaunch = opts.tokenLaunch ?? true;
     const enableLlm = opts.llm ??
-        (await confirm({
-            message: "Enable LLM gateway?",
-            default: false,
-            theme: output.bankrTheme,
-        }));
+        (headless
+            ? false
+            : await confirm({
+                message: "Enable LLM gateway?",
+                default: false,
+                theme: output.bankrTheme,
+            }));
+    if (opts.readWrite && !enableWallet && !enableAgent) {
+        output.warn("--read-write has no effect when both Wallet API and Agent API are disabled");
+    }
     const keySpin = output.spinner("Generating API key...");
     let apiKeyResult;
     try {
         apiKeyResult = await callGenerateApiKey(apiUrl, identityToken, {
             name: keyName.trim(),
-            agentApiEnabled: { readOnly: !enableWrite },
+            walletApiEnabled: enableWallet,
+            agentApiEnabled: enableAgent,
+            readOnly: opts.readWrite ? false : undefined,
+            tokenLaunchApiEnabled: enableTokenLaunch,
             llmGatewayEnabled: enableLlm,
+            allowedIps: opts.allowedIps,
+            allowedRecipients: opts.allowedRecipients,
         });
         keySpin.stop();
     }
@@ -286,10 +304,25 @@ async function emailLoginFlow(apiUrl, opts) {
     }
     // Show result
     output.blank();
-    const mode = enableWrite ? "read-write" : "read-only";
+    const features = [
+        enableWallet && "Wallet",
+        enableAgent && "Agent",
+        enableTokenLaunch && "Token Launch",
+        enableLlm && "LLM",
+    ].filter(Boolean);
     output.success(`API key "${apiKeyResult.name}" saved`);
-    output.dim(`  Mode: ${mode}`);
+    output.dim(`  Features: ${features.length ? features.join(", ") : "none"}`);
     output.dim(`  LLM:  ${apiKeyResult.llmGatewayEnabled ? "enabled" : "disabled"}`);
+    if (opts.allowedIps) {
+        output.dim(`  IPs:  ${opts.allowedIps.join(", ")}`);
+    }
+    if (opts.allowedRecipients) {
+        const parts = [
+            ...(opts.allowedRecipients.evm ?? []),
+            ...(opts.allowedRecipients.solana ?? []),
+        ];
+        output.dim(`  Recipients: ${parts.join(", ")}`);
+    }
     output.dim("  Manage keys at bankr.bot/api");
     return apiKeyResult.apiKey;
 }
@@ -340,6 +373,11 @@ async function siweLoginFlow(apiUrl, opts) {
             partnerApiKey: opts.partnerKey,
             keyName: opts.keyName ?? `SIWE-${new Date().toISOString().slice(0, 10)}`,
             readOnly: opts.readOnly ?? false,
+            walletApiEnabled: opts.walletApi ?? true,
+            agentApiEnabled: opts.agentApi ?? false,
+            tokenLaunchApiEnabled: opts.tokenLaunch ?? true,
+            allowedIps: opts.allowedIps,
+            allowedRecipients: opts.allowedRecipients,
         }),
     });
     if (!verifyRes.ok) {
@@ -397,6 +435,49 @@ async function validateApiKey(apiUrl, apiKey) {
     }
 }
 // ── Main login command ──────────────────────────────────────────────
+function parseAndValidateIps(raw) {
+    const ips = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const invalid = ips.filter((ip) => isIP(ip) === 0);
+    if (invalid.length > 0) {
+        fatal(`Invalid IP address(es): ${invalid.join(", ")}`);
+    }
+    return ips;
+}
+function parseAndValidateRecipients(raw) {
+    const addrs = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const evm = [];
+    const solana = [];
+    const invalid = [];
+    for (const addr of addrs) {
+        if (addr.startsWith("0x")) {
+            if (isAddress(addr)) {
+                evm.push(addr);
+            }
+            else {
+                invalid.push(addr);
+            }
+        }
+        else {
+            // Solana: base58, 32-44 chars
+            if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(addr)) {
+                solana.push(addr);
+            }
+            else {
+                invalid.push(addr);
+            }
+        }
+    }
+    if (invalid.length > 0) {
+        fatal(`Invalid address(es): ${invalid.join(", ")}`);
+    }
+    return { evm, solana };
+}
 export async function loginCommand(opts) {
     // Fail fast if flags were passed with empty values
     if (opts.apiKey !== undefined && !opts.apiKey.trim()) {
@@ -444,6 +525,17 @@ export async function loginCommand(opts) {
         output.success(`Credentials saved to ${getConfigPath()}`);
         output.dim(`Bankr API URL: ${apiUrl}`);
     }
+    // Lazily parse allowedIps / allowedRecipients only in flows that use them
+    function getParsedRestrictions() {
+        return {
+            allowedIps: opts.allowedIps
+                ? parseAndValidateIps(opts.allowedIps)
+                : undefined,
+            allowedRecipients: opts.allowedRecipients
+                ? parseAndValidateRecipients(opts.allowedRecipients)
+                : undefined,
+        };
+    }
     // --siwe: SIWE login flow (headless agent onboarding)
     if (opts.siwe) {
         if (!opts.privateKey) {
@@ -454,6 +546,10 @@ export async function loginCommand(opts) {
             partnerKey: opts.partnerKey,
             keyName: opts.keyName,
             readOnly: !opts.readWrite,
+            walletApi: opts.walletApi,
+            agentApi: opts.agentApi,
+            tokenLaunch: opts.tokenLaunch,
+            ...getParsedRestrictions(),
         });
         config.apiKey = apiKey;
         if (opts.partnerKey) {
@@ -492,10 +588,20 @@ export async function loginCommand(opts) {
             const privyConfig = await fetchPrivyConfigOrFail(apiUrl);
             await sendOtpWithSpinner(privyConfig, opts.email);
             output.blank();
-            output.info(`Complete login with: bankr login email ${opts.email} --code <code>`);
+            // Build the hint command, including any flags the user passed so they
+            // remember to re-supply them in step 2
+            let hint = `bankr login email ${opts.email} --code <code>`;
+            if (opts.allowedIps)
+                hint += ` --allowed-ips ${opts.allowedIps}`;
+            if (opts.allowedRecipients)
+                hint += ` --allowed-recipients ${opts.allowedRecipients}`;
+            output.info(`Complete login with: ${hint}`);
             return;
         }
-        const apiKey = await emailLoginFlow(apiUrl, opts);
+        const apiKey = await emailLoginFlow(apiUrl, {
+            ...opts,
+            ...getParsedRestrictions(),
+        });
         output.blank();
         saveCredentials(apiKey, opts.llmKey);
         return;

package/dist/commands/portfolio.d.ts

@@ -0,0 +1,9 @@
+export declare function portfolioCommand(opts: {
+    chain?: string;
+    json?: boolean;
+    lowValue?: boolean;
+    pnl?: boolean;
+    nfts?: boolean;
+    all?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=portfolio.d.ts.map

package/dist/commands/portfolio.js

@@ -0,0 +1,134 @@
+import chalk from "chalk";
+import { getPortfolio, } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { formatUsd, formatBalance } from "../lib/output.js";
+import { CHAIN_LABELS, VALID_CHAINS } from "../lib/chains.js";
+const BRAND = chalk.hex("#FF613D");
+const DIM = chalk.dim;
+const BOLD = chalk.bold;
+const GREEN = chalk.greenBright;
+const RED = chalk.redBright;
+const WHITE = chalk.whiteBright;
+function formatPnl(value) {
+    if (value === 0)
+        return DIM("$0.00");
+    const formatted = `$${Math.abs(value).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    return value > 0 ? GREEN(`+${formatted}`) : RED(`-${formatted}`);
+}
+function printChainBalances(chain, data, showPnl) {
+    const label = CHAIN_LABELS[chain] || chain;
+    const total = parseFloat(data.total);
+    const totalStr = total > 0 ? GREEN(formatUsd(total)) : DIM(formatUsd(total));
+    console.log();
+    console.log();
+    console.log(`  ${BRAND.bold(label)}  ${totalStr}`);
+    console.log(`  ${DIM("─".repeat(showPnl ? 74 : 58))}`);
+    // Native balance
+    const nativeUsd = parseFloat(data.nativeUsd);
+    if (nativeUsd > 0 || parseFloat(data.nativeBalance) > 0) {
+        const nativeSymbol = chain === "solana" ? "SOL" : chain === "polygon" ? "POL" : "ETH";
+        console.log(`    ${BOLD(WHITE(nativeSymbol.padEnd(12)))} ${formatBalance(data.nativeBalance).padStart(18)}  ${DIM(formatUsd(nativeUsd))}`);
+    }
+    // Token balances sorted by USD value descending
+    const sorted = [...data.tokenBalances].sort((a, b) => b.token.balanceUSD - a.token.balanceUSD);
+    for (const tb of sorted) {
+        const symbol = tb.token.baseToken.symbol || "???";
+        const bal = formatBalance(tb.token.balance);
+        const usd = formatUsd(tb.token.balanceUSD);
+        let line = `    ${WHITE(symbol.padEnd(12))} ${bal.padStart(18)}  ${DIM(usd)}`;
+        if (showPnl && tb.token.pnl) {
+            line += `  ${formatPnl(tb.token.pnl.totalPnl)}`;
+        }
+        console.log(line);
+    }
+    if (sorted.length === 0 && (nativeUsd === 0 || isNaN(nativeUsd))) {
+        console.log(DIM("    No token balances"));
+    }
+}
+export async function portfolioCommand(opts) {
+    // Validate chain option
+    const chains = opts.chain
+        ? opts.chain.split(",").map((c) => c.trim().toLowerCase())
+        : undefined;
+    if (chains) {
+        const invalid = chains.filter((c) => !VALID_CHAINS.has(c));
+        if (invalid.length > 0) {
+            output.error(`Invalid chain${invalid.length > 1 ? "s" : ""}: ${invalid.join(", ")}. Valid chains: ${[...VALID_CHAINS].join(", ")}`);
+            process.exit(1);
+        }
+    }
+    const includePnl = opts.pnl || opts.all;
+    const includeNfts = opts.nfts || opts.all;
+    const include = [];
+    if (includePnl)
+        include.push("pnl");
+    if (includeNfts)
+        include.push("nfts");
+    const spinText = include.length > 0
+        ? `Fetching portfolio (${include.join(", ")})...`
+        : "Fetching portfolio...";
+    const spin = output.spinner(spinText);
+    let data;
+    try {
+        data = await getPortfolio({
+            chains,
+            showLowValueTokens: opts.lowValue,
+            include: include.length > 0 ? include : undefined,
+        });
+        spin.succeed("Portfolio loaded");
+    }
+    catch (err) {
+        spin.fail(`Failed to fetch portfolio: ${err.message}`);
+        process.exit(1);
+    }
+    // JSON output mode
+    if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Calculate grand total
+    let grandTotal = 0;
+    const chainEntries = Object.entries(data.balances);
+    for (const [, chainData] of chainEntries) {
+        grandTotal += parseFloat(chainData.total) || 0;
+    }
+    console.log();
+    output.label("Wallet", "");
+    console.log(`  ${"EVM".padEnd(8)} ${data.evmAddress}`);
+    if (data.solAddress) {
+        console.log(`  ${"SOLANA".padEnd(8)} ${data.solAddress}`);
+    }
+    console.log();
+    output.label("Total", GREEN(formatUsd(grandTotal)));
+    if (opts.lowValue) {
+        console.log();
+        output.info("Including low-value tokens");
+    }
+    // Print each chain
+    for (const [chain, chainData] of chainEntries) {
+        printChainBalances(chain, chainData, !!includePnl);
+    }
+    // Print NFTs
+    if (includeNfts && data.nfts && data.nfts.length > 0) {
+        console.log();
+        console.log();
+        console.log(`  ${BRAND.bold("NFTs")}  ${DIM(`${data.nfts.length} item(s)`)}`);
+        console.log(`  ${DIM("─".repeat(58))}`);
+        for (const nft of data.nfts) {
+            const name = nft.name || DIM("Unnamed");
+            const collection = nft.collection?.name
+                ? DIM(` (${nft.collection.name})`)
+                : "";
+            const address = nft.collection?.address || DIM("unknown");
+            console.log(`    ${WHITE(name)}${collection}`);
+            console.log(`    ${DIM(address)} #${nft.tokenId}  ${DIM(nft.chainName || nft.chain)}`);
+            console.log();
+        }
+    }
+    else if (includeNfts) {
+        console.log();
+        output.info("No NFTs found");
+    }
+    console.log();
+}
+//# sourceMappingURL=portfolio.js.map

package/dist/commands/tokens.d.ts

@@ -0,0 +1,7 @@
+export declare function tokensSearchCommand(query: string, opts: {
+    chain?: string;
+}): Promise<void>;
+export declare function tokensInfoCommand(address: string, opts: {
+    chain?: string;
+}): Promise<void>;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/commands/tokens.js

@@ -0,0 +1,60 @@
+import { searchTokens } from "../lib/api.js";
+import * as output from "../lib/output.js";
+export async function tokensSearchCommand(query, opts) {
+    const spin = output.spinner(`Searching tokens for "${query}"...`);
+    try {
+        const chainId = opts.chain ? Number(opts.chain) : undefined;
+        const res = await searchTokens(query, chainId);
+        spin.succeed(`Found ${res.tokens.length} result(s)`);
+        if (res.tokens.length === 0) {
+            output.info("No tokens found. Try a different search query.");
+            return;
+        }
+        console.log();
+        for (const token of res.tokens) {
+            const price = token.priceUsd
+                ? `$${token.priceUsd.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 6 })}`
+                : output.fmt.dim("n/a");
+            console.log(`  ${output.fmt.brandBold(`${token.symbol}`)} ${output.fmt.dim(token.name)}`);
+            console.log(`    Address:  ${token.address}`);
+            console.log(`    Price:    ${price}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        spin.fail(`Search failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+export async function tokensInfoCommand(address, opts) {
+    const spin = output.spinner(`Fetching token info for ${address}...`);
+    try {
+        const chainId = opts.chain ? Number(opts.chain) : undefined;
+        const res = await searchTokens(address, chainId);
+        spin.succeed("Token info loaded");
+        // Match by the requested address (search returns all tokens from matching pools)
+        const addressLower = address.toLowerCase();
+        const token = res.tokens.find((t) => t.address.toLowerCase() === addressLower) ??
+            res.tokens[0];
+        if (!token) {
+            output.error("Token not found. Check the address and try again.");
+            process.exit(1);
+        }
+        console.log();
+        output.label("Name", token.name);
+        output.label("Symbol", token.symbol);
+        output.label("Address", token.address);
+        output.label("Decimals", String(token.decimals));
+        if (token.priceUsd) {
+            output.label("Price", `$${token.priceUsd.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 6 })}`);
+        }
+        if (token.logoURI) {
+            output.label("Logo", token.logoURI);
+        }
+    }
+    catch (err) {
+        spin.fail(`Failed to fetch token info: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=tokens.js.map

package/dist/commands/transfer.d.ts

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

package/dist/commands/transfer.js

@@ -0,0 +1,80 @@
+import { transfer, searchTokens } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { NATIVE_SYMBOLS, CHAIN_IDS } from "../lib/chains.js";
+import { isAddress } from "viem";
+/**
+ * Resolve a token symbol or address to a contract address.
+ * If it's already a valid address, return as-is. Otherwise search by symbol.
+ */
+async function resolveToken(tokenInput, chain) {
+    if (isAddress(tokenInput)) {
+        return { address: tokenInput, symbol: tokenInput };
+    }
+    const chainId = CHAIN_IDS[chain];
+    const res = await searchTokens(tokenInput, chainId);
+    // Exact symbol match (case-insensitive) to avoid resolving to wrong token
+    const inputUpper = tokenInput.toUpperCase();
+    const exactMatch = res.tokens.find((t) => t.symbol.toUpperCase() === inputUpper);
+    if (!exactMatch) {
+        const available = res.tokens
+            .slice(0, 5)
+            .map((t) => `${t.symbol} (${t.address})`)
+            .join(", ");
+        throw new Error(`No exact match for "${tokenInput}" on ${chain}. Did you mean: ${available || "no results"}`);
+    }
+    return { address: exactMatch.address, symbol: exactMatch.symbol };
+}
+export async function transferCommand(opts) {
+    const isNative = opts.native ?? false;
+    const chain = opts.chain ?? "base";
+    if (!isNative && !opts.token) {
+        output.error("Token required for ERC20 transfers. Use --token <symbol or address> or --native.");
+        process.exit(1);
+    }
+    let tokenAddress;
+    let tokenLabel;
+    if (isNative) {
+        tokenAddress = "0x0000000000000000000000000000000000000000";
+        tokenLabel = NATIVE_SYMBOLS[chain] ?? "ETH";
+    }
+    else {
+        const spin = output.spinner(`Resolving token "${opts.token}"...`);
+        try {
+            const resolved = await resolveToken(opts.token, chain);
+            tokenAddress = resolved.address;
+            tokenLabel = resolved.symbol;
+            if (tokenAddress !== opts.token) {
+                spin.succeed(`Resolved ${opts.token} → ${tokenLabel} (${tokenAddress})`);
+            }
+            else {
+                spin.stop();
+            }
+        }
+        catch (err) {
+            spin.fail(err.message);
+            process.exit(1);
+        }
+    }
+    const chainLabel = chain !== "base" ? ` on ${chain}` : "";
+    const spin = output.spinner(`Transferring ${opts.amount} ${tokenLabel} to ${opts.to}${chainLabel}...`);
+    try {
+        const result = await transfer({
+            tokenAddress,
+            recipientAddress: opts.to,
+            amount: opts.amount,
+            isNativeToken: isNative,
+            chain,
+        });
+        if (!result.success) {
+            spin.fail(`Transfer failed: ${result.error}`);
+            process.exit(1);
+        }
+        spin.succeed(`Transfer successful`);
+        output.label("Tx Hash", result.txHash ?? "unknown");
+    }
+    catch (err) {
+        spin.fail(`Transfer failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=transfer.js.map

package/dist/commands/update.d.ts

@@ -0,0 +1,4 @@
+export declare function updateCommand(opts: {
+    check?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=update.d.ts.map