@inversealtruism/cairn-cli 0.3.2 → 0.3.6

package/dist/cli.js

@@ -7,29 +7,145 @@ import * as csd from "./lib/csd.js";
 import { buildCommitment } from "./lib/item.js";
 import { buildGatewayRecord, buildPeerRecord, buildIdentityCommit, buildIdentityReveal } from "@inversealtruism/csd-registry";
 import { canonicalJson } from "@inversealtruism/csd-codec";
+import { cairnxGet, activeCairnxBase, defaultBases, buildTransferRecord, humanToBase, baseToHuman, CAIRNX_DOMAIN, CAIRNX_ANCHOR_FEE, TICKER_RE, NAME_RE } from "./lib/cairnx.js";
 import { randomBytes } from "node:crypto";
+import { createInterface } from "node:readline";
 import { c, banner, bannerAnimated, rule, badge, bar, csd as csdFmt, ok, warn, err, key as kdim, pad, spinner, sleep, isTty, anim, clearScreen, cursorHome, san } from "./lib/ui.js";
 const CSD = (n) => Number.isFinite(n) ? Math.round(n * CSD_PER_COIN) : NaN; // CSD → base units
+// ── max-fee sanity guard (UTXO-VALUE-1) ──────────────────────────────────────────────────────
+// A CSD fee is implicit (Σin − Σout) and the chain enforces NO maximum, so a hostile proxy that
+// UNDER-reports the picked UTXO's value would make `csd` compute too-small a change and the
+// difference is silently burned to the miner as fee — the user's own funds, with no on-chain
+// protection. cairn-cli has no codec to recompute the input's REAL value (the wallet's
+// verifyInputValues path), so it applies a proportionate SANITY cap on the fee instead: the fee
+// must be ≤ max(1 CSD absolute, 25% of the tx value). Every honest fee (a 0.01 CSD transfer fee,
+// a 0.25 CSD propose) passes; a typo / hostile-inflated fee is refused. `--max-fee <CSD>` overrides.
+// Returns null if the fee is acceptable, or a human error string to print and abort.
+const MAX_FEE_ABS = 100_000_000; // 1 CSD absolute floor — every honest fee is well under this
+const MAX_FEE_VALUE_FRACTION = 0.25; // …and ≤ 25% of the value moved
+function feeCap(txValue, a) {
+    if (a.flags["max-fee"] !== undefined) {
+        const m = CSD(Number(a.flags["max-fee"]));
+        if (Number.isSafeInteger(m) && m >= 0)
+            return m;
+    }
+    return Math.max(MAX_FEE_ABS, Math.floor(Math.max(0, txValue) * MAX_FEE_VALUE_FRACTION));
+}
+// Guard a value-write before it is built/signed. `txValue` = the value the user means to move
+// (recipients for a send; the fee itself for a fee-only propose/attest). Prints + returns false on abort.
+function feeSanity(fee, txValue, a) {
+    const cap = feeCap(txValue, a);
+    if (fee > cap) {
+        console.log(err(`fee ${csdToCoins(fee)} CSD looks abnormally high (cap ${csdToCoins(cap)} CSD).`) +
+            c.gray(" A proxy under-reporting your input can silently burn the difference as fee. Lower ") + c.cyan("--fee") +
+            c.gray(", or override with ") + c.cyan("--max-fee <CSD>") + c.gray(" if this is intentional."));
+        return false;
+    }
+    return true;
+}
+// Implied-fee transparency for a single-UTXO spend: the on-chain fee a hostile proxy can inflate is
+// (real input − value − change). We can only see the REPORTED input, but we can flag when the
+// reported change is implausibly small for the input (the collapsed-change signature of an
+// under-report). Non-fatal — a warning the user sees before they commit.
+function warnIfChangeCollapsed(inputValue, txValue, fee) {
+    const change = inputValue - txValue - fee;
+    if (change < 0)
+        return; // pickInput already ensures coverage; defensive
+    // a healthy spend leaves change ≫ fee unless the user genuinely picked a tight UTXO; flag the
+    // case where the implied fee dwarfs the change (what an under-reporting proxy produces).
+    if (change > 0 && fee > change) {
+        console.log(warn(`heads up: change (${csdToCoins(change)} CSD) is smaller than the fee (${csdToCoins(fee)} CSD).`) +
+            c.gray(" If your proxy under-reports this input, extra value is burned as fee — verify with your own node, or use ") + c.cyan("--max-fee") + c.gray("."));
+    }
+}
+// Pick a spendable input from the proxy, INDEPENDENTLY verify its value against CAIRN_RPC
+// (UTXO-VALUE-1 cross-source cure), and ALWAYS display the input/change so the implied fee is
+// visible on EVERY write (not just `send`). `txValue` = value moved to recipients (0 for a fee-
+// only propose/attest); `fee` = the fee. Returns the csd input triple, or null (reason printed).
+// Defense layering: (1) if an independent node is configured we cryptographically catch an
+// under-report and REFUSE; (2) otherwise the value is proxy-trusted and the only backstop is the
+// feeSanity cap + the visible change line — the user is told to set CAIRN_RPC for a real check.
+async function pickAndShow(addr, need, txValue, fee) {
+    const picked = await api.pickInput(addr, need).catch(() => null);
+    if (!picked) {
+        console.log(err("no single confirmed UTXO covers this spend") + c.gray(" — fund this address, or consolidate (a node + `csd … --auto-input` can combine inputs)."));
+        return null;
+    }
+    const [ptxid, pvoutS] = picked.input.split(":");
+    const v = await api.verifyInputValue(addr, ptxid, Number(pvoutS), picked.value).catch(() => ({ checked: false }));
+    if (v.checked && v.ok === false) {
+        if (v.missing)
+            console.log(err("the picked input is NOT in your independent node's UTXO set (CAIRN_RPC).") + c.gray(" The proxy may be misreporting your coins — refusing to spend. Check your node is synced, or unset CAIRN_RPC to override."));
+        else
+            console.log(err(`input value MISMATCH — proxy says ${csdToCoins(picked.value)} CSD, your node says ${csdToCoins(v.value ?? 0)} CSD.`) + c.gray(" A proxy under-reporting your input would burn the difference as fee — refusing to spend."));
+        return null;
+    }
+    const verified = v.checked && v.ok === true;
+    const inputValue = verified ? Number(v.value) : picked.value;
+    const tag = verified ? c.green(" ✓ verified vs your node")
+        : (CAIRN_RPC ? c.gray(" (independent value check unavailable — CAIRN_RPC unreachable)") : c.gray(" (UNVERIFIED — set CAIRN_RPC)"));
+    console.log(`${kdim("input")}   ${csdToCoins(inputValue)} CSD ${c.gray("(one UTXO)")}${tag}   ${kdim("change")} ${csdToCoins(Math.max(0, inputValue - txValue - fee))} CSD ${c.gray("back to you")}`);
+    warnIfChangeCollapsed(inputValue, txValue, fee);
+    // CLI-C1: cairn-cli is node-less and has no independent view of the picked UTXO's REAL value, so a
+    // hostile/MITM'd CAIRN_API that under-reports it makes `csd` compute a tiny change and silently burn
+    // the rest of YOUR coin as miner fee (the recipient still gets the signed amount; the loss is your
+    // change). The on-chain fee is implicit (Σin−Σout) with NO chain-enforced maximum. The only robust
+    // defense is an INDEPENDENT value source: set CAIRN_RPC to your own node. Make its absence un-missable.
+    if (!verified) {
+        console.log(warn("input value is NOT independently verified.") +
+            c.gray(" A hostile proxy that under-reports it can burn the difference as fee. Set ") + c.cyan("CAIRN_RPC") +
+            c.gray(" to your own node to verify this value cryptographically before spending."));
+    }
+    return picked.input;
+}
 // Resolve the user's PUBLIC address (to fetch inputs from the proxy). Never reads the key
 // unless we must derive it locally from the user's own csd wallet config (then we cache
