@defdone/annon 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/browser/login-dom.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Puts a request summary and status on the approval page. Every value is set with `textContent`;
+ * this module never parses markup.
+ */
+import type { Status } from './login-status.js';
+import type { Summary } from './login-view.js';
+declare const IDS: readonly ["title", "pair", "summary", "amount", "rows", "message-box", "message-label", "message", "terms-box", "terms", "warnings", "note", "wallet-field", "approve", "status", "action"];
+export type PageElements = Record<(typeof IDS)[number], HTMLElement>;
+export declare function pageElements(doc: Document): PageElements;
+/** Shows one request. Returns the element the caller updates with the time left. */
+export declare function renderSummary(doc: Document, el: PageElements, s: Summary, technical: string): HTMLElement;
+export declare function showStatus(el: PageElements, status: Status): void;
+export {};

package/dist/browser/login-dom.js

@@ -0,0 +1,67 @@
+/**
+ * Puts a request summary and status on the approval page. Every value is set with `textContent`;
+ * this module never parses markup.
+ */
+const IDS = [
+    'title',
+    'pair',
+    'summary',
+    'amount',
+    'rows',
+    'message-box',
+    'message-label',
+    'message',
+    'terms-box',
+    'terms',
+    'warnings',
+    'note',
+    'wallet-field',
+    'approve',
+    'status',
+    'action',
+];
+export function pageElements(doc) {
+    return Object.fromEntries(IDS.map((id) => [id, doc.getElementById(id)]));
+}
+function rows(doc, target, list) {
+    const values = list.map((r) => {
+        const row = doc.createElement('div');
+        const dt = doc.createElement('dt');
+        const dd = doc.createElement('dd');
+        row.className = 'row';
+        dt.textContent = r.label;
+        dd.textContent = r.value;
+        if (r.mono)
+            dd.className = 'mono';
+        row.append(dt, dd);
+        return [row, dd];
+    });
+    target.replaceChildren(...values.map(([row]) => row));
+    return values.map(([, dd]) => dd);
+}
+/** Shows one request. Returns the element the caller updates with the time left. */
+export function renderSummary(doc, el, s, technical) {
+    el.title.textContent = s.title;
+    el.amount.textContent = s.amount ?? '';
+    el.amount.hidden = !s.amount;
+    const dds = rows(doc, el.rows, [...s.rows, { label: 'Expires', value: '' }]);
+    el['message-box'].hidden = !s.message;
+    el['message-label'].textContent = s.message?.label ?? '';
+    el.message.textContent = s.message?.text ?? '';
+    el['terms-box'].hidden = s.terms.length === 0;
+    rows(doc, el.terms, s.terms);
+    el.warnings.replaceChildren(...s.warnings.map((w) => {
+        const li = doc.createElement('li');
+        li.textContent = w;
+        return li;
+    }));
+    el.warnings.hidden = s.warnings.length === 0;
+    el.note.textContent = s.note;
+    el.action.textContent = technical;
+    el.summary.hidden = false;
+    return dds[dds.length - 1];
+}
+export function showStatus(el, status) {
+    el.status.textContent = status.text;
+    el.status.className = `status ${status.tone}`;
+}

package/dist/browser/login-dropdown.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The NEAR wallet picker: the WAI-ARIA APG "select-only combobox" (a focusable combobox element
+ * and a listbox popup), so the list is styled by the page instead of drawn as an OS menu. The
+ * options are fixed here; the chosen value is still validated where it is used (login-wallet.ts).
+ */
+export interface WalletOption {
+    /** Element id of the option in the page shell. */
+    id: string;
+    value: string;
+    label: string;
+}
+export declare const WALLET_OPTIONS: readonly WalletOption[];
+export interface PickerState {
+    open: boolean;
+    /** The highlighted option while open. */
+    active: number;
+    selected: number;
+}
+/**
+ * One key on the combobox. Returns the next state, or undefined when the key is not handled.
+ * Closed: ArrowDown/ArrowUp/Enter/Space open on the selection, Home/End open on the first/last.
+ * Open: arrows, Home and End move; Enter, Space and Tab choose an enabled option; Escape closes.
+ */
+export declare function pickerKey(s: PickerState, key: string, disabled: readonly boolean[]): PickerState | undefined;
+/** Binds the picker to the page shell: `#near-wallet` (combobox) and `#near-wallet-list` (listbox). */
+export declare function walletPicker(doc: Document, onChange: () => void): {
+    value: () => string;
+    /** Disable one option, e.g. HOT Wallet off mainnet. The selection is kept and refused on use. */
+    setDisabled(value: string, off: boolean): void;
+    /** While a wallet is open or the request is finished, the choice cannot change. */
+    setLocked(on: boolean): void;
+};

