@agentgrant.cash/cli 1.0.0

package/dist/cli/perfolio-commands/hyperliquid.js

@@ -0,0 +1,408 @@
+import { buildCtx, requireAuth, runSignFlow, out, fail, resolveCash, loadDisplayPrefs } from '../money-helpers.js';
+import { describeCashResolution, formatMoney } from '../../lib/index.js';
+import { waitForTx } from '../../lib/verify.js';
+/**
+ * Hyperliquid's minimum order value ($10 notional). Used for a client-side
+ * pre-submit warning; the backend remains authoritative and re-validates.
+ */
+export const HL_MIN_ORDER_USD = 10;
+/**
+ * Pre-submit minimum-order check. Returns a currency-aware warning string when
+ * `sizeUsd` is below Hyperliquid's $10 minimum, else null. Exported for testing.
+ *
+ * Renders the minimum in the user's display currency (e.g. ₹800 for an INR user
+ * at rate 80) so CLI traders see an amount in their own terms rather than a bare
+ * "$10" — the gap that left CLI users guessing why orders were rejected.
+ */
+export function minOrderHint(sizeUsd, prefs, minUsd = HL_MIN_ORDER_USD) {
+    if (sizeUsd >= minUsd)
+        return null;
+    return `Minimum Hyperliquid order is ${formatMoney(minUsd, prefs)}. Increase --size and try again.`;
+}
+/**
+ * Human-readable Hyperliquid account summary. Balance/equity/margin come back as
+ * USD strings; localize them. Exported for testing. Shape (from backend
+ * GET /api/hl/status): { isSetup, isApproved, balance, equity, availableMargin, marginUsed }.
+ */
+export function formatHlStatus(data, prefs) {
+    const num = (v) => {
+        const n = Number(v);
+        return Number.isFinite(n) ? n : 0;
+    };
+    if (!data.isApproved) {
+        return data.isSetup
+            ? 'Hyperliquid trading: set up but not approved yet — run `grant hl setup` to finish.'
+            : 'Hyperliquid trading: not enabled yet — run `grant hl setup` to start trading perps.';
+    }
+    const equity = num(data.equity ?? data.balance);
+    return [
+        'Hyperliquid (perps trading)',
+        `  Account value:     ${formatMoney(equity, prefs)}`,
+        `  Available to trade: ${formatMoney(num(data.availableMargin), prefs)}`,
+        `  Margin in use:      ${formatMoney(num(data.marginUsed), prefs)}`,
+    ].join('\n');
+}
+/** Relay terminal states for an HL→Ethereum withdrawal. */
+const WD_OK = new Set(['success', 'filled', 'completed', 'done']);
+const WD_BAD = new Set(['failure', 'failed', 'refund', 'expired', 'cancelled']);
+/**
+ * Poll a HL→Ethereum withdrawal to a terminal state and report it honestly:
+ * success (with the Ethereum delivery tx), failed/refunded, or still-settling
+ * (re-checkable, never a dead end). Used by both `hl withdraw` and `hl withdraw-status`.
+ */
+async function pollWithdrawStatus(ctx, requestId, expected) {
+    const tail = expected ? ` (~${expected} USDT)` : '';
+    const start = Date.now();
+    let last = 'pending';
+    while (Date.now() - start < 240_000) {
+        try {
+            const s = await ctx.client.hlWithdrawStatus(requestId);
+            last = (s?.status || 'pending').toLowerCase();
+            const outTx = s?.outTxHashes?.[0];
+            if (WD_OK.has(last)) {
+                out(ctx, `✓ Withdrawal complete${tail} — cash delivered to your wallet on Ethereum.${outTx ? `\n  tx: ${outTx}` : ''}`, { success: true, status: last, requestId, outTxHash: outTx });
+                return;
+            }
+            if (WD_BAD.has(last)) {
+                fail(`Withdrawal ${last}. Funds returned to your Hyperliquid balance.`, ctx.json);
+                return;
+            }
+        }
+        catch {
+            /* transient (relay not indexed yet / blip) — keep polling */
+        }
+        await new Promise((r) => setTimeout(r, 4000));
+    }
+    out(ctx, `Withdrawal still settling${tail}. Re-check with \`grant hl withdraw-status ${requestId}\`.`, { submitted: true, confirmed: false, status: last, requestId });
+}
+/** Poll HL status until the account equity reaches >= minUsd, or timeout. */
+async function waitForHlBalance(ctx, minUsd, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const s = (await ctx.client.hlStatus());
+            if (parseFloat(s?.balance ?? '0') >= minUsd)
+                return true;
+        }
+        catch {
+            /* transient — keep polling */
+        }
+        await new Promise((r) => setTimeout(r, 5000));
+    }
+    return false;
+}
+/**
+ * Hyperliquid perpetual trading.
+ *
+ * Reads + trades are AUTONOMOUS — the backend signs with a server-held,
+ * encrypted per-user agent key (HL's native API-wallet). The only step that
+ * needs the user is the one-time agent approval (`hl setup`), which signs an
+ * EIP-712 ApproveAgent action in the browser via the sign relay. After that,
+ * open/close/leverage/tpsl all run with no further interaction.
+ */
+export function registerHyperliquid(program) {
+    const hl = program.command('hl').description('Hyperliquid perpetual trading (any market — stocks, crypto, commodities, fx, indices)');
+    hl.command('status').description('Agent-approval state, balance and open positions')
+        .action(async (_o, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlStatus();
+        if (ctx.json) {
+            out(ctx, '', data);
+            return;
+        }
+        const prefs = await loadDisplayPrefs(ctx);
+        out(ctx, formatHlStatus(data, prefs), data);
+    });
+    hl.command('positions').description('Open perpetual positions')
+        .action(async (_o, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlPositions();
+        out(ctx, JSON.stringify(data, null, 2), data);
+    });
+    hl.command('orders').description('Open orders')
+        .action(async (_o, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlOrders();
+        out(ctx, JSON.stringify(data, null, 2), data);
+    });
+    hl.command('history').description('Trade / fill history')
+        .option('--limit <n>', 'how many records to return (default 50)', (v) => parseInt(v, 10))
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        if (opts.limit !== undefined && !(Number.isFinite(opts.limit) && opts.limit > 0))
+            fail('--limit must be a positive whole number', ctx.json);
+        const data = await ctx.client.hlTradeHistory(opts.limit);
+        out(ctx, JSON.stringify(data, null, 2), data);
+    });
+    hl.command('price').description('Live mark price for any market (default GOLD)')
+        .option('--asset <symbol>', 'market symbol — e.g. AAPL, TSLA, BTC, GOLD. Use `hl markets` to find it.')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlPrice(opts.asset);
+        out(ctx, JSON.stringify(data, null, 2), data);
+    });
+    hl.command('markets').description('Discover tradeable markets — stocks, crypto, commodities, fx, indices')
+        .option('--search <q>', 'filter by symbol or category (e.g. aapl, stock, gold, crypto)')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlMarkets(opts.search);
+        if (ctx.json) {
+            out(ctx, '', data);
+            return;
+        }
+        const lines = data.markets
+            .slice(0, 60)
+            .map((m) => `  ${m.symbol.padEnd(10)} ${m.category.padEnd(10)} up to ${m.maxLeverage}x`);
+        const more = data.count > 60 ? `\n  …and ${data.count - 60} more (use --search to narrow)` : '';
+        out(ctx, `${data.count} markets:\n${lines.join('\n')}${more}`, data);
+    });
+    // One-time: generate the agent key (autonomous) + user-approve it on HL (browser-sign).
+    hl.command('setup').description('Enable autonomous perp trading (funds the account first if needed, then one-time browser approval)')
+        .option('--fund <usdt>', 'amount of cash to move to Hyperliquid if it needs funding first')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        let setup = await ctx.client.hlSetup();
+        if (setup.isApproved) {
+            out(ctx, 'Hyperliquid trading is already enabled.', { isApproved: true, agentAddress: setup.agentAddress });
+            return;
+        }
+        // FUND-THEN-ACTIVATE — mirrors the web app's FuturesSetupFunding flow.
+        // Hyperliquid rejects approveAgent (an L1 action) until the account holds
+        // funds ("Must deposit before performing actions"), so we MUST deposit
+        // before approving. A brand-new account reads as $0 here.
+        if (setup.needsDeposit) {
+            const min = setup.minDeposit ?? 5;
+            const bal = (await ctx.client.getBalance().catch(() => null));
+            const cash = parseFloat(bal?.balances?.USDT?.balanceFormatted ?? '0');
+            // --fund is a cash amount in the user's currency → resolve to USD; default
+            // is a USD heuristic (min of $10 / available cash).
+            const want = opts.fund
+                ? Number((await resolveCash(ctx, opts.fund, 6)).usdString)
+                : Math.min(10, Math.floor(cash));
+            if (cash < min || want < min) {
+                fail(`Hyperliquid needs at least $${min} on your futures account before trading can be enabled ` +
+                    `(it currently has $${setup.hlBalance ?? '0'}). You hold $${cash.toFixed(2)} in cash. ` +
+                    (cash < min
+                        ? `Add funds first (\`pf deposit\` for crypto, or \`pf fiat deposit\`), then run \`pf hl setup\` again.`
+                        : `Run \`pf hl deposit --amount ${Math.min(10, Math.floor(cash))}\` first, then \`pf hl setup\` again.`), ctx.json);
+            }
+            if (!ctx.json)
+                console.log(`\nHyperliquid needs funding before activation. Moving $${want} cash to Hyperliquid first…`);
+            // Autonomous deposit (session-key), then wait for the bridge to land.
+            await ctx.client.hlDeposit({ amountUsdt: String(want) });
+            const landed = await waitForHlBalance(ctx, min, 180_000);
+            if (!landed) {
+                out(ctx, `Deposit submitted — it can take a couple of minutes to arrive on Hyperliquid. ` +
+                    `Once \`pf hl status\` shows the balance, run \`pf hl setup\` again to finish enabling trading.`, { submitted: true, funded: false, needsDeposit: true });
+                return;
+            }
+            // Re-fetch so the approval nonce / typed-data is fresh after funding.
+            setup = await ctx.client.hlSetup();
+            if (setup.isApproved) {
+                out(ctx, 'Hyperliquid trading is already enabled.', { isApproved: true, agentAddress: setup.agentAddress });
+                return;
+            }
+        }
+        await runSignFlow(ctx, {
+            label: 'Enable Hyperliquid trading',
+            confirmTx: false, // HL ApproveAgent is an L1 action, not an Ethereum tx
+            task: {
+                type: 'hl-approve',
+                signMode: 'typed',
+                signatureFormat: 'rsv', // Hyperliquid wants { r, s, v }
+                payload: setup.approvalTypedData,
+                executePath: '/hl/approve',
+                executeBody: { action: setup.approvalAction, nonce: setup.approvalAction.nonce },
+                preview: { agentAddress: setup.agentAddress },
+            },
+        });
+    });
+    hl.command('deposit').description('Move cash from your account into Hyperliquid (autonomous — no browser)')
+        .requiredOption('--amount <amount>', 'cash to move into HL — in your display currency by default; prefix $/₹ to force one, or pass --usd')
+        .option('--usd', 'interpret --amount as US dollars, ignoring your display currency')
+        .option('--no-wait', 'return immediately without waiting for the bridge tx to confirm')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        // Autonomous: POST /tx/bridge-deposit builds the USDT-approve + Across bridge
+        // calls and executes them via the Biconomy session grant (agent-signed).
+        //
+        // Two-stage settlement: the bridge tx confirms the Ethereum leg, but Across
+        // fills onto Hyperliquid a few MINUTES later. Trusting only the tx status
+        // therefore reports "failed/timeout" for a deposit that is actually on its
+        // way (the reported bug). So we (1) confirm the tx, then (2) reconcile by
+        // polling for the HL balance to actually rise before declaring success.
+        const m = await resolveCash(ctx, opts.amount, 6, { usd: !!opts.usd });
+        const wait = opts.wait !== false;
+        const label = `Deposit ${describeCashResolution(m)} cash → Hyperliquid`;
+        // Snapshot HL equity before, so we can detect the balance increase.
+        let preBalance = 0;
+        if (wait) {
+            try {
+                preBalance = parseFloat((await ctx.client.hlStatus())?.balance ?? '0') || 0;
+            }
+            catch { /* non-fatal — proceed without a baseline */ }
+        }
+        const res = await ctx.client.hlDeposit({ amountUsdt: m.usdString });
+        const txHash = res?.txHash;
+        const tail = txHash ? ` (tx ${txHash})` : '';
+        if (!wait) {
+            out(ctx, `Submitted: ${label}${tail}.\nFunds arrive on Hyperliquid a few minutes after the bridge tx confirms — check \`grant hl status\`.`, { submitted: true, confirmed: false, status: res?.status ?? 'submitted', txHash });
+            return;
+        }
+        const txResult = await waitForTx(ctx.client, txHash);
+        if (txResult.status === 'failed')
+            fail(`${label} failed on-chain${tail}.`, ctx.json);
+        // Poll for the funds to actually land on HL (Across fill). 95% tolerance
+        // absorbs bridge fees/rounding so a real deposit isn't missed.
+        const target = preBalance + Number(m.usdString) * 0.95;
+        const landed = await waitForHlBalance(ctx, target, 180_000);
+        if (landed) {
+            out(ctx, `✓ ${label} — now available on Hyperliquid.`, { success: true, confirmed: true, settledOnHl: true, status: 'success', txHash });
+        }
+        else if (txResult.status === 'success') {
+            out(ctx, `${label}: bridge tx confirmed${tail}; funds are still settling on Hyperliquid (this can take a few minutes). Check \`grant hl status\`.`, { submitted: true, confirmed: true, settledOnHl: false, status: 'success', txHash });
+        }
+        else {
+            out(ctx, `${label}: submitted${tail} but not yet confirmed. Re-check with \`grant tx status${txHash ? ` ${txHash}` : ''}\` and \`grant hl status\`.`, { submitted: true, confirmed: false, settledOnHl: false, status: txResult.status, txHash });
+        }
+    });
+    // Autonomous — the backend signs the sendAsset via the Privy autonomous signer
+    // (TEE), so this needs NO browser approval. Funds land as cash (USDT) on Ethereum
+    // in the user's own wallet.
+    hl.command('withdraw').description('Withdraw cash from Hyperliquid back to your wallet on Ethereum')
+        .requiredOption('--amount <amount>', 'cash to withdraw from HL — in your display currency by default; prefix $/₹ to force one, or pass --usd')
+        .option('--usd', 'interpret --amount as US dollars, ignoring your display currency')
+        .option('--no-wait', 'return immediately without waiting for the bridge to settle')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const m = await resolveCash(ctx, opts.amount, 6, { usd: !!opts.usd });
+        const res = await ctx.client.hlWithdraw({ amountUsdc: m.usdString });
+        const requestId = res?.relayRequestId;
+        const expected = res?.expectedOutputUsdt;
+        const tail = expected ? ` (~${expected} USDT expected)` : '';
+        if (opts.wait === false || !requestId) {
+            out(ctx, `Withdrawal submitted${tail}.${requestId ? `\nCheck progress with \`grant hl withdraw-status ${requestId}\`.` : ''}`, { submitted: true, requestId, ...res });
+            return;
+        }
+        if (!ctx.json)
+            console.log(`\nWithdrawing ${describeCashResolution(m)} from Hyperliquid${tail}. Confirming delivery to your wallet…`);
+        await pollWithdrawStatus(ctx, requestId, expected);
+    });
+    hl.command('withdraw-status <requestId>').description('Check a Hyperliquid withdrawal until it lands on Ethereum')
+        .action(async (requestId, _o, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        await pollWithdrawStatus(ctx, requestId);
+    });
+    hl.command('open').description('Open a perpetual position on any market (autonomous)')
+        .requiredOption('--side <long|short>', 'position direction')
+        .requiredOption('--size <usd>', 'position size in USD')
+        .requiredOption('--leverage <n>', 'leverage multiplier')
+        .option('--asset <symbol>', 'market to trade — e.g. AAPL, TSLA, BTC, GOLD (default GOLD). Use `hl markets` to find symbols.')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const side = String(opts.side).toLowerCase();
+        if (side !== 'long' && side !== 'short')
+            fail('--side must be long or short.', ctx.json);
+        const leverage = Number(opts.leverage);
+        if (!(leverage >= 1))
+            fail('--leverage must be at least 1.', ctx.json);
+        // --size is the position notional in USD, entered in the user's currency by
+        // default (e.g. an INR user typing "5000" means ₹5000 of exposure).
+        const sizeM = await resolveCash(ctx, String(opts.size), 2);
+        const sizeUsd = sizeM.usd;
+        if (!(sizeUsd > 0))
+            fail('--size must be greater than 0.', ctx.json);
+        // Pre-submit guard: Hyperliquid rejects orders under $10 notional. Warn the
+        // user up-front (in their own currency) instead of making the round-trip and
+        // showing a rejection — the backend still re-validates authoritatively.
+        const preHint = minOrderHint(sizeUsd, await loadDisplayPrefs(ctx));
+        if (preHint)
+            fail(preHint, ctx.json);
+        const asset = opts.asset ? String(opts.asset) : undefined;
+        const market = asset ? asset.toUpperCase() : 'gold';
+        try {
+            const data = await ctx.client.hlOpen({ side: side, sizeUsd, leverage, asset });
+            out(ctx, `Opened ${side} ${describeCashResolution(sizeM)} ${market} @ ${leverage}x. Check \`grant hl positions\`.`, { success: true, market, sizeUsd, ...(data ?? {}) });
+        }
+        catch (e) {
+            // If the backend reports the $10 minimum (e.g. after price rounding),
+            // re-render it in the user's currency rather than showing a bare "$10".
+            const err = e;
+            if (err?.code === 'MIN_ORDER_NOT_MET') {
+                const prefs = await loadDisplayPrefs(ctx);
+                fail(minOrderHint(0, prefs, err.details?.minOrderUsd ?? HL_MIN_ORDER_USD), ctx.json);
+            }
+            throw e;
+        }
+    });
+    hl.command('close').description('Close a perpetual position (autonomous) — fully, or part with --percentage')
+        .option('--asset <symbol>', 'asset to close', 'XAU')
+        .option('--percentage <pct>', 'close only this percent of the position (1–100; default 100 = full)', (v) => parseFloat(v))
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const pct = opts.percentage;
+        if (pct !== undefined && !(Number.isFinite(pct) && pct > 0 && pct <= 100))
+            fail('--percentage must be a number between 1 and 100', ctx.json);
+        // Only send sizePct for a genuine PARTIAL close; omit it for a full close so
+        // the backend takes its default full-close path (sizePct 100 === full).
+        const partial = pct !== undefined && pct < 100;
+        const data = await ctx.client.hlClose({
+            asset: String(opts.asset).toUpperCase(),
+            ...(partial ? { sizePct: pct } : {}),
+        });
+        const what = partial ? `${pct}% of your ${opts.asset} position` : `${opts.asset} position`;
+        out(ctx, `Closed ${what}.`, { success: true, ...(data ?? {}) });
+    });
+    hl.command('leverage').description('Set leverage for the perp market')
+        .requiredOption('--set <n>', 'leverage multiplier')
+        .option('--isolated', 'use isolated margin (default cross)')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlSetLeverage({ leverage: Number(opts.set), isCross: !opts.isolated });
+        out(ctx, `Leverage set to ${opts.set}x (${opts.isolated ? 'isolated' : 'cross'}).`, { success: true, ...(data ?? {}) });
+    });
+    hl.command('tpsl').description('Set take-profit / stop-loss on a position')
+        .requiredOption('--asset <symbol>', 'asset', 'XAU')
+        .requiredOption('--side <long|short>', 'position direction')
+        .requiredOption('--size <n>', 'position size')
+        .option('--tp <price>', 'take-profit price')
+        .option('--sl <price>', 'stop-loss price')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const side = String(opts.side).toLowerCase();
+        if (side !== 'long' && side !== 'short')
+            fail('--side must be long or short.', ctx.json);
+        if (!opts.tp && !opts.sl)
+            fail('Provide at least one of --tp or --sl.', ctx.json);
+        const data = await ctx.client.hlTpsl({
+            asset: String(opts.asset).toUpperCase(),
+            side: side,
+            size: String(opts.size),
+            takeProfit: opts.tp ? Number(opts.tp) : undefined,
+            stopLoss: opts.sl ? Number(opts.sl) : undefined,
+        });
+        out(ctx, 'Take-profit / stop-loss set.', { success: true, ...(data ?? {}) });
+    });
+    hl.command('cancel <orderId>').description('Cancel an open order')
+        .option('--asset <symbol>', 'asset', 'XAU')
+        .action(async (orderId, opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.hlCancelOrder({ oid: Number(orderId), asset: opts.asset?.toUpperCase() });
+        out(ctx, `Cancelled order ${orderId}.`, { success: true, ...(data ?? {}) });
+    });
+}