-// only the public address). Order: --address → CAIRN_ADDR → cached → derive via csd.
+// only the public address). Order: --address → CAIRN_ADDR (both EXPLICIT user intent for this
+// invocation) → the csd wallet's real change address → cached config.address (LAST, and never
+// above the wallet — see below).
+//
+// F13/R18: the cached config.address is attacker-tamperable (a poisoned
+// ~/.config/cairn-cli/config.json would otherwise redirect `cairn address` output, so a funder
+// piping it pays the attacker). So when csd is available we re-derive the wallet's REAL change
+// address and treat THAT as authoritative; if it disagrees with the cached value we refuse and
+// rewrite the cache. The cache is only used as a fallback when csd can't tell us the truth.
 async function resolveAddr(a) {
-    const flag = a.flags.address ? String(a.flags.address) : (CAIRN_ADDR || loadLocalConfig().address);
-    if (flag && /^0x[0-9a-fA-F]{40}$/.test(flag))
-        return flag;
+    // explicit, per-invocation choice — the user can deliberately target any address
+    const explicit = a.flags.address ? String(a.flags.address) : CAIRN_ADDR;
+    if (explicit && /^0x[0-9a-fA-F]{40}$/.test(explicit))
+        return explicit;
+    const cached = loadLocalConfig().address;
     const cfg = await csd.walletConfig();
-    // Prefer the address csd already exposes (change addr) — avoids re-deriving from the
-    // privkey, which would put the key on the `csd` argv (visible via /proc on a shared host).
+    // Best case: the wallet exposes its change address directly — authoritative AND needs no key
+    // (no argv exposure). The cache is then only an anti-poison cross-check (F13/R18): if a tampered
+    // config disagrees, say so loudly and use the wallet's address.
     if (cfg?.default_change_addr20 && /^0x[0-9a-fA-F]{40}$/.test(String(cfg.default_change_addr20))) {
-        const addr = String(cfg.default_change_addr20);
-        saveLocalConfig({ address: addr });
-        return addr;
-    }
+        const real = String(cfg.default_change_addr20);
+        if (cached && cached.toLowerCase() !== real.toLowerCase())
+            console.log(warn(`cached address ${c.cyan(san(cached))} does NOT match your csd wallet ${c.cyan(real)}`) + c.gray(" — using the wallet's address and refreshing the cache (a tampered config can't redirect you)."));
+        saveLocalConfig({ address: real });
+        return real;
+    }
+    // No change address configured. Audit H-2: re-deriving from the privkey on EVERY call runs
+    // `csd wallet recover --privkey <KEY>`, putting the key on the argv (readable via /proc on a
+    // shared host). Avoid that — prefer a previously-cached address; only DERIVE when we have
+    // nothing else (then cache it + warn once, and nudge the user to set a change address so the
+    // key is never needed again, which also restores the F13 anti-poison cross-check above).
+    if (cached && /^0x[0-9a-fA-F]{40}$/.test(cached))
+        return cached;
     if (cfg?.default_privkey) {
-        const addr = await csd.deriveAddr(cfg.default_privkey);
-        if (addr) {
-            saveLocalConfig({ address: addr });
-            return addr;
+        const real = await csd.deriveAddr(cfg.default_privkey);
+        if (real && /^0x[0-9a-fA-F]{40}$/.test(real)) {
+            const cached2 = saveLocalConfig({ address: real });
+            console.log(warn("derived your address from the wallet key once.") + c.gray(" " + csd.keyExposureWarning));
+            // CLI-C2-DERIVEADDR: if the cache write FAILED (read-only HOME, unwritable CAIRN_CLI_CONFIG, …)
+            // the "derive at most once" guarantee is broken — every subsequent call would re-derive and
+            // re-expose the key on the csd argv. Surface it so the user can set a change address / CAIRN_ADDR.
+            if (!cached2)
+                console.log(warn("could NOT cache your address (config write failed)") +
+                    c.gray(" — set a change address (") + c.cyan("csd wallet init --privkey <key>") + c.gray(") or ") + c.cyan("CAIRN_ADDR") +
+                    c.gray(", otherwise the key is re-derived (and briefly re-exposed on the csd argv) every run."));
+            return real;
         }
     }
     return null;
@@ -39,13 +155,17 @@ async function resolveAddr(a) {
 // proxy ourselves. We do NOT trust csd's own auto-submit: it targets csd's configured node,
 // which may be a different node than the one the Cairn board (and its miner) read — so a tx
 // could sit in the wrong mempool and never get mined into the board's view. Always submit via
-// the proxy (the board's miner-connected node). A repeat that comes back "already present /
-// known" for OUR txid is success (the tx is in that node's mempool); a true double-spend
-// "conflict" is the only ambiguous case, so we confirm via a tx lookup before claiming ok.
+// the proxy (the board's miner-connected node).
+//
+// Success is EVIDENCE-BASED, never message-based: a hostile proxy (or a real double-spend)
+// can return an "already present / conflict" string for a tx that is NOT actually ours, so we
+// never treat any error message as success. A clean submit ack is good; otherwise we ask the
+// node directly whether OUR exact txid is on-chain (api.confirmTxMined), and only claim success
+// when the node confirms it. If we can't confirm, we surface the real node message.
 async function signAndSubmit(csdArgs) {
     const r = await csd.run(csdArgs);
     if (!r.ok)
-        return { ok: false, error: (r.stderr || r.stdout || "csd failed").trim().split("\n").slice(-1)[0] };
+        return { ok: false, error: san((r.stderr || r.stdout || "csd failed").trim().split("\n").slice(-1)[0]) };
     let out = null;
     try {
         out = JSON.parse(r.stdout);
@@ -55,18 +175,50 @@ async function signAndSubmit(csdArgs) {
         return { ok: false, error: "csd produced no signed transaction" };
     const txid = out.txid;
     const sub = await api.submitTx(out.tx).catch((e) => ({ ok: false, err: e.message }));
-    if (sub.ok)
-        return { ok: true, txid: sub.txid || txid };
-    // A benign "already present / mempool conflict" for OUR txid means the tx is already in a
-    // mempool (e.g. csd's own auto-submit reached this same node first, or a re-run) — success.
-    // For a single-key wallet this is safe: only the key owner can produce a conflicting spend
-    // of their own UTXO, so a conflict on our freshly-built tx is our own prior submit, not a
-    // third party. (The narrow exception — two DIFFERENT local spends of one UTXO fired at once
-    // — is on the user.) The node can't be queried for mempool membership (its /tx indexes only
-    // mined txs), so we rely on the matching txid + benign message.
-    if (txid && /already|present|known|in mempool|conflict/i.test(String(sub.err ?? "")))
+    // CLI-C3: the AUTHORITATIVE txid is the LOCALLY-signed one (csd computed it from the exact bytes
+    // it signed). NEVER adopt the proxy-reported sub.txid — a hostile/MITM'd proxy could drop our tx
+    // and ack a DIFFERENT, already-mined chain tx; that substituted txid would then pass confirmMined
+    // AND an independent chainTxMined (it IS a real tx) and falsely read "confirmed on-chain",
+    // defeating the H-7 evidence-based cure. A divergent proxy txid is a hard failure.
+    const norm = (t) => String(t ?? "").toLowerCase().replace(/^0x/, "");
+    if (sub.ok) {
+        if (sub.txid && txid && norm(sub.txid) !== norm(txid))
+            return { ok: false, error: "proxy reported a different txid than the one we signed — refusing", txid };
+        return { ok: true, txid: txid || sub.txid };
+    }
+    // Submit was NOT acked. Don't trust the error STRING — a forged "already present" can hide a
+    // rejected/conflicting tx. Confirm against the chain: only if the node reports OUR exact txid
+    // as mined is this our own prior submit (a genuine "already in"); otherwise the conflict is a
+    // DIFFERENT spend (a real double-spend / hostile reply) and we surface it as a failure.
+    if (txid && await api.confirmTxMined(txid))
         return { ok: true, txid };
-    return { ok: false, error: sub.err || "submit rejected by node", txid };
+    return { ok: false, error: san(sub.err || "submit rejected by node"), txid };
+}
+// Freshness gate (R12): before building any value tx, consult the proxy's chain-view status so
+// we never sign against a FROZEN or forked tip (the proxy may be failing over to an honest-but-
+// stale or wedged node). Fail CLOSED on a stale tip; fail OPEN (warn only) if the freshness
+// surface is unreachable — that matches the rest of the CLI's 'cannot reach' UX and an old node
+// without /api/rpc/status must still be usable. `--force-stale` lets an operator override.
+async function freshTip(a) {
+    let s;
+    try {
+        s = await api.rpcStatus();
+    }
+    catch {
+        console.log(warn("could not check chain freshness (status surface unreachable) — proceeding"));
+        return true;
+    }
+    const secs = Number(s?.secondsSinceAdvance ?? 0);
+    const threshold = Number(s?.staleSecsThreshold ?? 600);
+    const stale = s?.stale === true || (Number.isFinite(secs) && Number.isFinite(threshold) && threshold > 0 && secs > threshold);
+    if (!stale)
+        return true;
+    if (a.flags["force-stale"]) {
+        console.log(warn(`chain tip looks STALE (${secs}s since last advance) — proceeding anyway (--force-stale)`));
+        return true;
+    }
+    console.log(err(`chain tip looks STALE — last advanced ${secs}s ago (threshold ${threshold}s).`) + c.gray(" The node may be frozen or failing over to a stale view; refusing to build a tx. Retry shortly, or override with ") + c.cyan("--force-stale") + c.gray("."));
+    return false;
 }
 // Guard: a write needs `csd` installed + a configured wallet (or an explicit --address + csd key).
 async function requireCsd() {
@@ -103,11 +255,25 @@ function parse(argv) {
     }
     return { _, flags, multi };
 }
-// Do two URLs point at the same host? (used to refuse a "trustless" verify claim when the
-// node RPC and the board API are the same operator). Unparseable → treat as same (safe).
+// Do two URLs point at the same MACHINE? (used to refuse a "trustless" verify claim when the
+// node RPC and the board API are the same operator). Compares hostname only — NOT host — so a
+// same-box node:8789 + board:7777 are correctly judged same-machine (a port difference does not
+// make two endpoints independent), and canonicalizes the loopback aliases (127.0.0.1 / localhost
+// / ::1) so they all compare equal. Unparseable → treat as same (the SAFE default: never claim
+// trustless independence we can't establish).
+function canonHost(h) {
+    const x = h.toLowerCase().replace(/^\[|\]$/g, ""); // strip IPv6 brackets
+    // CLI-C3-CANONHOST (M-15): the ENTIRE 127.0.0.0/8 range is loopback (one machine), so 127.0.0.1
+    // and 127.0.0.2 must canonicalize equal — else a two-loopback-alias setup (board on 127.0.0.1, a
+    // sham "independent node" on 127.0.0.2) would falsely earn the "trustless via independent CAIRN_RPC"
+    // badge. Map every loopback alias to "localhost".
+    if (x === "localhost" || x === "::1" || x === "0.0.0.0" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(x))
+        return "localhost";
+    return x;
+}
 function sameHost(a, b) {
     try {
-        return new URL(a).host.toLowerCase() === new URL(b).host.toLowerCase();
+        return canonHost(new URL(a).hostname) === canonHost(new URL(b).hostname);
     }
     catch {
         return true;
@@ -271,7 +437,12 @@ async function cmdSetup() {
     banner();
     rule("setup — cairn over your csd wallet");
     const has = await csd.available();
-    console.log(`  ${kdim("csd binary")}  ${has ? ok("found (" + csd.CSD_BIN + ")") : err("not found — install Compute Substrate's csd CLI, or set CAIRN_CSD to its path")}`);
+    // H-1: show the RESOLVED absolute path of the binary that will SIGN, so the user can verify it
+    // (and see the refusal if it was resolved from an untrusted location).
+    const bin = csd.csdPathInfo();
+    console.log(`  ${kdim("csd binary")}  ${has ? ok("found") + c.gray("  " + (bin.path ?? "")) + (bin.explicit ? c.gray("  (CAIRN_CSD)") : c.gray("  (resolved)")) : err(bin.error || "not found — install Compute Substrate's csd CLI, or set CAIRN_CSD to its absolute path")}`);
+    if (bin.warning)
+        console.log(`  ${kdim("")}            ${warn(bin.warning)}`);
     if (!has) {
         console.log(c.gray("\n  cairn signs nothing itself — it drives your csd wallet. Install csd, then re-run ") + c.cyan("cairn setup") + c.gray("."));
         return;
@@ -346,30 +517,66 @@ async function cmdSend(a) {
     for (const o of outs)
         console.log(`${kdim("to")}      ${c.cyan(o.to)} ${c.gray("→ " + csdToCoins(o.value) + " CSD")}`);
     console.log(`${kdim("fee")}     ${csdToCoins(fee)} CSD   ${kdim("total")} ${csdToCoins(total + fee)} CSD`);
+    // max-fee sanity: an absurd fee (typo, or a hostile proxy under-reporting the input → burned
+    // change) is refused BEFORE we build/sign. --dry-run still SHOWS the abnormal-fee warning (so the
+    // user sees it without spending) but never aborts the preview. --max-fee overrides a deliberate fee.
+    const feeOk = feeSanity(fee, total, a);
     if (a.flags["dry-run"]) {
         console.log(c.gray("\n[dry-run] not sent"));
         return;
     }
-    const sp = spinner("fetching input → csd signs → submit");
-    const picked = await api.pickInput(addr, total + fee).catch(() => null);
-    if (!picked) {
-        sp.stop();
-        console.log(err("no single confirmed UTXO covers amount + fee") + c.gray(" — fund this address, or consolidate (a node + `csd … --auto-input` can combine inputs)"));
+    if (!feeOk)
+        return;
+    if (!(await freshTip(a)))
+        return;
+    const input = await pickAndShow(addr, total + fee, total, fee);
+    if (!input)
         return;
-    }
-    sp.stop();
-    // transparency: show the input value + change so a hostile proxy under-reporting the input
-    // (which would silently inflate the burned fee) is visible before we sign. Change goes to
-    // your own address; the proxy can never redirect it.
-    console.log(`${kdim("input")}   ${csdToCoins(picked.value)} CSD ${c.gray("(one UTXO)")}   ${kdim("change")} ${csdToCoins(Math.max(0, picked.value - total - fee))} CSD ${c.gray("back to you")}`);
     const sp2 = spinner("csd signs → submit");
     const args = ["spend"];
     for (const o of outs)
         args.push("--output", `${o.to}:${o.value}`);
-    args.push("--change", addr, "--fee", String(fee), "--input", picked.input);
+    args.push("--change", addr, "--fee", String(fee), "--input", input);
     const r = await signAndSubmit(args);
     sp2.stop();
-    console.log(r.ok ? ok(`sent  ${c.cyan(r.txid)}`) + c.gray("  (signed by your csd wallet)") : err(r.error || "failed"));
+    if (!r.ok) {
+        console.log(err(r.error || "failed"));
+        return;
+    }
+    console.log(ok(`sent  ${c.cyan(r.txid)}`) + c.gray("  (signed by your csd wallet)"));
+    await confirmMined(r.txid, "transfer", !!a.flags.wait);
+}
+// Post-submit feedback for value writes (send/support). The txid is already proven submitted by the
+// evidence-based signAndSubmit; mining is a separate ~120s event, so by DEFAULT we DON'T block on it —
+// we report submitted + how to track it (matching token-send). Pass `--wait` to block until OUR exact
+// txid is mined (the old behavior; useful in scripts that chain on confirmation). Non-fatal either way.
+async function confirmMined(txid, label, wait) {
+    if (!wait) {
+        console.log(c.gray(`  ${label} submitted — usually mines within ~2 min; track with `) + c.cyan(`cairn show ${txid.slice(0, 10)}…`));
+        return;
+    }
+    const sp = spinner("waiting for the tx to mine (--wait)");
+    const mined = await api.confirmTxMined(txid).catch(() => false);
+    // H-7: the proxy can string-echo a "mined" reply. Only assert "confirmed on-chain" when an
+    // INDEPENDENT node (CAIRN_RPC) agrees; otherwise soften/flag so the user isn't given a false
+    // settlement guarantee they might release goods against.
+    const indep = mined ? await api.chainTxMined(txid).catch(() => null) : null;
+    sp.stop();
+    if (!mined) {
+        console.log(warn(`${label} submitted — not mined yet; re-check with `) + c.cyan(`cairn show`) + warn(" once a block lands"));
+        return;
+    }
+    // CLI-C3-CONFIRM-SAMEHOST: only call it an INDEPENDENT confirmation when CAIRN_RPC is a different
+    // machine than CAIRN_API (a same-host node is the same operator, not an independent check) — the
+    // same discipline cmdVerify already applies to its trustless badge.
+    if (indep === true)
+        console.log(ok(`${label} confirmed on-chain`) + (sameHost(CAIRN_RPC, CAIRN_API)
+            ? c.gray("  ⚠ CAIRN_RPC shares a host with CAIRN_API — point it at an independent node for a trustless check")
+            : c.gray("  (verified against your independent node)")));
+    else if (indep === false)
+        console.log(err(`${label}: the proxy reports it mined but your node (CAIRN_RPC) does NOT — treat as UNCONFIRMED.`) + c.gray(" A hostile proxy can forge a 'mined' reply; trust your own node."));
+    else
+        console.log(warn(`${label}: proxy reports mined`) + c.gray("  — set CAIRN_RPC to your own node to confirm independently (a proxy can forge this signal)."));
 }
 async function cmdPropose(a) {
     const domain = String(a.flags.domain ?? "");
@@ -388,11 +595,11 @@ async function cmdPropose(a) {
         try {
             const r = await api.apiPropose({ domain, title, body, links, fee });
             sp.stop();
-            console.log(r.ok ? ok(`proposed  ${c.cyan(r.id)}`) + c.gray("  (operator)") : err(r.error || "failed"));
+            console.log(r.ok ? ok(`proposed  ${c.cyan(san(r.id))}`) + c.gray("  (operator)") : err(san(r.error || "failed")));
         }
         catch (e) {
             sp.stop();
-            console.log(err(e.message));
+            console.log(err(san(e.message)));
         }
         return;
     }
@@ -411,19 +618,21 @@ async function cmdPropose(a) {
         console.log(`${kdim("title")}    ${c.white(title)}`);
         console.log(`${kdim("hash")}     ${c.magenta(payloadHash)} ${c.gray("· uri " + uri)}`);
         console.log(`${kdim("fee")}      ${csdToCoins(fee)} CSD   ${kdim("from")} ${c.cyan(addr)}`);
+        feeSanity(fee, fee, a); // show the abnormal-fee warning in the preview (non-aborting on dry-run)
         console.log(c.gray("\n[dry-run] not signed or submitted"));
         return;
     }
-    const sp = spinner("fetching input → csd signs → submit");
-    const picked = await api.pickInput(addr, fee).catch(() => null);
-    if (!picked) {
-        sp.stop();
-        console.log(err("no confirmed UTXO above the fee") + c.gray(" — fund " + addr));
+    if (!feeSanity(fee, fee, a))
+        return;
+    if (!(await freshTip(a)))
+        return;
+    const input = await pickAndShow(addr, fee, 0, fee);
+    if (!input)
         return;
-    }
     const tip = await api.tipHeight().catch(() => 0);
     const days = Math.max(1, parseInt(String(a.flags["expires-days"] ?? 30)) || 30);
-    const r = await signAndSubmit(["propose", "--domain", domain, "--payload-hash", payloadHash, "--uri", uri, "--expires-epoch", String(Math.floor(tip / 30) + days * 24), "--fee", String(fee), "--change", addr, "--input", picked.input]);
+    const sp = spinner("csd signs → submit");
+    const r = await signAndSubmit(["propose", "--domain", domain, "--payload-hash", payloadHash, "--uri", uri, "--expires-epoch", String(Math.floor(tip / 30) + days * 24), "--fee", String(fee), "--change", addr, "--input", input]);
     sp.stop();
     if (!r.ok) {
         console.log(err(r.error || "failed"));
@@ -454,11 +663,11 @@ async function cmdSupport(a) {
         try {
             const r = await api.apiSupport({ id, fee, score, confidence });
             sp.stop();
-            console.log(r.ok ? ok(`supported  ${c.cyan(r.id)}`) + c.gray("  (operator)") : err(r.error || "failed"));
+            console.log(r.ok ? ok(`supported  ${c.cyan(san(r.id))}`) + c.gray("  (operator)") : err(san(r.error || "failed")));
         }
         catch (e) {
             sp.stop();
-            console.log(err(e.message));
+            console.log(err(san(e.message)));
         }
         return;
     }
@@ -472,19 +681,27 @@ async function cmdSupport(a) {
     if (a.flags["dry-run"]) {
         console.log(`${kdim("support")}  ${c.cyan(id)}`);
         console.log(`${kdim("fee")}      ${csdToCoins(fee)} CSD ${c.gray("· score " + score + " · confidence " + confidence)}   ${kdim("from")} ${c.cyan(addr)}`);
+        feeSanity(fee, fee, a); // show the abnormal-fee warning in the preview (the attest weight IS the fee)
         console.log(c.gray("\n[dry-run] not signed or submitted"));
         return;
     }
-    const sp = spinner("fetching input → csd signs → submit");
-    const picked = await api.pickInput(addr, fee).catch(() => null);
-    if (!picked) {
-        sp.stop();
-        console.log(err("no confirmed UTXO above the fee") + c.gray(" — fund " + addr));
+    // an attest's fee IS the deliberate weight/stake; only guard against an absurd typo above the cap.
+    if (!feeSanity(fee, fee, a))
         return;
-    }
-    const r = await signAndSubmit(["attest", "--proposal-id", id, "--score", String(score), "--confidence", String(confidence), "--fee", String(fee), "--change", addr, "--input", picked.input]);
+    if (!(await freshTip(a)))
+        return;
+    const input = await pickAndShow(addr, fee, 0, fee);
+    if (!input)
+        return;
+    const sp = spinner("csd signs → submit");
+    const r = await signAndSubmit(["attest", "--proposal-id", id, "--score", String(score), "--confidence", String(confidence), "--fee", String(fee), "--change", addr, "--input", input]);
     sp.stop();
-    console.log(r.ok ? ok(`supported  ${c.cyan(r.txid)}`) + c.gray("  (signed by your csd wallet)") : err(r.error || "failed"));
+    if (!r.ok) {
+        console.log(err(r.error || "failed"));
+        return;
+    }
+    console.log(ok(`supported  ${c.cyan(r.txid)}`) + c.gray("  (signed by your csd wallet)"));
+    await confirmMined(r.txid, "support", !!a.flags.wait);
 }
 async function cmdWall(a) {
     if (a._[1] === "place") {
@@ -631,12 +848,19 @@ async function help() {
     console.log(c.bold("  wallet") + c.gray("  (signs with your installed csd wallet — cairn never holds your key)"));
     cmd("setup", "", "check csd + wallet, show your address (alias: doctor)");
     cmd("address", "", "your address + balance (alias: whoami, balance)");
-    cmd("send", "--to <0x…40> --amount <CSD>", "transfer CSD (+ --output <a>:<CSD> ×N, --fee <CSD>, --dry-run)");
+    cmd("send", "--to <0x…40> --amount <CSD>", "transfer CSD (+ --output <a>:<CSD> ×N, --fee <CSD>, --max-fee <CSD>, --dry-run)");
     cmd("propose", "--domain <d> --title <t> --body <b>", "post an item (alias: post; + --fee, --expires-days, --dry-run)");
     cmd("support", "<id> --fee <CSD>", "back an item (+ --score, --confidence, --dry-run)");
+    console.log("");
+    console.log(c.bold("  cairnx") + c.gray("  (tokens + .csd names on the CairnX layer)"));
+    cmd("tokens", "[address]", "token balances + .csd names (default: your address)");
+    cmd("token-info", "<TICKER>", "supply · minted · mint mode · top-10 holders (alias: token)");
+    cmd("token-send", "--ticker T --to 0x…40 --amount <n>", "send tokens (anchors a 0.25 CSD transfer record; --dry-run, --yes)");
+    cmd("names", "[address]", "owned .csd names");
+    cmd("name", "<name>", "one name: owner · lease · open offer");
     console.log(c.gray("\n  lenses (--sort): " + Object.keys(LENS).join(" · ")));
     console.log(c.gray(`  api: ${CAIRN_API}  ·  1 CSD = ${CSD_PER_COIN} base · propose ≥ ${csdToCoins(MIN_FEE_PROPOSE)} · attest ≥ ${csdToCoins(MIN_FEE_ATTEST)} CSD`));
-    console.log(c.gray("  config: CAIRN_API (board) · CAIRN_CSD (csd binary) · CAIRN_ADDR (your addr) · CAIRN_RPC (trustless verify) · CAIRN_TOKEN (operator)"));
+    console.log(c.gray("  config: CAIRN_API (board) · CAIRNX_API (token layer) · CAIRN_CSD (csd binary) · CAIRN_ADDR (your addr) · CAIRN_RPC (trustless verify) · CAIRN_TOKEN (operator)"));
     console.log(c.gray("  display: honors NO_COLOR · --no-color · --no-anim · TERM=dumb (color/animation auto-off when piped)"));
     console.log(c.gray("  writes are signed by your own ") + c.cyan("csd") + c.gray(" wallet (csd wallet new / init); cairn supplies the input + Cairn content. Sealed claims + Sign-in: use the Cairn Wallet."));
 }
@@ -667,6 +891,12 @@ async function main() {
         case "propose":
         case "post": return cmdPropose(a);
         case "support": return cmdSupport(a);
+        case "tokens": return cmdTokens(a);
+        case "token-info":
+        case "token": return cmdTokenInfo(a);
+        case "token-send": return cmdTokenSend(a);
+        case "names": return cmdNames(a);
+        case "name": return cmdName(a);
         case "gateway": return cmdGateway(a);
         case "peer": return cmdPeer(a);
         case "identity": return cmdIdentity(a);
@@ -676,17 +906,23 @@ async function main() {
 // ── L3 registry publish commands (build a signed record → anchor Propose → serve bytes) ──
 // Anchor a built registry record: Propose{domain, payloadHash} signed by the csd wallet,
 // then publish the EXACT canonical bytes to the content origin (self-certified on arrival).
-async function anchorRecord(rec, addr, fee, days, label) {
-    const uri = "csd:" + rec.domain.replace(/[^a-z]/gi, "").slice(0, 6) + ":v1:" + rec.payloadHash.slice(2, 14);
-    const sp = spinner("fetching input → csd signs → submit");
-    const picked = await api.pickInput(addr, fee).catch(() => null);
-    if (!picked) {
-        sp.stop();
-        console.log(err("no confirmed UTXO above the fee") + c.gray(" — fund " + addr));
+async function anchorRecord(a, rec, addr, fee, days, label) {
+    // max-fee sanity: a fixed-floor record anchor should never burn more than the 1 CSD abs cap.
+    if (fee > MAX_FEE_ABS) {
+        console.log(err(`fee ${csdToCoins(fee)} CSD looks abnormally high for a ${label} record (cap ${csdToCoins(MAX_FEE_ABS)} CSD).`) + c.gray(" Lower ") + c.cyan("--fee") + c.gray("."));
         return false;
     }
+    // CLI-C6-ANCHOR-FRESHTIP: registry writes move value (the propose fee) + are in-process-signed, so
+    // they must NOT skip the stale/forked-tip gate every other value-write enforces.
+    if (!(await freshTip(a)))
+        return false;
+    const uri = "csd:" + rec.domain.replace(/[^a-z]/gi, "").slice(0, 6) + ":v1:" + rec.payloadHash.slice(2, 14);
+    const input = await pickAndShow(addr, fee, 0, fee);
+    if (!input)
+        return false;
     const tip = await api.tipHeight().catch(() => 0);
-    const r = await signAndSubmit(["propose", "--domain", rec.domain, "--payload-hash", rec.payloadHash, "--uri", uri, "--expires-epoch", String(Math.floor(tip / 30) + days * 24), "--fee", String(fee), "--change", addr, "--input", picked.input]);
+    const sp = spinner("csd signs → submit");
+    const r = await signAndSubmit(["propose", "--domain", rec.domain, "--payload-hash", rec.payloadHash, "--uri", uri, "--expires-epoch", String(Math.floor(tip / 30) + days * 24), "--fee", String(fee), "--change", addr, "--input", input]);
     sp.stop();
     if (!r.ok) {
         console.log(err(r.error || "failed"));
@@ -737,7 +973,7 @@ async function cmdGateway(a) {
         console.log(c.gray("\n[dry-run] not signed or submitted"));
         return;
     }
-    await anchorRecord(rec, p.addr, fee, 10, "gateway");
+    await anchorRecord(a, rec, p.addr, fee, 10, "gateway");
 }
 async function cmdPeer(a) {
     if (a._[1] !== "announce") {
@@ -761,7 +997,7 @@ async function cmdPeer(a) {
         console.log(c.gray("\n[dry-run] not signed or submitted"));
         return;
     }
-    await anchorRecord(rec, p.addr, fee, 10, "peer");
+    await anchorRecord(a, rec, p.addr, fee, 10, "peer");
 }
 async function cmdIdentity(a) {
     const sub = a._[1];
@@ -791,7 +1027,7 @@ async function cmdIdentity(a) {
             console.log(c.gray("\n[dry-run] not signed"));
             return;
         }
-        await anchorRecord(rec, p.addr, fee, 90, "identity reveal");
+        await anchorRecord(a, rec, p.addr, fee, 90, "identity reveal");
         return;
     }
     // default / --commit-only: step 1
@@ -802,8 +1038,267 @@ async function cmdIdentity(a) {
         console.log(c.gray("\n[dry-run] not signed"));
         return;
     }
-    const okc = await anchorRecord(rec, p.addr, fee, 90, "identity commit");
+    const okc = await anchorRecord(a, rec, p.addr, fee, 90, "identity commit");
     if (okc)
         console.log(c.gray("\n  save this salt — reveal NEXT epoch (~1h):  ") + c.cyan(`cairn identity claim ${handle} --reveal --salt ${salt}`));
 }
-main().catch((e) => { console.error(err(String(e?.message ?? e))); process.exit(1); });
+// ── CairnX: tokens + .csd names (reads via the CairnX state API; the one write —
+//    token-send — anchors a canonical transfer record as a cairnx:v1 Propose) ──
+// Display: base units → human, with thousands grouping. decimals===undefined (a ticker the
+// API doesn't know) falls back to raw base units rather than guessing a scale.
+const group = (s) => s.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+// CLI-C4-AMOUNTDOS: read-API amounts are attacker-controlled strings; a non-numeric one would throw
+// inside BigInt()/baseToHuman() and crash the whole read/display. Parse defensively (0n on garbage)
+// so one hostile balance can't take down `tokens`/`token-info`.
+const big = (x) => { try {
+    return BigInt(String(x ?? "0"));
+}
+catch {
+    return 0n;
+} };
+function tokAmt(base, decimals) {
+    if (decimals === undefined)
+        return `${group(String(base))} (base units)`;
+    try {
+        const [i, f] = baseToHuman(big(base), decimals).split(".");
+        return group(i) + (f ? "." + f : "");
+    }
+    catch {
+        return `${group(big(base).toString())} (base units)`;
+    }
+}
+// The address a CairnX read targets: positional arg → --address/CAIRN_ADDR/csd wallet.
+async function resolveCairnxAddr(a, positional) {
+    if (positional !== undefined) {
+        if (!/^0x[0-9a-fA-F]{40}$/.test(positional)) {
+            console.log(err(`bad address: ${san(positional)}`));
+            return null;
+        }
+        return positional.toLowerCase();
+    }
+    const addr = await resolveAddr(a);
+    if (!addr)
+        console.log(err("no address — pass one (cairn tokens 0x…), or --address, or run ") + c.cyan("cairn setup"));
+    return addr ? addr.toLowerCase() : null;
+}
+// ticker → decimals map from /tokens (best-effort: an unreachable list degrades to raw units).
+async function tokenDecimals() {
+    const list = await cairnxGet("/tokens").catch(() => []);
+    const map = {};
+    for (const t of Array.isArray(list) ? list : [])
+        if (typeof t?.ticker === "string" && Number.isInteger(t?.decimals))
+            map[t.ticker] = t.decimals;
+    return map;
+}
+async function cmdTokens(a) {
+    const addr = await resolveCairnxAddr(a, a._[1]);
+    if (!addr)
+        return;
+    const [acct, dec] = await Promise.all([cairnxGet(`/address/${encodeURIComponent(addr)}`), tokenDecimals()]);
+    if (a.flags.json) {
+        console.log(JSON.stringify(acct, null, 2));
+        return;
+    }
+    banner();
+    rule(`cairnx · ${addr.slice(0, 10)}… · ${String(activeCairnxBase() ?? "").replace(/^https?:\/\//, "")}`);
+    const bals = Object.entries(acct.balances ?? {});
+    if (!bals.length)
+        console.log(c.gray("  no token balances"));
+    for (const [ticker, b] of bals) {
+        const locked = big(b.locked);
+        console.log(`  ${c.cyan(pad(san(ticker), 14))} ${c.white(tokAmt(String(b.available ?? "0"), dec[ticker]))}${locked > 0n ? c.gray(` · ${tokAmt(String(b.locked), dec[ticker])} locked in open offers`) : ""}`);
+    }
+    const names = acct.names ?? [];
+    console.log(`\n  ${kdim(".csd names")} ${names.length ? names.map((n) => c.green(san(n))).join(c.gray(" · ")) : c.gray("none")}`);
+}
+async function cmdTokenInfo(a) {
+    const ticker = String(a._[1] ?? "").toUpperCase();
+    if (!TICKER_RE.test(ticker)) {
+        console.log(warn("usage: ") + c.cyan("cairn token-info <TICKER>"));
+        return;
+    }
+    const t = await cairnxGet(`/token/${encodeURIComponent(ticker)}`).catch((e) => { console.log(e.status === 404 ? err(`unknown token ${san(ticker)}`) : err(san(e.message))); return null; });
+    if (!t)
+        return;
+    banner();
+    rule(`token · ${san(t.ticker)}`);
+    const row = (k, v) => console.log(`  ${kdim(pad(k, 11))} ${v}`);
+    row("name", c.white(san(t.name ?? t.ticker)));
+    row("decimals", c.white(String(t.decimals)));
+    row("supply", `${c.white(tokAmt(String(t.supply), t.decimals))} ${c.gray("max")}`);
+    const minted = big(t.minted), supply = big(t.supply);
+    row("minted", `${c.white(tokAmt(String(t.minted), t.decimals))}${supply > 0n ? c.gray(` · ${Number((minted * 10000n) / supply) / 100}% of supply`) : ""}`);
+    row("mint", t.mint === "open" ? c.green("open") + c.gray(` · up to ${tokAmt(String(t.mintLimit ?? "0"), t.decimals)} per mint`) : c.gray("issuer-only"));
+    row("deployer", c.gray(san(t.deployer)));
+    row("deployed", c.gray(`height ${Number(t.height)} · id ${san(String(t.deployId ?? "")).slice(0, 22)}…`));
+    // top-10 holders by total (available + locked) — the same reading the explorer shows
+    const holders = Object.entries(t.holders ?? {}).map(([h, b]) => ({ h, total: big(b.available) + big(b.locked) }))
+        .filter((x) => x.total > 0n).sort((x, y) => (y.total > x.total ? 1 : y.total < x.total ? -1 : 0));
+    console.log(`\n  ${kdim("holders")}    ${c.white(String(holders.length))}${holders.length > 10 ? c.gray(" · top 10") : ""}`);
+    const max = holders[0]?.total ?? 1n;
+    for (const { h, total } of holders.slice(0, 10)) {
+        const pct = minted > 0n ? Number((total * 10000n) / minted) / 100 : 0;
+        console.log(`  ${bar(Number((total * 1000n) / max), 1000)}  ${c.gray(san(h).slice(0, 12) + "…")} ${c.white(tokAmt(total.toString(), t.decimals))} ${c.gray(`· ${pct}%`)}`);
+    }
+}
+// y/N gate for the one CairnX write. Non-interactive runs behave like the CLI's other
+// writes (no prompt — use --dry-run to preview); --yes skips the prompt when interactive.
+async function confirmSend(q) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return true;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ans = await new Promise((res) => rl.question(q, res));
+    rl.close();
+    return /^y(es)?$/i.test(ans.trim());
+}
+async function cmdTokenSend(a) {
+    const ticker = String(a.flags.ticker ?? "").toUpperCase();
+    const to = String(a.flags.to ?? "");
+    const amountStr = String(a.flags.amount ?? "");
+    if (!ticker || !a.flags.to || a.flags.amount === undefined) {
+        console.log(warn("usage: ") + c.cyan("cairn token-send --ticker CAIRN --to 0x…40 --amount 1.5 [--dry-run] [--yes]"));
+        return;
+    }
+    if (!TICKER_RE.test(ticker)) {
+        console.log(err(`bad ticker: ${san(ticker)}`));
+        return;
+    }
+    if (!/^0x[0-9a-fA-F]{40}$/.test(to)) {
+        console.log(err(`bad recipient: ${san(to)}`));
+        return;
+    }
+    // CLI-C5-DECIMALS: `decimals` drives the human→base scale but is reported by an UNauthenticated
+    // CairnX read API (no signature/SPV) — a hostile gateway over-reporting it silently inflates the
+    // MAGNITUDE of your transfer. So: (1) when not pinned to a single CAIRNX_API, cross-check decimals
+    // across the default bases and refuse on disagreement (dual-source discipline); (2) always show +
+    // confirm the exact base-unit integer so a wrong scale is visible before signing.
+    const t = await cairnxGet(`/token/${encodeURIComponent(ticker)}`).catch((e) => { console.log(e.status === 404 ? err(`unknown token ${ticker}`) : err(san(e.message))); return null; });
+    if (!t)
+        return;
+    const decimals = Number(t.decimals);
+    const bases = defaultBases();
+    if (bases.length > 1) {
+        const seen = await Promise.all(bases.map((b) => cairnxGet(`/token/${encodeURIComponent(ticker)}`, [b]).then((x) => Number(x?.decimals)).catch(() => null)));
+        const consistent = seen.filter((d) => Number.isInteger(d));
+        if (consistent.length >= 2 && new Set(consistent).size > 1) {
+            console.log(err(`CairnX sources DISAGREE on ${ticker} decimals (${[...new Set(consistent)].join(" vs ")}) — refusing to scale the amount against an ambiguous decimals (pin CAIRNX_API to a trusted base).`));
+            return;
+        }
+    }
+    let amount;
+    try {
+        amount = humanToBase(amountStr, decimals);
+    }
+    catch (e) {
+        console.log(err(san(e.message)));
+        return;
+    }
+    if (amount <= 0n) {
+        console.log(err("amount must be > 0"));
+        return;
+    }
+    const from = await resolveAddr(a);
+    if (!from) {
+        console.log(err("could not resolve your address — pass --address or run ") + c.cyan("cairn setup"));
+        return;
+    }
+    // balance check against the same state the resolver will apply the transfer to
+    const acct = await cairnxGet(`/address/${encodeURIComponent(from.toLowerCase())}`);
+    const avail = big(acct.balances?.[ticker]?.available);
+    if (avail < amount) {
+        console.log(err(`insufficient ${ticker}: balance ${tokAmt(avail.toString(), decimals)}, tried to send ${tokAmt(amount.toString(), decimals)}${big(acct.balances?.[ticker]?.locked) > 0n ? ` (${tokAmt(String(acct.balances[ticker].locked), decimals)} more is locked in open offers)` : ""}`));
+        return;
+    }
+    let built;
+    try {
+        built = buildTransferRecord({ ticker, to, amount });
+    }
+    catch (e) {
+        console.log(err(san(e.message)));
+        return;
+    }
+    // clear-print exactly what will be anchored before anything signs — the EXACT base-unit integer is
+    // emphasized on its own line (CLI-C5: a wrong API-reported `decimals` shows up here as a magnitude).
+    console.log(`${kdim("send")}    ${c.white(tokAmt(amount.toString(), decimals))} ${c.cyan(ticker)}`);
+    console.log(`${kdim("amount")}  ${c.white(c.bold(amount.toString()))} ${c.gray(`base units · ${decimals} decimals (from the CairnX read API — verify this magnitude)`)}`);
+    console.log(`${kdim("to")}      ${c.cyan(to.toLowerCase())}`);
+    console.log(`${kdim("from")}    ${c.cyan(from.toLowerCase())} ${c.gray(`· ${ticker} balance ${tokAmt(avail.toString(), decimals)}`)}`);
+    console.log(`${kdim("record")}  ${c.white(san(built.uri))}`);
+    console.log(`${kdim("hash")}    ${c.magenta(built.payloadHash)}`);
+    console.log(`${kdim("anchor")}  ${c.gray(`Propose on ${CAIRNX_DOMAIN} — costs `)}${c.white(csdToCoins(CAIRNX_ANCHOR_FEE) + " CSD")}${c.gray(" (the chain fee; the tokens themselves move by record)")}`);
+    if (a.flags["dry-run"]) {
+        console.log(c.gray("\n[dry-run] not signed or submitted"));
+        return;
+    }
+    if (!(await requireCsd()))
+        return;
+    if (!a.flags.yes && !(await confirmSend(`\nsend ${tokAmt(amount.toString(), decimals)} ${ticker} (${amount} base units) for ${csdToCoins(CAIRNX_ANCHOR_FEE)} CSD? [y/N] `))) {
+        console.log(c.gray("aborted"));
+        return;
+    }
+    if (!(await freshTip(a)))
+        return;
+    const input = await pickAndShow(from, CAIRNX_ANCHOR_FEE, 0, CAIRNX_ANCHOR_FEE);
+    if (!input)
+        return;
+    const tip = await api.tipHeight().catch(() => 0);
+    const sp3 = spinner("csd signs → submit");
+    const r = await signAndSubmit(["propose", "--domain", CAIRNX_DOMAIN, "--payload-hash", built.payloadHash, "--uri", built.uri, "--expires-epoch", String(Math.floor(tip / 30) + 24), "--fee", String(CAIRNX_ANCHOR_FEE), "--change", from, "--input", input]);
+    sp3.stop();
+    console.log(r.ok ? ok(`transfer anchored  ${c.cyan(r.txid)}`) + c.gray("  (tokens move when it mines — check `cairn tokens`)") : err(r.error || "failed"));
+}
+async function cmdNames(a) {
+    const addr = await resolveCairnxAddr(a, a._[1]);
+    if (!addr)
+        return;
+    const acct = await cairnxGet(`/address/${encodeURIComponent(addr)}`);
+    const names = acct.names ?? [];
+    if (a.flags.json) {
+        console.log(JSON.stringify(names, null, 2));
+        return;
+    }
+    banner();
+    rule(`.csd names · ${addr.slice(0, 10)}…`);
+    if (!names.length) {
+        console.log(c.gray("  no names owned — claim one on " + (activeCairnxBase()?.includes("127.0.0.1") ? "the /trade marketplace" : "https://cairn-substrate.com/trade")));
+        return;
+    }
+    for (const n of names)
+        console.log(`  ${c.green(san(n))}`);
+    console.log(c.gray(`\n  ${names.length} name${names.length === 1 ? "" : "s"} · cairn name <name> for detail`));
+}
+async function cmdName(a) {
+    const n = String(a._[1] ?? "").toLowerCase();
+    if (!n || !NAME_RE.test(n)) {
+        console.log(warn("usage: ") + c.cyan("cairn name <name>") + c.gray("  (lowercase, 3–32 chars [a-z0-9-])"));
+        return;
+    }
+    const r = await cairnxGet(`/name/${encodeURIComponent(n)}`).catch((e) => { console.log(e.status === 404 ? err(`unregistered name "${san(n)}"`) + c.gray(" — claimable via commit-reveal on /trade") : err(san(e.message))); return null; });
+    if (!r)
+        return;
+    banner();
+    rule(`name · ${san(r.name ?? n)}`);
+    const row = (k, v) => console.log(`  ${kdim(pad(k, 10))} ${v}`);
+    row("owner", c.cyan(san(r.owner)));
+    row("claimed", c.gray(`height ${Number(r.height)}${Number(r.effectiveHeight) !== Number(r.height) ? ` · effective ${Number(r.effectiveHeight)}` : ""} · claim ${san(String(r.claimId ?? "")).slice(0, 22)}…`));
+    // lease: the API reports paidThroughEpoch once the v1.5 lease model is live; the ETA is
+    // computed from the chain tip (1 epoch = 30 blocks · 120s target ⇒ ~1h per epoch).
+    if (r.paidThroughEpoch != null) {
+        const tip = await api.tipHeight().catch(() => 0);
+        const blocksLeft = (Number(r.paidThroughEpoch) + 1) * 30 - tip;
+        const eta = !tip ? "" : blocksLeft <= 0 ? " · " + "EXPIRED" : ` · expires in ~${blocksLeft >= 720 ? (blocksLeft / 720).toFixed(1) + " days" : Math.max(1, Math.round(blocksLeft / 30)) + "h"}`;
+        row("lease", `${c.white("paid through epoch " + Number(r.paidThroughEpoch))}${blocksLeft <= 0 && tip ? "  " + err("EXPIRED") : c.gray(eta)}`);
+    }
+    else
+        row("lease", c.gray("— (no lease data from this API)"));
+    if (r.locked)
+        row("locked", c.gray("yes — a sale/transfer is in flight"));
+    if (r.offer) {
+        const want = r.offer.want ?? {};
+        const price = want.value !== undefined ? `${csdToCoins(Number(want.value))} CSD` : `${san(String(want.amount))} ${san(String(want.ticker))}`;
+        row("offer", `${c.green("FOR SALE")} ${c.white("· " + price)} ${c.gray(`· seller ${san(String(r.offer.seller ?? r.owner)).slice(0, 12)}… · offer ${san(String(r.offer.id ?? "")).slice(0, 18)}…${r.offer.taker ? " · reserved for a taker" : ""}`)}`);
+    }
+    else
+        row("offer", c.gray("no open offer"));
+}
+main().catch((e) => { console.error(err(san(String(e?.message ?? e)))); process.exit(1); });