package/dist/browser/login-dropdown.js

@@ -0,0 +1,129 @@
+/**
+ * The NEAR wallet picker: the WAI-ARIA APG "select-only combobox" (a focusable combobox element
+ * and a listbox popup), so the list is styled by the page instead of drawn as an OS menu. The
+ * options are fixed here; the chosen value is still validated where it is used (login-wallet.ts).
+ */
+export const WALLET_OPTIONS = [
+    { id: 'near-wallet-meteor', value: 'meteor-wallet', label: 'Meteor Wallet' },
+    { id: 'near-wallet-hot', value: 'hot-wallet', label: 'HOT Wallet' },
+];
+/** The next enabled option from `from` in `step` direction, or `from` when there is none. */
+function move(from, step, disabled) {
+    for (let i = from + step; i >= 0 && i < disabled.length; i += step)
+        if (!disabled[i])
+            return i;
+    return from;
+}
+const first = (disabled) => move(-1, 1, disabled);
+const last = (disabled) => move(disabled.length, -1, disabled);
+/**
+ * One key on the combobox. Returns the next state, or undefined when the key is not handled.
+ * Closed: ArrowDown/ArrowUp/Enter/Space open on the selection, Home/End open on the first/last.
+ * Open: arrows, Home and End move; Enter, Space and Tab choose an enabled option; Escape closes.
+ */
+export function pickerKey(s, key, disabled) {
+    if (!s.open) {
+        if (['ArrowDown', 'ArrowUp', 'Enter', ' '].includes(key))
+            return { ...s, open: true, active: s.selected };
+        if (key === 'Home')
+            return { ...s, open: true, active: first(disabled) };
+        if (key === 'End')
+            return { ...s, open: true, active: last(disabled) };
+        return undefined;
+    }
+    if (key === 'ArrowDown')
+        return { ...s, active: move(s.active, 1, disabled) };
+    if (key === 'ArrowUp')
+        return { ...s, active: move(s.active, -1, disabled) };
+    if (key === 'Home')
+        return { ...s, active: first(disabled) };
+    if (key === 'End')
+        return { ...s, active: last(disabled) };
+    if (key === 'Escape')
+        return { ...s, open: false };
+    if (key === 'Enter' || key === ' ' || key === 'Tab')
+        return {
+            ...s,
+            open: false,
+            selected: disabled[s.active] ? s.selected : s.active,
+        };
+    return undefined;
+}
+/** Binds the picker to the page shell: `#near-wallet` (combobox) and `#near-wallet-list` (listbox). */
+export function walletPicker(doc, onChange) {
+    const combo = doc.getElementById('near-wallet');
+    const list = doc.getElementById('near-wallet-list');
+    const label = doc.getElementById('near-wallet-value');
+    const options = WALLET_OPTIONS.map((o) => doc.getElementById(o.id));
+    const disabled = WALLET_OPTIONS.map(() => false);
+    let state = { open: false, active: 0, selected: 0 };
+    let locked = false;
+    const render = () => {
+        combo.setAttribute('aria-expanded', String(state.open));
+        combo.setAttribute('aria-disabled', String(locked));
+        list.hidden = !state.open;
+        if (state.open)
+            combo.setAttribute('aria-activedescendant', WALLET_OPTIONS[state.active]?.id ?? '');
+        else
+            combo.removeAttribute('aria-activedescendant');
+        options.forEach((o, i) => {
+            o.setAttribute('aria-selected', String(i === state.selected));
+            o.setAttribute('aria-disabled', String(disabled[i]));
+            o.className = `option${i === state.active && state.open ? ' active' : ''}`;
+        });
+        label.textContent = WALLET_OPTIONS[state.selected]?.label ?? '';
+    };
+    const update = (next) => {
+        const changed = next.selected !== state.selected;
+        state = next;
+        render();
+        if (changed)
+            onChange();
+    };
+    combo.onkeydown = (e) => {
+        if (locked)
+            return;
+        const next = pickerKey(state, e.key, disabled);
+        if (!next)
+            return;
+        if (e.key !== 'Tab')
+            e.preventDefault();
+        update(next);
+    };
+    combo.onclick = () => {
+        if (!locked)
+            update({ ...state, open: !state.open, active: state.selected });
+    };
+    options.forEach((o, i) => {
+        o.onclick = () => {
+            if (locked || disabled[i])
+                return;
+            update({ open: false, active: i, selected: i });
+            combo.focus();
+        };
+    });
+    // Close on any press outside the picker.
+    doc.addEventListener?.('pointerdown', (e) => {
+        const target = e.target;
+        if (state.open && !combo.contains(target) && !list.contains(target))
+            update({ ...state, open: false });
+    });
+    render();
+    return {
+        value: () => WALLET_OPTIONS[state.selected]?.value ?? '',
+        /** Disable one option, e.g. HOT Wallet off mainnet. The selection is kept and refused on use. */
+        setDisabled(value, off) {
+            const i = WALLET_OPTIONS.findIndex((o) => o.value === value);
+            if (i >= 0)
+                disabled[i] = off;
+            render();
+        },
+        /** While a wallet is open or the request is finished, the choice cannot change. */
+        setLocked(on) {
+            locked = on;
+            if (on)
+                state = { ...state, open: false };
+            render();
+        },
+    };
+}