package/dist/cli/perfolio-commands/loans.js

@@ -0,0 +1,34 @@
+import { buildCtx, requireAuth, resolver, out } from '../money-helpers.js';
+/**
+ * Loan + funding-address commands ported from the standalone Perfolio CLI. The
+ * combined `grant portfolio` / `grant balance` view (which folds in predictions
+ * + earn) lives separately in commands/portfolio.ts — these are the
+ * loan-detail and deposit-address commands that have no combined-view overlap.
+ */
+export function registerLoans(program) {
+    program.command('loans').description('All open "cash borrowed against X" positions')
+        .action(async (_o, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const data = await ctx.client.getPosition('XAUT', 'USDT'); // v1: canonical gold-backed loan
+        out(ctx, JSON.stringify(data, null, 2), data);
+    });
+    program.command('position').description('Detail for one loan')
+        .requiredOption('--against <asset>', 'collateral asset (gold, bitcoin, ethereum)')
+        .action(async (opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        requireAuth(ctx);
+        const r = await resolver(ctx);
+        const collateral = r.resolve(opts.against).symbol;
+        const data = await ctx.client.getPosition(collateral, 'USDT');
+        out(ctx, JSON.stringify(data, null, 2), data);
+    });
+    program.command('deposit').description('Show your address for funding the account')
+        .action((_o, cmd) => {
+        const ctx = buildCtx(cmd);
+        const creds = requireAuth(ctx);
+        const walletAddress = creds.money?.walletAddress;
+        out(ctx, `Send funds to your wallet on Ethereum:\n\n  ${walletAddress}\n\n` +
+            `Supported: USDT, USDC, ETH and supported collaterals. Only send on Ethereum mainnet.`, { walletAddress, chain: 'ethereum' });
+    });
+}

