nat-cli 0.0.3 → 0.3.0

package/lib/tui.mjs

@@ -0,0 +1,671 @@
+// Terminal UI for `bnat` with no arguments: one dashboard screen (wallet line, status, error
+// summary, a tabbed table, a timestamped log, key bar). Raw keys in, ANSI frames out.
+//
+// Every action runs this same CLI as a child (`bnat <cmd> … --json`), so the checks, simulation,
+// wallet-preview validation and journal are exactly the ones the commands use. A write is first
+// run without --yes (checks + simulation only, nothing sent) and becomes the pending plan; only
+// `y` runs it again with --yes, which hands it to baw. While a transaction executes, quitting is
+// refused: an interrupted run would leave its journal entry open.
+//
+// Login: if `baw wallet status` is not CONNECTED, the table panel shows the QR code from
+// `baw auth signin` while `baw auth verify` waits for the scan (stopped at expiry, on Esc or quit).
+import { spawn } from 'node:child_process';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { emitKeypressEvents } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import QRCode from 'qrcode';
+import { getAddress, isAddress } from 'viem';
+import { baw, data } from './baw.mjs';
+import { BATCH_MAX as BATCH, wrapAmounts } from './chain.mjs';
+import { configFile, lang, saveSetting, setLang, settings, t } from './i18n.mjs';
+import { stateDir } from './journal.mjs';
+
+const CLI = fileURLToPath(new URL('../scripts/cli.mjs', import.meta.url));
+const PAGE = 50; // rows per page (ranks 1–50, 51–100, …)
+const TOP_DEPTH = 10_000; // how deep /top ranks
+
+/** Run `bnat <args> --json` and return its JSON envelope ({ ok, result, log, error, stopped }). */
+export function runCli(args) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, ['--no-warnings', CLI, ...args, '--json'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { err += d; });
+    child.on('error', (e) => resolve({ ok: false, error: e.message, log: [] }));
+    child.on('close', () => {
+      try { resolve(JSON.parse(out)); } catch { resolve({ ok: false, error: (err || out).trim().slice(-400) || t('tui.noOutput'), log: [] }); }
+    });
+  });
+}
+
+/** The baw login calls the TUI makes (injectable for tests). */
+export const bawAuth = {
+  async status() { return data(await baw(['wallet', 'status']), 'baw wallet status').status; },
+  async signin() { return data(await baw(['auth', 'signin']), 'baw auth signin'); },
+  async verify(qrCodeId, signal) { return data(await baw(['auth', 'verify', '--qrCodeId', qrCodeId], { signal }), 'baw auth verify'); },
+};
+
+/** A QR code as text rows of half blocks (two modules per row, 2-module quiet zone). */
+export function qrLines(text) {
+  const q = QRCode.create(text, { errorCorrectionLevel: 'M' });
+  const n = q.modules.size, m = 2;
+  const dark = (r, c) => r >= 0 && c >= 0 && r < n && c < n && !!q.modules.get(r, c);
+  const out = [];
+  for (let r = -m; r < n + m; r += 2) {
+    let line = '';
+    for (let c = -m; c < n + m; c++) {
+      const top = dark(r, c), bottom = dark(r + 1, c);
+      line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+// ---- text width (CJK and full-width forms take two columns) ----
+const wide = (c) => (c >= 0x1100 && c <= 0x115f) || (c >= 0x2e80 && c <= 0xa4cf) || (c >= 0xac00 && c <= 0xd7a3)
+  || (c >= 0xf900 && c <= 0xfaff) || (c >= 0xfe30 && c <= 0xfe4f) || (c >= 0xff00 && c <= 0xff60) || (c >= 0xffe0 && c <= 0xffe6);
+const cw = (ch) => (wide(ch.codePointAt(0)) ? 2 : 1);
+export const width = (s) => { let w = 0; for (const ch of s) w += cw(ch); return w; };
+/** Cut or pad `s` to exactly `cols` columns. */
+export function fit(s, cols) {
+  let out = '', w = 0;
+  for (const ch of s) {
+    if (w + cw(ch) > cols) break;
+    out += ch; w += cw(ch);
+  }
+  return out + ' '.repeat(Math.max(0, cols - w));
+}
+function wrapText(s, cols) {
+  const out = [];
+  for (const line of String(s).split('\n')) {
+    let cur = '', w = 0;
+    for (const ch of line) {
+      if (w + cw(ch) > cols) { out.push(cur); cur = ''; w = 0; }
+      cur += ch; w += cw(ch);
+    }
+    out.push(cur);
+  }
+  return out;
+}
+const pad = (s, n) => s + ' '.repeat(Math.max(0, n - width(s)));
+const lpad = (s, n) => ' '.repeat(Math.max(0, n - width(s))) + s;
+const short = (a) => (a ? `${a.slice(0, 6)}…${a.slice(-4)}` : '');
+const group = (s) => String(s).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+/** 18-decimal integer -> decimal string without trailing zeros (cut, not rounded, to `dp`). */
+export function units(v, dp = 18) {
+  const b = BigInt(v), neg = b < 0n, a = neg ? -b : b;
+  const frac = (a % 10n ** 18n).toString().padStart(18, '0').slice(0, dp).replace(/0+$/, '');
+  return `${neg ? '-' : ''}${a / 10n ** 18n}${frac ? `.${frac}` : ''}`;
+}
+const gweiBnb = (g) => units(BigInt(g) * 10n ** 9n);
+const hhmmss = (d) => d.toTimeString().slice(0, 8);
+const tilde = (p) => (p.startsWith(homedir()) ? `~${p.slice(homedir().length)}` : p);
+
+// ---- the fields each tab's rows are drawn from ----
+const intLike = (v) => (typeof v === 'number' && Number.isSafeInteger(v) && v >= 0) || (typeof v === 'string' && /^\d+$/.test(v));
+const blockRow = (x) => !!x && intLike(x.blk) && intLike(x.burnGwei);
+const ROW_OK = {
+  blocks: blockRow, held: blockRow, vault: blockRow,
+  market: (b) => !!b && intLike(b.id) && intLike(b.price) && intLike(b.remaining) && intLike(b.escrow) && /^0x[0-9a-fA-F]{40}$/.test(b.buyer ?? ''),
+  history: (e) => !!e && typeof e.status === 'string' && typeof e.action === 'string',
+};
+
+// ---- styled segments: a line is [[text, style], …] ----
+const RESET = '\x1b[0m';
+const ST = {
+  dim: '\x1b[2m', b: '\x1b[1m', ok: '\x1b[32m', bad: '\x1b[31m', warn: '\x1b[33m', info: '\x1b[36m', sel: '\x1b[7m',
+  frame: '\x1b[90m', qr: '\x1b[47m\x1b[30m', tab: '\x1b[1;36m', badb: '\x1b[1;31m', okb: '\x1b[1;32m',
+};
+/** Segments cut/padded to `cols`; `base` (the selected-row style) sits under every segment. */
+function paint(segs, cols, base) {
+  let out = '', w = 0;
+  const pre = base ? ST[base] : '';
+  for (const [text, s] of segs) {
+    let piece = '';
+    for (const ch of String(text)) {
+      if (w + cw(ch) > cols) break;
+      piece += ch; w += cw(ch);
+    }
+    if (piece) out += pre + (s ? ST[s] : '') + piece + RESET;
+    if (w >= cols) break;
+  }
+  return out + pre + ' '.repeat(Math.max(0, cols - w)) + RESET;
+}
+const segWidth = (segs) => segs.reduce((a, [text]) => a + width(String(text)), 0);
+
+// Text keys, looked up at draw time so `i` (language switch) applies at once.
+const TABS = [
+  { key: 'blocks', name: 'tui.mintable' },
+  { key: 'held', name: 'tui.holdings', multi: true }, { key: 'vault', name: 'tui.vault', multi: true },
+  { key: 'market', name: 'tui.market' }, { key: 'history', name: 'tui.history' },
+];
+const KEYS = {
+  blocks: 'tui.enterMintTMintTo2',
+  held: 'tui.spacePickAPickPage',
+  vault: 'tui.spacePickAPickPage2',
+  market: 'tui.enterSellBPlaceBid',
+  history: 'tui.hSettleByHashX',
+};
+
+/**
+ * Start the TUI. I/O is injectable for tests: `run` replaces the CLI runner, `auth` the baw
+ * login calls, `input`/`output` the terminal, `size` the window size, `logDir` the log folder.
+ */
+export function runTui({ input = process.stdin, output = process.stdout, run = runCli, auth = bawAuth, size, logDir } = {}) {
+  const dims = size ?? (() => ({ cols: output.columns || 100, rows: output.rows || 30 }));
+  const dir = logDir ?? join(stateDir(), 'logs');
+  const logFile = join(dir, `tui-${new Date().toISOString().replace(/[:.]/g, '-')}.jsonl`);
+  try { mkdirSync(dir, { recursive: true }); } catch { /* the on-screen log still works */ }
+
+  return new Promise((resolveQuit) => {
+    const tabs = TABS.map((tb) => ({ ...tb, rows: [], i: 0, top: 0, offset: 0, total: null, err: null, loaded: false, picked: new Map(), sort: 'burn', mine: false }));
+    let tab = 0;
+    let me = null, meErr = null; // wallet summary from `bnat wallet`
+    let login = { state: 'checking' }; // state: checking | CONNECTED | UNCONNECTED | CREATING | error
+    let showLogin = false, loginTick = null;
+    const inflight = []; // running children; one spinner timer while any is in flight
+    let spin = 0, timer = null, executing = false;
+    let pending = null; // { args, title, after, planned:Set } waiting for y
+    let prompt = null; // { label, value, resolve }
+    let status = null; // { t, s } one-line message
+    const log = []; // { at, t, s }
+    let logBack = 0; // log lines scrolled up from the bottom
+    const errors = new Map(); // reason -> count
+    let quitting = false;
+    let mintTo = settings().mintTo ?? null; // default mint recipient (`bnat config mintTo`); null = this wallet
+
+    // ---------------- log ----------------
+    function note(kind, text, s) {
+      const at = new Date();
+      log.push({ at, t: text, s });
+      if (log.length > 2000) log.splice(0, log.length - 2000);
+      try { appendFileSync(logFile, `${JSON.stringify({ at: at.toISOString(), kind, text })}\n`); } catch { /* best effort */ }
+      draw();
+    }
+    function fail(r, what) {
+      const reason = `${r.stopped ? t('cli.stopped') : t('cli.error')}${t('common.colon')}${r.error}`;
+      errors.set(reason, (errors.get(reason) ?? 0) + 1);
+      note('error', `${what}${t('common.colon')}${reason}`, 'bad');
+    }
+
+    // ---------------- children ----------------
+    async function exec(args, label, { write = false, checking = false } = {}) {
+      const job = { label, checking };
+      inflight.push(job);
+      if (write) executing = true;
+      if (!quitting) timer ??= setInterval(() => { spin++; draw(); }, 120);
+      draw();
+      try { return await run(args); } finally {
+        inflight.splice(inflight.indexOf(job), 1);
+        if (write) executing = false;
+        if (!inflight.length) { clearInterval(timer); timer = null; }
+        draw();
+      }
+    }
+    async function loadMe() {
+      const r = await exec(['wallet'], t('tui.readingWallet'));
+      if (r.ok) { me = r.result; meErr = null; } else meErr = r.error;
+      draw();
+    }
+    async function load(tb) {
+      tb.loaded = true; tb.err = null;
+      const off = String(tb.offset);
+      const r = await ({
+        // Unminted blocks ranked by burn, 10,000 deep.
+        blocks: () => exec(['top', '--filter', 'unminted', '--size', String(PAGE), '--offset', off], t('tui.readingMintableBlocks')),
+        held: () => exec(['holdings', '--size', String(PAGE), '--offset', off], t('tui.readingHoldings')),
+        vault: () => exec(['vault', '--sort', tb.sort, '--size', String(PAGE), '--offset', off], t('tui.readingVault')),
+        market: () => exec(['bids', '--size', String(PAGE), '--offset', off, ...(tb.mine ? ['--mine'] : [])], t('tui.readingBids')),
+        history: () => exec(['history'], t('tui.readingHistory')),
+      })[tb.key]();
+      if (!r.ok) { tb.err = r.error; tb.rows = []; return draw(); }
+      const v = r.result;
+      const rows = tb.key === 'held' ? v?.held : tb.key === 'vault' ? v?.rows : v;
+      // Check the shape of the list and of every row the table will render: don't crash on it.
+      if (!Array.isArray(rows) || !rows.every(ROW_OK[tb.key])) { tb.err = t('tui.unexpectedReply'); tb.rows = []; return draw(); }
+      tb.rows = tb.key === 'history' ? [...rows].reverse() : rows;
+      tb.total = tb.key === 'held' ? v.heldTotal : tb.key === 'vault' ? v.total : null;
+      tb.i = Math.min(tb.i, Math.max(0, tb.rows.length - 1));
+      draw();
+    }
+    const cur = () => tabs[tab];
+    const staleAll = () => { for (const tb of tabs) tb.loaded = false; };
+    const refresh = () => { staleAll(); loadMe(); load(cur()); };
+
+    // ---------------- writes: plan, then y ----------------
+    async function plan(args, title, after) {
+      note('plan', `${title}${t('common.colon')}${t('tui.checkingAndSimulatingOnChain')}`, 'info');
+      const r = await exec(args, t('tui.checking', { title }), { checking: true });
+      const lines = (r.log ?? []).filter((l) => !l.startsWith(t('tui.withoutYes')));
+      for (const l of lines) note('plan', l);
+      if (!r.ok) return fail(r, title);
+      pending = { args, title, after, planned: new Set(lines) };
+      draw();
+    }
+    async function confirm() {
+      const p = pending;
+      pending = null;
+      note('send', `${p.title}${t('common.colon')}${t('tui.confirmedHandedToBawTo')}`, 'warn');
+      const r = await exec([...p.args, '--yes'], t('tui.executing', { title: p.title }), { write: true });
+      for (const l of r.log ?? []) if (!p.planned.has(l)) note('exec', l, l.startsWith(t('tui.done')) ? 'ok' : undefined);
+      if (r.ok) {
+        const done = `${p.title}${t('common.colon')}${t('tui.done2')}`;
+        status = { t: done, s: 'ok' }; note('done', done, 'ok');
+      } else fail(r, p.title);
+      p.after?.();
+      refresh();
+    }
+    async function once(args, title) {
+      note('run', `${title}…`, 'info');
+      const r = await exec(args, `${title}…`);
+      for (const l of r.log ?? []) note('run', l);
+      if (!r.ok) fail(r, title);
+      refresh();
+    }
+    function ask(label) {
+      return new Promise((resolve) => { prompt = { label, value: '', resolve }; draw(); });
+    }
+
+    // ---------------- login ----------------
+    function stopLogin() {
+      login.abort?.abort();
+      clearTimeout(login.expiry);
+      clearInterval(loginTick); loginTick = null;
+    }
+    async function checkLogin() {
+      login = { state: 'checking' };
+      draw();
+      try {
+        const st = await auth.status();
+        if (quitting) return;
+        if (st === 'CONNECTED') { login = { state: st }; return refresh(); }
+        login = { state: st };
+        note('login', st === 'CREATING'
+          ? t('tui.bawIsCreatingTheWallet')
+          : t('tui.bawIsNotLoggedIn'), 'warn');
+        load(cur()); // public lists work without a wallet
+        return startLogin();
+      } catch (e) {
+        if (quitting) return;
+        login = { state: 'error', err: e.message };
+        note('login', `baw${t('common.colon')}${e.message}`, 'bad');
+        load(cur());
+      }
+    }
+    async function startLogin() {
+      stopLogin();
+      showLogin = true;
+      login = { state: 'UNCONNECTED', loading: true };
+      draw();
+      let s;
+      try { s = await auth.signin(); } catch (e) {
+        if (quitting) return;
+        login = { state: 'error', err: e.message };
+        return note('login', `${t('tui.couldNotCreateTheLogin')}${t('common.colon')}${e.message}`, 'bad');
+      }
+      if (quitting || !showLogin) return;
+      if (s?.status === 'ALREADY_CONNECTED') return afterLogin();
+      if (typeof s?.qrCodeId !== 'string' || typeof s?.urlForWeb !== 'string') {
+        login = { state: 'error', err: `${t('tui.bawAuthSigninReturnedAn')}${t('common.colon')}${JSON.stringify(s).slice(0, 200)}` };
+        return note('login', login.err, 'bad');
+      }
+      const ac = new AbortController();
+      const expireAt = Number(s.expireAt) || Date.now() + 5 * 60_000;
+      const l = {
+        state: 'UNCONNECTED', abort: ac, expireAt, pairing: s.pairingCode, url: s.urlForWeb, lines: qrLines(s.urlForWeb),
+        expiry: setTimeout(() => { l.expired = true; ac.abort(); }, Math.max(0, expireAt - Date.now())),
+      };
+      login = l;
+      loginTick = setInterval(draw, 1000);
+      note('login', t('tui.loginQrCodeReadyWaiting'));
+      try {
+        const v = await auth.verify(s.qrCodeId, ac.signal);
+        stopLogin();
+        if (quitting) return;
+        if (v?.status && v.status !== 'SUCCESS') throw Error(t('tui.scanResult', { status: v.status }));
+        afterLogin();
+      } catch (e) {
+        stopLogin();
+        if (quitting || login !== l) return; // a newer QR replaced this one
+        if (e.name === 'AbortError') {
+          login = { state: 'UNCONNECTED', expired: l.expired };
+          if (l.expired) note('login', t('tui.qrCodeExpiredPressL'), 'warn');
+        } else {
+          login = { state: 'error', err: e.message };
+          note('login', `${t('tui.loginFailed')}${t('common.colon')}${e.message}`, 'bad');
+        }
+        draw();
+      }
+    }
+    function afterLogin() {
+      login = { state: 'CONNECTED' };
+      showLogin = false;
+      note('login', t('tui.bawLoggedIn'), 'ok');
+      refresh();
+    }
+
+    // ---------------- rendering ----------------
+    function headerLine() {
+      const sep = [' │ ', 'frame'];
+      const segs = [['bnat', 'b'], sep];
+      if (me) {
+        segs.push([short(me.address)], sep, ['.ai '], me.agentId ? ['✓', 'ok'] : [t('tui.none'), 'bad'], sep,
+          [`BNB ${units(me.bnb, 6)}`], sep, [`NAT ${me.nfts}`], sep, [`BNAT ${units(me.bnat, 6)}`], sep);
+        if (mintTo) segs.push([t('tui.mintToHeader', { to: short(mintTo) }), 'warn'], sep);
+      } else if (meErr && login.state === 'CONNECTED') segs.push([`${t('tui.walletReadFailed')}${t('common.colon')}${meErr}`, 'bad'], sep);
+      const ls = login.state;
+      segs.push(ls === 'CONNECTED' ? [t('tui.bawLoggedIn2'), 'ok'] : ls === 'checking' ? [t('tui.bawCheckingLogin'), 'dim']
+        : ls === 'error' ? [t('tui.bawUnavailable'), 'bad'] : [t('tui.bawNotLoggedInL'), 'warn']);
+      return segs;
+    }
+    function statusLine() {
+      if (inflight.length) {
+        const label = executing ? `${inflight.at(-1).label}${t('tui.cannotQuitUntilItFinishes')}` : inflight.at(-1).label;
+        return [[`${'⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'[spin % 10]} ${label}`, 'warn']];
+      }
+      if (status) return [[status.t, status.s]];
+      return [[t('tui.ready'), 'dim']];
+    }
+    function tabTitle() {
+      const segs = [];
+      tabs.forEach((tb, k) => {
+        if (k) segs.push([' │ ', 'frame']);
+        segs.push([`${k + 1} ${t(tb.name)}`, k === tab && !showLogin ? 'tab' : 'dim']);
+      });
+      if (showLogin) return [[t('tui.bawLogin'), 'tab'], ['  ', ''], ...segs];
+      const tb = cur(), info = [];
+      if (tb.multi && tb.picked.size) {
+        let sum = 0n;
+        for (const g of tb.picked.values()) { const a = wrapAmounts(BigInt(g)); sum += tb.key === 'held' ? a.toHolder : a.unwrapCost; }
+        const amt = units(sum, 9);
+        info.push(tb.key === 'held'
+          ? t('tui.pickedGetBnat', { size: tb.picked.size, amt })
+          : t('tui.pickedPayBnat', { size: tb.picked.size, amt }));
+      }
+      if (tb.key === 'blocks' && tb.rows.length) info.push(t('tui.rankRange', { from: tb.offset + 1, to: tb.offset + tb.rows.length }));
+      else if (tb.rows.length && (tb.offset || (tb.total ?? 0) > tb.rows.length || tb.rows.length === PAGE)) {
+        const range = `${tb.offset + 1}–${tb.offset + tb.rows.length}${tb.total ? ` / ${tb.total}` : ''}`;
+        info.push(t('tui.pageRange', { range }));
+      }
+      if (tb.key === 'vault') info.push(tb.sort === 'burn' ? t('tui.byBurn') : t('tui.newest'));
+      if (tb.key === 'market' && tb.mine) info.push(t('tui.mineOnly'));
+      if (info.length) segs.push([`   ${info.join(' · ')}`, 'info']);
+      return segs;
+    }
+    function columns(tb) {
+      const mark = (x) => (tb.picked.has(x.blk) ? ['✓ ', 'okb'] : ['· ', 'dim']);
+      const BLOCK = t('tui.block'), BURN = t('tui.burnGwei');
+      switch (tb.key) {
+        case 'blocks': return {
+          head: `${lpad(t('tui.rank'), 6)}  ${pad(BLOCK, 14)}${lpad(BURN, 18)}   BNB`,
+          row: (x, k) => [[lpad(String(tb.offset + k + 1), 6), 'dim'], [`  ${pad(`#${x.blk}`, 14)}`], [lpad(group(x.burnGwei), 18)], [`   ${gweiBnb(x.burnGwei)}`]],
+        };
+        case 'held': return {
+          head: `  ${pad(BLOCK, 14)}${lpad(BURN, 18)}   ${t('tui.wrapGetsBnat')}`,
+          row: (x) => [mark(x), [pad(`#${x.blk}`, 14)], [lpad(group(x.burnGwei), 18)], [`   ${units(wrapAmounts(BigInt(x.burnGwei)).toHolder)}`]],
+        };
+        case 'vault': return {
+          head: `  ${pad(BLOCK, 14)}${lpad(BURN, 18)}   ${t('tui.unwrapCostsBnat')}`,
+          row: (x) => [mark(x), [pad(`#${x.blk}`, 14)], [lpad(group(x.burnGwei), 18)], [`   ${units(wrapAmounts(BigInt(x.burnGwei)).unwrapCost)}`]],
+        };
+        case 'market': return {
+          head: `${pad(t('tui.id'), 7)}${pad(t('tui.priceBnbBnat'), 20)}${pad(t('tui.leftBnat'), 20)}${pad(t('tui.lockedBnb'), 20)} ${t('tui.buyer')}`,
+          row: (b) => {
+            const mine = me && b.buyer.toLowerCase() === me.address.toLowerCase();
+            return [[pad(`#${b.id}`, 7)], [pad(units(b.price), 20)], [pad(units(b.remaining), 20)], [pad(units(b.escrow), 20)], [` ${short(b.buyer)}`, 'dim'], ...(mine ? [[t('tui.mine'), 'info']] : [])];
+          },
+        };
+        default: return {
+          head: `${pad(t('tui.time'), 20)}${pad(t('tui.status'), 11)}${pad(t('tui.action'), 8)}${t('tui.summary')}`,
+          row: (e) => {
+            const s = e.status === 'confirmed' ? 'ok' : e.status === 'failed' ? 'bad' : e.status === 'abandoned' ? 'dim' : 'warn';
+            return [[pad((e.at ?? '').slice(0, 19).replace('T', ' '), 20), 'dim'], [pad(e.status, 11), s], [pad(e.action, 8)], [`${e.summary ?? ''}${e.hash ? ` ${short(e.hash)}` : ''}`]];
+          },
+        };
+      }
+    }
+    function tableBody(inner, h) {
+      if (showLogin) return loginBody(inner, h);
+      const tb = cur();
+      if (tb.err) return wrapText(`${t('tui.readFailed')}${t('common.colon')}${tb.err}`, inner).slice(0, h).map((l) => ({ segs: [[l, 'bad']] }));
+      const c = columns(tb);
+      const out = [{ segs: [[c.head, 'dim']] }];
+      if (!tb.rows.length) { out.push({ segs: [[tb.loaded && !inflight.length ? t('tui.nothingHere') : '', 'dim']] }); return out; }
+      const room = h - 1;
+      if (tb.i < tb.top) tb.top = tb.i;
+      if (tb.i >= tb.top + room) tb.top = tb.i - room + 1;
+      tb.top = Math.max(0, Math.min(tb.top, tb.rows.length - room));
+      tb.rows.slice(tb.top, tb.top + room).forEach((x, k) => {
+        const idx = tb.top + k;
+        out.push({ segs: c.row(x, idx), base: idx === tb.i ? 'sel' : undefined });
+      });
+      return out;
+    }
+    function loginBody(inner, h) {
+      const center = (segs) => ({ segs: [[' '.repeat(Math.max(0, Math.floor((inner - segWidth(segs)) / 2)))], ...segs] });
+      if (login.state === 'error') return wrapText(`${t('tui.bawUnavailable')}${t('common.colon')}${login.err}`, inner).map((l) => ({ segs: [[l, 'bad']] }));
+      if (!login.lines) {
+        return [center([[login.loading ? t('tui.creatingTheLoginQrCode')
+          : login.expired ? t('tui.qrCodeExpiredPressL')
+            : t('tui.notLoggedInPressL'), 'warn']])];
+      }
+      const left = Math.max(0, Math.round((login.expireAt - Date.now()) / 1000));
+      const mmss = `${Math.floor(left / 60)}:${String(left % 60).padStart(2, '0')}`;
+      const info = [
+        center([[t('tui.scanWithTheBinanceApp'), 'b']]),
+        center([[t('tui.pairingCodeCheckItMatches', { v0: login.pairing ?? '—' }), 'info']]),
+        center([[t('tui.expiresInLNewCode', { mmss }), 'dim']]),
+      ];
+      if (login.lines.length + info.length + 1 > h || width(login.lines[0]) > inner) {
+        const out = [center([[t('tui.windowTooSmallForThe'), 'warn']])];
+        for (const l of wrapText(login.url, inner)) out.push({ segs: [[l, 'info']] });
+        return [...out, ...info];
+      }
+      return [...login.lines.map((l) => center([[l, 'qr']])), { segs: [] }, ...info];
+    }
+    function box(title, body, cols, h) {
+      if (segWidth(title) > cols - 4) { // keep the corner: cut the last segment from the left
+        const [text, s] = title.at(-1), room = cols - 4 - segWidth(title.slice(0, -1)) - 1;
+        let cut = String(text);
+        while (cut && width(cut) > room) cut = [...cut].slice(1).join('');
+        title = [...title.slice(0, -1), [`…${cut}`, s]];
+      }
+      const tw = Math.min(segWidth(title), cols - 4);
+      const lines = [[['┌ ', 'frame'], ...title, [` ${'─'.repeat(Math.max(0, cols - 4 - tw))}┐`, 'frame']]];
+      for (let k = 0; k < h; k++) lines.push({ inner: body[k] ?? { segs: [] } });
+      lines.push([[`└${'─'.repeat(Math.max(0, cols - 2))}┘`, 'frame']]);
+      return lines;
+    }
+    function draw() {
+      if (quitting) return;
+      try { render(); } catch (e) { output.write(`\x1b[H\x1b[2J${t('tui.drawFailed')}${t('common.colon')}${e.message}\r\n`); }
+    }
+    function render() {
+      const { cols, rows } = dims();
+      const inner = cols - 2;
+      const errs = [...errors].sort((a, b) => b[1] - a[1]);
+      const errLines = errs.length
+        ? [[[t('tui.errorsCountReason'), 'badb']], ...errs.slice(0, 3).map(([m, n]) => [[`${lpad(String(n), 4)} · `, 'bad'], [m]])]
+        : [];
+      const tail = [];
+      if (pending) {
+        tail.push([[t('tui.toConfirm'), 'warn'], [pending.title, 'b'], [t('tui.checksAndSimulationPassedNothing'), 'warn'],
+          ['y', 'okb'], [t('tui.send'), 'warn'], ['n', 'badb'], [t('tui.cancel'), 'warn']]);
+      }
+      if (prompt) tail.push([[prompt.label, 'b'], [`${prompt.value}█`]]);
+      const keys = showLogin ? t('tui.lNewQrCodeEsc')
+        : t('tui.16TabsMoveR', { v0: t(KEYS[cur().key]) });
+      const loginKey = login.state === 'CONNECTED' || showLogin ? '' : t('tui.lLogIn');
+      const global = t('tui.pgupPgdnScrollLogQ', { loginKey });
+      if (width(`${keys} · ${global}`) <= cols) tail.push([[`${keys} · ${global}`, 'dim']]);
+      else tail.push([[keys, 'dim']], [[global, 'dim']]);
+
+      const room = Math.max(10, rows - 2 - errLines.length - tail.length) - 4; // minus two box frames
+      const tableH = showLogin ? Math.max(3, room - 4) : Math.max(3, Math.round(room * 0.6));
+      const logH = Math.max(1, room - tableH);
+
+      const logLines = log.flatMap((e) => wrapText(`${hhmmss(e.at)}  ${e.t}`, inner).map((l, k) => ({ segs: k ? [[l, e.s]] : [[l.slice(0, 10), 'dim'], [l.slice(10), e.s]] })));
+      logBack = Math.max(0, Math.min(logBack, logLines.length - logH));
+      const logView = logLines.slice(Math.max(0, logLines.length - logH - logBack), logLines.length - logBack);
+      const logTitle = [[t('tui.log'), 'b'], [`  ${tilde(logFile)}`, 'dim'], ...(logBack ? [[`  ↑${logBack}`, 'info']] : [])];
+
+      const lines = [headerLine(), statusLine(), ...errLines,
+        ...box(tabTitle(), tableBody(inner, tableH), cols, tableH),
+        ...box(logTitle, logView, cols, logH), ...tail].slice(0, rows);
+      let out = '\x1b[H';
+      lines.forEach((l, k) => {
+        if (k) out += '\r\n';
+        out += Array.isArray(l) ? paint(l, cols) : `${ST.frame}│${RESET}${paint(l.inner.segs, inner, l.inner.base)}${ST.frame}│${RESET}`;
+      });
+      out += '\x1b[J';
+      output.write(out);
+    }
+
+    // ---------------- keys ----------------
+    function quit() {
+      if (executing) { status = { t: t('tui.aTransactionIsExecutingCannot'), s: 'warn' }; return draw(); }
+      quitting = true;
+      clearInterval(timer); timer = null;
+      stopLogin();
+      input.off('keypress', onKey);
+      input.setRawMode?.(false);
+      input.pause();
+      output.off?.('resize', draw);
+      process.off('exit', restore);
+      restore();
+      resolveQuit();
+    }
+    async function setMintTo() {
+      const v = await ask(t('tui.mintToWhichAddress0x'));
+      if (v === null) return draw();
+      if (v !== '' && v !== 'self' && !isAddress(v)) { status = { t: t('tui.badAddress', { v }), s: 'warn' }; return draw(); }
+      mintTo = v === '' || v === 'self' ? null : getAddress(v);
+      try { saveSetting('mintTo', mintTo ?? undefined); } catch (e) { status = { t: e.message, s: 'bad' }; return draw(); }
+      note('config', mintTo ? t('tui.mintToSet', { to: mintTo, file: tilde(configFile()) }) : t('tui.mintToCleared', { file: tilde(configFile()) }), 'info');
+    }
+    function switchLang() {
+      setLang(lang === 'zh' ? 'en' : 'zh');
+      try { saveSetting('lang', lang); } catch (e) { status = { t: e.message, s: 'bad' }; }
+      note('config', t('tui.langSwitched', { file: tilde(configFile()) }), 'info');
+    }
+    function switchTab(k) {
+      tab = k; status = null;
+      if (!cur().loaded) load(cur());
+      draw();
+    }
+    function page(tb, by) {
+      tb.offset = Math.max(0, tb.offset + by); tb.i = 0; tb.top = 0; tb.picked.clear();
+      return load(tb);
+    }
+    async function onListKey(k) {
+      const tb = cur(), x = tb.rows[tb.i];
+      const more = tb.total !== null ? tb.total > tb.offset + tb.rows.length : tb.rows.length === PAGE;
+      if (k.name === 'up') tb.i = Math.max(0, tb.i - 1);
+      else if (k.name === 'down') tb.i = Math.min(Math.max(0, tb.rows.length - 1), tb.i + 1);
+      else if (k.str === 'n' && more && !(tb.key === 'blocks' && tb.offset + PAGE >= TOP_DEPTH)) return page(tb, PAGE);
+      else if (k.str === 'p' && tb.offset > 0) return page(tb, -PAGE);
+      else if (tb.key === 'blocks' && x) {
+        if (k.name === 'return') {
+          return plan(['mint', '--block', String(x.blk)], mintTo ? t('tui.mint2', { blk: x.blk, to: short(mintTo) }) : t('tui.mint', { blk: x.blk }));
+        }
+        if (k.str === 't') return setMintTo();
+      } else if (tb.multi) {
+        if (k.name === 'space' && x) {
+          if (tb.picked.has(x.blk)) tb.picked.delete(x.blk);
+          else if (tb.picked.size < BATCH) tb.picked.set(x.blk, x.burnGwei);
+          else status = { t: t('tui.atMostPerTransaction', { BATCH }), s: 'warn' };
+          tb.i = Math.min(tb.rows.length - 1, tb.i + 1);
+        } else if (k.str === 'a') {
+          for (const r of tb.rows) if (tb.picked.size < BATCH) tb.picked.set(r.blk, r.burnGwei);
+          if (tb.rows.length > BATCH) status = { t: t('tui.atMostPerTransactionPicked', { BATCH }), s: 'warn' };
+        } else if (k.str === 's' && tb.key === 'vault') { tb.sort = tb.sort === 'burn' ? 'recent' : 'burn'; return page(tb, -tb.offset); }
+        else if (k.name === 'escape') tb.picked.clear();
+        else if (k.name === 'return') {
+          const blks = tb.picked.size ? [...tb.picked.keys()] : x ? [x.blk] : [];
+          if (!blks.length) return;
+          const verb = tb.key === 'held' ? 'wrap' : 'unwrap';
+          return plan([verb, '--block', blks.join(',')], t('tui.batchTitle', { verb, length: blks.length }), () => tb.picked.clear());
+        }
+      } else if (tb.key === 'market') {
+        if (k.str === 'm') { tb.mine = !tb.mine; return page(tb, -tb.offset); }
+        if (k.str === 'b') {
+          const price = await ask(t('tui.priceBnbBnatEscCancels')); if (!price) return;
+          const amount = await ask(t('tui.amountBnatEscCancels')); if (!amount) return;
+          return plan(['bid', '--price', price, '--amount', amount], t('tui.bidBnat', { amount, price }));
+        }
+        if (k.str === 'c' && x) {
+          if (!me || x.buyer.toLowerCase() !== me.address.toLowerCase()) { status = { t: t('tui.youCanOnlyCancelYour'), s: 'warn' }; return draw(); }
+          return plan(['cancel', '--bid', String(x.id)], t('tui.cancelBid', { id: x.id }));
+        }
+        if (k.name === 'return' && x) {
+          const amt = await ask(t('tui.howMuchBnatToSell', { id: x.id }));
+          if (amt === null) return;
+          return plan(['sell', '--bid', String(x.id), ...(amt ? ['--amount', amt] : ['--all'])], t('tui.sellToBid', { id: x.id }));
+        }
+      } else if (tb.key === 'history' && x && (k.str === 'h' || k.str === 'x')) {
+        if (['confirmed', 'failed', 'abandoned'].includes(x.status)) { status = { t: t('tui.thisEntryIsAlreadySettled'), s: 'dim' }; return draw(); }
+        if (k.str === 'h') {
+          const hash = await ask(t('tui.transactionHash0xFindIt'));
+          if (hash) return once(['resume', '--hash', hash, '--id', x.id], t('tui.settle', { action: x.action }));
+        } else {
+          const sure = await ask(t('tui.sureItWasNeverSent'));
+          if (sure === 'yes') return once(['resume', '--abandon', x.id], t('tui.abandon', { action: x.action }));
+        }
+      }
+      draw();
+    }
+    function onKey(str, key = {}) {
+      const k = { ...key, str };
+      if (k.ctrl && k.name === 'c') return quit();
+      if (prompt) {
+        const p = prompt;
+        if (k.name === 'return') { prompt = null; p.resolve(p.value.trim()); }
+        else if (k.name === 'escape') { prompt = null; p.resolve(null); }
+        else if (k.name === 'backspace') p.value = [...p.value].slice(0, -1).join('');
+        else if (str && !k.ctrl && !k.meta && str >= ' ') p.value += str;
+        return draw();
+      }
+      if (k.name === 'pageup') { logBack += 5; return draw(); }
+      if (k.name === 'pagedown') { logBack = Math.max(0, logBack - 5); return draw(); }
+      if (k.str === 'q') return quit();
+      if (executing) return;
+      if (pending) {
+        if (k.str === 'y') return confirm();
+        if (k.str === 'n' || k.name === 'escape') { note('plan', `${pending.title}${t('common.colon')}${t('tui.cancelledNothingSent')}`, 'dim'); pending = null; return draw(); }
+        return; // a plan waits for y or n; nothing else runs meanwhile
+      }
+      if (inflight.some((j) => j.checking)) return; // a plan is being checked
+      if (k.str === 'L' || k.str === 'l') { if (login.state !== 'CONNECTED') startLogin(); return; }
+      if (k.str === 'i') return switchLang();
+      if (showLogin) {
+        if (k.name === 'escape') {
+          stopLogin(); showLogin = false;
+          login = { state: 'UNCONNECTED' };
+          note('login', t('tui.skippedLoginYouCanBrowse'), 'dim');
+        }
+        return;
+      }
+      if (/^[1-9]$/.test(k.str ?? '') && Number(k.str) <= TABS.length) return switchTab(Number(k.str) - 1);
+      if (k.name === 'tab' || k.name === 'right') return switchTab((tab + (k.shift ? TABS.length - 1 : 1)) % TABS.length);
+      if (k.name === 'left') return switchTab((tab + TABS.length - 1) % TABS.length);
+      if (k.str === 'r') return refresh();
+      status = null;
+      onListKey(k);
+    }
+
+    // Leave the terminal usable however the process ends (a crash included).
+    function restore() { input.setRawMode?.(false); output.write(`${RESET}\x1b[?25h\x1b[?1049l`); }
+    process.on('exit', restore);
+    emitKeypressEvents(input);
+    input.setRawMode?.(true);
+    input.resume();
+    input.on('keypress', onKey);
+    output.on?.('resize', draw);
+    output.write('\x1b[?1049h\x1b[?25l\x1b[2J');
+    note('start', t('tui.bnatStarted'));
+    checkLogin();
+  });
+}