package/dist/browser/login-format.d.ts

@@ -0,0 +1,16 @@
+/** Plain-text formatting for the approval page: amounts, times and byte strings. */
+/** Any value as plain text. Objects become JSON, so nothing is ever interpreted as markup. */
+export declare const text: (v: unknown) => string;
+export declare const record: (v: unknown) => Record<string, unknown>;
+/** Base units as a decimal string, e.g. `formatUnits('200000', 6)` is `0.2`. Non-integers stay as given. */
+export declare function formatUnits(value: unknown, decimals: number): string;
+/** Minutes and seconds left, e.g. `1:05`; never negative. */
+export declare function clock(ms: number): string;
+/** A local date and time, e.g. `2026-11-14 14:02:11`. */
+export declare function localTime(ms: number): string;
+/** The request's own expiry, e.g. `1:45 left (until 14:02:11)` or `Expired`. */
+export declare function expiryText(expiresAt: number, now: number): string;
+/** A unix time in seconds (string or number) as local time, or the raw value when not one. */
+export declare const secondsTime: (v: unknown) => string;
+/** A 32-byte NEP-413 nonce as hex. Anything else is returned unchanged. */
+export declare function nonceHex(nonce: unknown): unknown;

package/dist/browser/login-format.js

@@ -0,0 +1,52 @@
+/** Plain-text formatting for the approval page: amounts, times and byte strings. */
+/** Any value as plain text. Objects become JSON, so nothing is ever interpreted as markup. */
+export const text = (v) => typeof v === 'string'
+    ? v
+    : typeof v === 'number' || typeof v === 'bigint' || typeof v === 'boolean'
+        ? String(v)
+        : v === undefined || v === null
+            ? ''
+            : JSON.stringify(v);
+export const record = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+/** Base units as a decimal string, e.g. `formatUnits('200000', 6)` is `0.2`. Non-integers stay as given. */
+export function formatUnits(value, decimals) {
+    const raw = text(value);
+    if (!/^[0-9]+$/.test(raw))
+        return raw;
+    const digits = raw.replace(/^0+(?=.)/, '').padStart(decimals + 1, '0');
+    const whole = digits.slice(0, digits.length - decimals);
+    const fraction = digits.slice(digits.length - decimals).replace(/0+$/, '');
+    return fraction ? `${whole}.${fraction}` : whole;
+}
+/** Minutes and seconds left, e.g. `1:05`; never negative. */
+export function clock(ms) {
+    const s = Math.max(0, Math.ceil(ms / 1000));
+    return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
+}
+/** A local date and time, e.g. `2026-11-14 14:02:11`. */
+export function localTime(ms) {
+    const d = new Date(ms);
+    if (Number.isNaN(d.getTime()))
+        return '';
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+/** The request's own expiry, e.g. `1:45 left (until 14:02:11)` or `Expired`. */
+export function expiryText(expiresAt, now) {
+    return now >= expiresAt
+        ? 'Expired'
+        : `${clock(expiresAt - now)} left (until ${localTime(expiresAt).slice(11)})`;
+}
+/** A unix time in seconds (string or number) as local time, or the raw value when not one. */
+export const secondsTime = (v) => {
+    const raw = text(v);
+    return /^[0-9]{1,12}$/.test(raw) ? `${localTime(Number(raw) * 1000)} local time` : raw;
+};
+/** A 32-byte NEP-413 nonce as hex. Anything else is returned unchanged. */
+export function nonceHex(nonce) {
+    return Array.isArray(nonce) &&
+        nonce.length === 32 &&
+        nonce.every((n) => Number.isInteger(n) && n >= 0 && n < 256)
+        ? `0x${nonce.map((n) => n.toString(16).padStart(2, '0')).join('')}`
+        : nonce;
+}

package/dist/browser/login-status.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Why a wallet attempt failed, as a fixed reason the page shows and may report to the CLI. Only
+ * these reason names cross to the terminal, so no wallet- or page-supplied text is ever printed.
+ */
+export declare const WALLET_FAILURES: readonly ["window_closed", "popup_blocked", "rejected", "wallet_error", "refused", "send_uncertain"];
+export type WalletFailure = (typeof WALLET_FAILURES)[number];
+export declare const isWalletFailure: (v: unknown) => v is WalletFailure;
+/** A refusal written by the page itself (wrong chain, wallet not offered); its message is shown as is. */
+export declare class Refusal extends Error {
+}
+/** Any failure after the wallet's send call started, whatever the wallet says: it may have broadcast. */
+export declare class SendUncertain extends Error {
+}
+/** The reason and the page text for a failed wallet attempt. */
+export declare function walletFailure(error: unknown): {
+    reason: WalletFailure;
+    text: string;
+};
+export type Tone = 'idle' | 'wait' | 'ok' | 'error';
+export interface Status {
+    tone: Tone;
+    text: string;
+}
+export declare const STATUS: {
+    readonly noCapability: {
+        readonly tone: "error";
+        readonly text: "Open the exact URL printed by your CLI.";
+    };
+    readonly waitingCli: {
+        readonly tone: "idle";
+        readonly text: "Waiting for the CLI to send a request.";
+    };
+    readonly ready: {
+        readonly tone: "idle";
+        readonly text: "Check the details, then continue in your wallet.";
+    };
+    readonly connect: {
+        readonly tone: "idle";
+        readonly text: "Transactions take two steps: connect your wallet first, then review the transaction.";
+    };
+    readonly wallet: {
+        readonly tone: "wait";
+        readonly text: "Waiting for your wallet. Finish or cancel there.";
+    };
+    readonly verifying: {
+        readonly tone: "wait";
+        readonly text: "Signed. The CLI is checking the result.";
+    };
+    readonly signed: {
+        readonly tone: "ok";
+        readonly text: "Signed. Return to the terminal. Keep this tab open if the command asks for another approval.";
+    };
+    readonly redirected: {
+        readonly tone: "ok";
+        readonly text: "Proof returned to the approval window. Return to your terminal.";
+    };
+    readonly rejected: {
+        readonly tone: "error";
+        readonly text: "The CLI did not accept the wallet result. Check the terminal for the reason.";
+    };
+    readonly expired: {
+        readonly tone: "error";
+        readonly text: "This request expired. Run the command again in the terminal.";
+    };
+    readonly ended: {
+        readonly tone: "error";
+        readonly text: "The approval session has ended. Return to the terminal.";
+    };
+};
+export declare const connected: (account: string) => Status;

package/dist/browser/login-status.js

@@ -0,0 +1,85 @@
+/**
+ * Why a wallet attempt failed, as a fixed reason the page shows and may report to the CLI. Only
+ * these reason names cross to the terminal, so no wallet- or page-supplied text is ever printed.
+ */
+export const WALLET_FAILURES = [
+    'window_closed',
+    'popup_blocked',
+    'rejected',
+    'wallet_error',
+    'refused',
+    /** The wallet's send call ran and then failed: the transaction may be on chain. Never retried. */
+    'send_uncertain',
+];
+export const isWalletFailure = (v) => WALLET_FAILURES.includes(v);
+/** A refusal written by the page itself (wrong chain, wallet not offered); its message is shown as is. */
+export class Refusal extends Error {
+}
+/** Any failure after the wallet's send call started, whatever the wallet says: it may have broadcast. */
+export class SendUncertain extends Error {
+}
+const AGAIN = 'Try again or pick another wallet.';
+/** The reason and the page text for a failed wallet attempt. */
+export function walletFailure(error) {
+    if (error instanceof Refusal)
+        return { reason: 'refused', text: error.message };
+    if (error instanceof SendUncertain)
+        return {
+            reason: 'send_uncertain',
+            text: 'The wallet may have sent the transaction. Do not approve it again. Return to the terminal.',
+        };
+    const e = (error && typeof error === 'object' ? error : {});
+    const message = typeof error === 'string' ? error : String(e.message ?? '');
+    const tags = Array.isArray(e.endTags) ? e.endTags : [];
+    // Meteor's SDK: closed_window from its popup, WINDOW_CLOSED when the opener sees it closed, and
+    // POPUP_WINDOW_OPEN_FAILED when window.open returned nothing.
+    if (tags.includes('POPUP_WINDOW_OPEN_FAILED') || /open popup/i.test(message))
+        return {
+            reason: 'popup_blocked',
+            text: 'Your browser blocked the wallet window. Allow pop-ups for this page, then try again.',
+        };
+    if (tags.includes('WINDOW_CLOSED') || /closed the window|window closed/i.test(message))
+        return { reason: 'window_closed', text: `The wallet window closed before signing. ${AGAIN}` };
+    // EIP-1193 4001 is a user rejection.
+    if (e.code === 4001 || /reject|denied|declined|cancel/i.test(message))
+        return { reason: 'rejected', text: `The wallet declined the request. ${AGAIN}` };
+    return {
+        reason: 'wallet_error',
+        text: `The wallet could not complete the request${message ? ` (${message.slice(0, 200)})` : ''}. ${AGAIN}`,
+    };
+}
+export const STATUS = {
+    noCapability: { tone: 'error', text: 'Open the exact URL printed by your CLI.' },
+    waitingCli: { tone: 'idle', text: 'Waiting for the CLI to send a request.' },
+    ready: { tone: 'idle', text: 'Check the details, then continue in your wallet.' },
+    connect: {
+        tone: 'idle',
+        text: 'Transactions take two steps: connect your wallet first, then review the transaction.',
+    },
+    wallet: { tone: 'wait', text: 'Waiting for your wallet. Finish or cancel there.' },
+    verifying: { tone: 'wait', text: 'Signed. The CLI is checking the result.' },
+    signed: {
+        tone: 'ok',
+        text: 'Signed. Return to the terminal. Keep this tab open if the command asks for another approval.',
+    },
+    redirected: {
+        tone: 'ok',
+        text: 'Proof returned to the approval window. Return to your terminal.',
+    },
+    rejected: {
+        tone: 'error',
+        text: 'The CLI did not accept the wallet result. Check the terminal for the reason.',
+    },
+    expired: {
+        tone: 'error',
+        text: 'This request expired. Run the command again in the terminal.',
+    },
+    ended: {
+        tone: 'error',
+        text: 'The approval session has ended. Return to the terminal.',
+    },
+};
+export const connected = (account) => ({
+    tone: 'idle',
+    text: `Connected as ${account}. Now review the transaction in your wallet.`,
+});

package/dist/browser/login-terms.d.ts

@@ -0,0 +1,10 @@
+type Row = {
+    label: string;
+    value: string;
+    mono?: boolean;
+};
+export declare function describeTerms(terms: unknown, signedPrice?: string): {
+    rows: Row[];
+    warnings: string[];
+};
+export {};

package/dist/browser/login-terms.js

@@ -0,0 +1,69 @@
+/**
+ * The CLI's payment or listing terms attached to a signing request (`SigningRequest.terms`). They
+ * are review context, not what the wallet signs: the page shows them apart from the signed request
+ * and warns when their price differs from the amount the request signs.
+ */
+import { formatUnits, record, text } from './login-format.js';
+/** `{kind, id}` as `NEAR alice.near` or `EVM 0x...`; anything else as plain text. */
+const identity = (v) => {
+    const i = record(v);
+    return typeof i.kind === 'string' && typeof i.id === 'string'
+        ? `${i.kind === 'evm' ? 'EVM' : i.kind === 'near' ? 'NEAR' : i.kind === 'solana' ? 'Solana' : i.kind} ${i.id}`
+        : text(v);
+};
+const near = (v) => (/^[0-9]+$/.test(text(v)) ? `${formatUnits(v, 24)} NEAR` : text(v));
+/** Split recipients with their share; the remainder recipient also gets the rounding rest. */
+function split(recipients, remainder) {
+    if (!Array.isArray(recipients))
+        return [];
+    return recipients.map((r, i) => {
+        const bps = Number(record(r).bps);
+        const share = Number.isInteger(bps) ? `${(bps / 100).toFixed(2)}%` : text(record(r).bps);
+        return {
+            label: recipients.length === 1 ? 'Paid to' : `Recipient ${i + 1}`,
+            value: `${identity(record(r).identity)} ${share}${i === remainder ? ', plus the rounding remainder' : ''}`,
+            mono: true,
+        };
+    });
+}
+export function describeTerms(terms, signedPrice) {
+    const t = record(terms);
+    if (!Object.keys(t).length)
+        return { rows: [], warnings: [] };
+    const s = record(t.split);
+    const source = record(t.source);
+    const optional = (label, v, mono = true, format = text) => v === undefined || v === null || v === '' ? [] : [{ label, value: format(v), mono }];
+    const rows = [
+        ...optional('File', t.file),
+        ...optional('Resource', t.resource),
+        ...optional('Seller', t.seller, true, identity),
+        ...optional('Host', t.host),
+        ...optional('Contract', t.contract),
+        ...optional('Route', t.route, false),
+        ...optional('Price', t.price, false, (v) => `${formatUnits(v, 6)} USDC`),
+        ...optional('Token', t.token),
+        ...split(t.recipients ?? s.recipients, t.remainder ?? s.remainder),
+        ...optional('Base payout address', t.baseRecipient),
+        ...optional('Protocol fee', t.fee, false),
+        ...optional('Listing storage', t.listingStorage, false, near),
+        ...optional('Purchase storage', t.purchaseStorage, false, near),
+        ...(Object.keys(source).length
+            ? [
+                {
+                    label: 'Pay from',
+                    value: `${text(source.amountFormatted ?? source.amount)} ${text(source.symbol ?? source.asset)} on ${text(source.chain)}`,
+                },
+                ...optional('Deposit before', source.depositBefore, false),
+            ]
+            : []),
+    ];
+    const price = text(t.price);
+    return {
+        rows,
+        warnings: signedPrice !== undefined && price && price !== signedPrice
+            ? [
+                `The CLI's terms say ${formatUnits(price, 6)} USDC, but the request signs ${formatUnits(signedPrice, 6)}. Do not approve.`,
+            ]
+            : [],
+    };
+}

package/dist/browser/login-view.d.ts

@@ -0,0 +1,34 @@
+/**
+ * What the approval page shows for one signing request. Every value comes from the request object
+ * the page signs (`operation`, `chain`, `account`, `expiresAt`, `payload`); `terms` is the CLI's
+ * review context and is shown apart from it, labelled as such. Pure functions: the DOM code sets
+ * each returned string as text, never as markup.
+ */
+import type { SigningRequest } from '../node/signing.js';
+export interface Row {
+    label: string;
+    value: string;
+    /** Addresses, hashes and other values a person compares character by character. */
+    mono?: boolean;
+}
+export interface Summary {
+    title: string;
+    /** The headline amount of a payment, e.g. `0.2 USDC`. */
+    amount?: string;
+    rows: Row[];
+    /** The exact text a wallet signs, or the arguments of a transaction. */
+    message?: {
+        label: string;
+        text: string;
+    };
+    /** What signing does and does not do. */
+    note: string;
+    /** The CLI's payment or listing terms, when the request carries them. */
+    terms: Row[];
+    warnings: string[];
+}
+/** The whole request as JSON, with a NEP-413 nonce as hex instead of 32 numbers. */
+export declare function technicalDetails(q: SigningRequest): string;
+export declare const networkName: (chain: string) => string;
+/** The summary of one signing request. Unknown operations are described as such, never guessed. */
+export declare function describeRequest(q: SigningRequest): Summary;