package/dist/cli/perfolio-commands/market.js

@@ -0,0 +1,76 @@
+import { buildCtx, out, loadDisplayPrefs } from '../money-helpers.js';
+import { formatMoney, GRAMS_PER_TROY_OUNCE } from '../../lib/index.js';
+/** Pull a crypto unit price (USD) by symbol from the /prices/crypto array. */
+function cryptoPrice(crypto, wanted) {
+    if (!Array.isArray(crypto))
+        return null;
+    const hit = crypto.find((e) => {
+        const sym = (e?.currency ?? e?.symbol);
+        return typeof sym === 'string' && sym.toUpperCase() === wanted;
+    });
+    const p = typeof hit?.price === 'number' ? hit.price : NaN;
+    return Number.isFinite(p) && p > 0 ? p : null;
+}
+/**
+ * If a price feed is flagged stale, return a loud inline warning (e.g. " ⚠ stale
+ * (16h old)"); '' when fresh/unknown. A quiet `stale:true` boolean was easy to miss
+ * — acting on a 16-hour-old gold mark is a real risk, so it must be visible.
+ */
+export function staleNote(src) {
+    const o = src;
+    if (!o || o.stale !== true)
+        return '';
+    const age = typeof o.ageSeconds === 'number' && o.ageSeconds > 0 ? o.ageSeconds : undefined;
+    if (age === undefined)
+        return '  ⚠ stale';
+    const h = Math.floor(age / 3600);
+    const m = Math.round((age % 3600) / 60);
+    const ageStr = h > 0 ? `${h}h${m > 0 ? ` ${m}m` : ''}` : `${m}m`;
+    return `  ⚠ stale (${ageStr} old — may be out of date)`;
+}
+/** Human-readable price board, localized to the user's currency + gold unit. Exported for tests. */
+export function formatPrices(gold, crypto, prefs) {
+    const lines = ['Prices'];
+    let anyPrice = false;
+    const goldUsdPerOz = typeof gold?.price === 'number' ? gold.price : null;
+    if (goldUsdPerOz != null) {
+        const perGram = prefs.goldUnit === 'g';
+        const unitPrice = perGram ? goldUsdPerOz / GRAMS_PER_TROY_OUNCE : goldUsdPerOz;
+        lines.push(`  Gold       ${formatMoney(unitPrice, prefs)}/${perGram ? 'g' : 'oz'}${staleNote(gold)}`);
+        anyPrice = true;
+    }
+    const btc = cryptoPrice(crypto, 'BTC');
+    if (btc != null) {
+        lines.push(`  Bitcoin    ${formatMoney(btc, prefs)}`);
+        anyPrice = true;
+    }
+    const eth = cryptoPrice(crypto, 'ETH');
+    if (eth != null) {
+        lines.push(`  Ethereum   ${formatMoney(eth, prefs)}`);
+        anyPrice = true;
+    }
+    if (!anyPrice)
+        return 'Prices are unavailable right now — try again in a moment.';
+    lines.push('  Cash       1 cash ≈ $1 (a US-dollar stablecoin)');
+    return lines.join('\n');
+}
+export function registerMarket(program) {
+    program.command('prices').description('Current prices for gold, bitcoin, ethereum, cash')
+        .action(async (_o, cmd) => {
+        const ctx = buildCtx(cmd);
+        const [gold, crypto] = await Promise.all([ctx.client.getGoldPrice(), ctx.client.getCryptoPrices()]);
+        if (ctx.json) {
+            out(ctx, '', { gold, crypto });
+            return;
+        }
+        const prefs = await loadDisplayPrefs(ctx);
+        out(ctx, formatPrices(gold, crypto, prefs), { gold, crypto });
+    });
+    program.command('rate').description('Borrow rate for a market')
+        .option('--against <asset>', 'collateral asset', 'gold')
+        .action(async (_opts, cmd) => {
+        const ctx = buildCtx(cmd);
+        const [rate, stats] = await Promise.all([ctx.client.getBorrowRate(), ctx.client.getMarketStats()]);
+        out(ctx, JSON.stringify({ rate, stats }, null, 2), { rate, stats });
+    });
+}