@floatonnear/float-adapter 0.2.0 → 0.3.0

package/dist/handlers.d.ts

@@ -19,6 +19,12 @@ export interface DeliveryRecord {
 export interface AdapterConfig {
     token: string;
     decimals: number;
+    /**
+     * The vault account. Needed to enumerate VIRTUAL agents, whose keys live on
+     * the vault itself. Optional so a caller that only wants account-bound
+     * agents still works rather than being forced to supply it.
+     */
+    vault?: string;
     /**
      * Base deliveries, keyed by request id, as the relayer recorded them.
      *
@@ -112,6 +118,11 @@ export interface VaultInfo {
      * never arrived. Null when the token contract cannot be read.
      */
     vaultTokenBalance: string | null;
+    /**
+     * The contract's own UTC day counter, for building a `purge_settled`
+     * cutoff. Null when it could not be read — never 0, which is a real day.
+     */
+    currentDay: number | null;
 }
 /**
  * `near` / `testnet` / anything else. Derived from the network the contract
@@ -129,12 +140,20 @@ export interface AgentKeyView {
     frozen: boolean;
     keys: {
         publicKey: string;
-        /** True only if the key really is a function-call key. */
+        /** True if the key names specific methods — a function-call OR gas key. */
         restricted: boolean;
         receiverId: string | null;
         methodNames: string[];
         allowanceYocto: string | null;
+        /** NEP-611 gas keys only. For these the balance IS the spending cap. */
+        gasBalanceYocto: string | null;
     }[];
+    /**
+     * True for a VIRTUAL agent: a gas key on the vault rather than a bound
+     * account. `accountId` is then the vault itself, which is what "virtual"
+     * means — there is no separate account.
+     */
+    virtual?: boolean;
     /** Set when the key list could not be read, so the UI can say so. */
     error?: string;
 }
@@ -147,6 +166,14 @@ export type KeyFn = (accountId: string) => Promise<{
                 receiver_id: string;
                 method_names: string[];
             };
+        } | {
+            GasKeyFunctionCall: {
+                allowance: string | null;
+                balance: string;
+                receiver_id: string;
+                method_names: string[];
+                num_nonces?: number;
+            };
         };
     };
 }[]>;
@@ -160,7 +187,106 @@ export type KeyFn = (accountId: string) => Promise<{
  * trying to rule out. `restricted` here is computed from the permission NEAR
  * reports, and a FullAccess key makes it false.
  */
-export declare function getAgentKeys(view: ViewFn, keys: KeyFn, _cfg: AdapterConfig): Promise<AgentKeyView[]>;
+/** What `coverageNote` returns, so a UI renders a fact rather than composing one. */
+export interface CoverageNote {
+    /** False when no scan has ever run. NOT the same as "no refusals". */
+    scanned: boolean;
+    /** Blocks inside the claimed range that were never actually read. */
+    unreadBlocks: number;
+    /** A sentence safe to render verbatim. */
+    text: string;
+    /**
+     * The same caveat in one line, for somewhere `text` does not fit.
+     *
+     * On a 375px screen `text` is a three-sentence amber paragraph that was
+     * the largest thing on the activity page — bigger than the payments it
+     * qualifies. The obvious fix is for the page to shorten it, and that is
+     * the fix this module exists to prevent: a formatter in JSX drifts, and
+     * the direction it drifts is toward claiming more coverage than exists.
+     *
+     * So the short form is built HERE, under the same tests, and it keeps the
+     * load-bearing word. "1,500 blocks read" alone is a boast; "outside them,
+     * unknown" is the part that stops a reader treating a quiet list as an
+     * empty one. The heights are dropped, not the distinction — a height is
+     * for checking the claim, and the full `text` is one tap away.
+     */
+    short: string;
+    /**
+     * The state of the refusal history, in words a user can act on.
+     *
+     * `text` and `short` both lead with block heights. A height is an
+     * identifier for checking the claim; it is not something a person reading
+     * their payments can do anything with, and leading with it is why the
+     * caveat read as noise rather than as information — the owner's words:
+     * "i dont understand it and also i dont like it showing up on our page".
+     *
+     * So this is the version that goes on the page. It states the only thing
+     * a reader needs: whether the refusal list can be trusted as complete.
+     * The heights stay available behind it.
+     *
+     * MAY BE vs IS, and the difference is real:
+     *   nothing scanned   — nobody has looked at all
+     *   unread blocks     — IS incomplete; specific blocks are known missing
+     *   a clean range     — MAY BE incomplete, because the range is still a
+     *                       window and outside it is unknown. There is no
+     *                       "complete" state to report: the adapter cannot
+     *                       know one without the vault's creation height and
+     *                       the chain head, neither of which it has.
+     */
+    headline: string;
+}
+/**
+ * State what the refusal history actually covers, in words.
+ *
+ * `blockedCoverage` has been on /v1/dashboard for a while, computed behind a
+ * comment reading "A UI that shows 0 blocked without this cannot distinguish
+ * an honest zero from an unscanned range" — and no page rendered it. So the
+ * activity page showed four payments and zero refusals with nothing saying
+ * that 95% of the vault's blocks had never been read.
+ *
+ * The sentence is built HERE, not in JSX, because this module owns the
+ * distinction and has the tests. A formatter duplicated in a component is one
+ * that drifts, and the direction it drifts is always toward claiming more
+ * coverage than exists.
+ *
+ * Deliberately NOT expressed as a percentage. That would need the vault's
+ * creation height and the chain head, neither of which this handler has, and
+ * an invented denominator is exactly the plausible-wrong-number this file
+ * warns about. The range and the block count are facts; a ratio would not be.
+ */
+export declare function coverageNote(scan: AdapterConfig["blockedScan"] | null | undefined): CoverageNote;
+/**
+ * Every agent that may spend, with its keys read FROM THE CHAIN.
+ *
+ * The restriction is the product's central security claim, so the page that
+ * states it must not state it from a constant. A hardcoded "restricted to
+ * request_payment" would keep rendering happily if someone added a full-access
+ * key to an agent — exactly the regression a reader of that page is trying to
+ * rule out. `restricted` is computed from the permission NEAR reports.
+ *
+ * TWO RAILS, and this used to see only one:
+ *
+ *   ACCOUNT  `bind_agent` sets `node.account`, and the keys live on that
+ *            account. Kept: it binds an account that already exists and whose
+ *            owner already controls it, so it strands nothing.
+ *
+ *   VIRTUAL  `bind_virtual_agent` maps a public key to a node and leaves
+ *            `node.account` as None — deliberately, because that field means
+ *            "a real sub-account is bound here" and a virtual agent is the
+ *            absence of one. The key is a NEP-611 gas key ON THE VAULT.
+ *
+ * This filtered on `n.account` alone. Once sub-accounts were retired that is
+ * null on every node of every new vault, so the page rendered an EMPTY LIST
+ * for a correctly configured vault — which reads as "nothing is authorised
+ * here", the exact inversion the `error` field exists to prevent elsewhere.
+ *
+ * There is no view that lists bound keys, only `get_virtual_agent_node(pk)`.
+ * So the enumeration runs the other way: take the vault's own access keys and
+ * ask the contract which of them are bound. That also means the owner's
+ * full-access key — which the factory now installs — is correctly excluded,
+ * because it is not bound to any node.
+ */
+export declare function getAgentKeys(view: ViewFn, keys: KeyFn, cfg: AdapterConfig): Promise<AgentKeyView[]>;
 export declare function getDashboard(view: ViewFn, cfg: AdapterConfig): Promise<{
     owner: {
         authMethod: string;
@@ -170,7 +296,7 @@ export declare function getDashboard(view: ViewFn, cfg: AdapterConfig): Promise<
     treasury: {
         ownerId: string;
         walletAddress: string;
-        createdAt: string;
+        createdAt: null;
         amount: string;
         currency: string;
         decimals: number;
@@ -185,6 +311,7 @@ export declare function getDashboard(view: ViewFn, cfg: AdapterConfig): Promise<
             to: number;
         }>;
     } | null | undefined;
+    blockedCoverageNote: CoverageNote;
     transactionStats: {
         total: number;
         approved: number;
@@ -192,14 +319,60 @@ export declare function getDashboard(view: ViewFn, cfg: AdapterConfig): Promise<
         failed: number;
         other: number;
     };
+    /**
+     * RECIPIENT AND MEMO TRAVEL SEPARATELY.
+     *
+     * `venue` USED to be `memo || recipient`, collapsing two different facts
+     * into one string: the Overview table showed "work12.testnet" for one
+     * payment and "first payment from a vault created in one signature" for
+     * the next, under a single heading, with no way to tell which you were
+     * looking at. `recipient` and `memo` were added beside it to separate them.
+     *
+     * AS OF 2026-11-11 THE MEMO IS REDACTED on this public surface (see
+     * map.ts), so `venue` is simply the recipient and `memo` is always null.
+     * The dashboard is keyless and multi-tenant — anyone can type a vault name
+     * — and a memo is what a company paid FOR.
+     *
+     * It is NOT secret: the memo is on chain and one view call away. This
+     * removes it from the surface that turned "know how to query a NEAR RPC"
+     * into "type a name". The agent's own `vault_history` reads the chain
+     * directly and still sees everything.
+     */
     recentActivity: {
         id: string;
         agent: string;
+        /**
+         * THE AGENT'S IDENTITY, not just its label.
+         *
+         * The Overview's activity rows seeded their avatar from `agent` (the
+         * NAME) while the budget tree two panels above seeded from `agentId`.
+         * Those hash differently, so one agent wore two colours on one page:
+         * "marketing" was yellow-green in the tree and pink in the table.
+         */
+        agentId: string;
         venue: string;
+        recipient: string | null;
+        memo: string | null;
         amount: string;
         rail: string;
         time: string;
         status: string;
+        /**
+         * THE REASON A PAYMENT WAS REFUSED, which this mapping used to drop.
+         *
+         * The blocked-row builder above already computes both of these from the
+         * contract's `request_blocked` event, and the Activity page renders
+         * them — but `recentActivity` listed eleven fields and neither was
+         * among them. So the Overview showed "BLOCKED" twice and said nothing
+         * about WHY, while the answer sat one object away.
+         *
+         * That is not cosmetic. The sharpest thing this product does is tell a
+         * sibling apart from its parent: `PARENT_DAILY_BUDGET` means someone
+         * else spent your pool, `DAILY_BUDGET` means you did. Dropping the code
+         * makes those two identical on the page a user actually lands on.
+         */
+        blockReason: string | null;
+        blockMessage: string | null;
     }[];
     paused: boolean;
 }>;

package/dist/handlers.js

@@ -98,6 +98,20 @@ export async function getVaultInfo(view, cfg, viewOn) {
     const vaultTokenBalance = await viewOn(cfg.token, "ft_balance_of", {
         account_id: c.vault_id,
     }).catch(() => null);
+    /**
+     * THE CONTRACT'S OWN DAY, not a computed one.
+     *
+     * `purge_settled(before_day, …)` removes records strictly before the day
+     * it is given, so a caller needs today's number to build "everything up to
+     * now". Deriving it from the browser clock would be a guess about the
+     * contract: the vault has a `clock_mode`, and a test clock does not track
+     * UTC. A cutoff that is one day wrong either deletes records that are
+     * still live or silently deletes nothing.
+     *
+     * Null on failure rather than 0: day zero is a real value, and it would
+     * mean "purge nothing" while looking like an answer.
+     */
+    const currentDay = await view("current_day", {}).catch(() => null);
     return {
         vaultId: c.vault_id,
         tokenId: cfg.token,
@@ -109,44 +123,128 @@ export async function getVaultInfo(view, cfg, viewOn) {
         clockMode: c.clock_mode,
         strictAllocation: c.strict_allocation,
         vaultTokenBalance,
+        currentDay,
     };
 }
 /**
- * The bound agent accounts, with their access keys read FROM THE CHAIN.
+ * State what the refusal history actually covers, in words.
+ *
+ * `blockedCoverage` has been on /v1/dashboard for a while, computed behind a
+ * comment reading "A UI that shows 0 blocked without this cannot distinguish
+ * an honest zero from an unscanned range" — and no page rendered it. So the
+ * activity page showed four payments and zero refusals with nothing saying
+ * that 95% of the vault's blocks had never been read.
+ *
+ * The sentence is built HERE, not in JSX, because this module owns the
+ * distinction and has the tests. A formatter duplicated in a component is one
+ * that drifts, and the direction it drifts is always toward claiming more
+ * coverage than exists.
+ *
+ * Deliberately NOT expressed as a percentage. That would need the vault's
+ * creation height and the chain head, neither of which this handler has, and
+ * an invented denominator is exactly the plausible-wrong-number this file
+ * warns about. The range and the block count are facts; a ratio would not be.
+ */
+export function coverageNote(scan) {
+    if (!scan) {
+        return {
+            scanned: false,
+            unreadBlocks: 0,
+            text: "Refusal history has not been scanned for this vault, so refusals are " +
+                "UNKNOWN rather than absent. A refusal is never stored on chain — only " +
+                "emitted as an event — so nothing can show them until " +
+                "scripts/scan-blocked.mjs has read the blocks.",
+            short: "Refusals not scanned — unknown, not absent.",
+            headline: "refusal history has not been scanned",
+        };
+    }
+    const unreadBlocks = (scan.holes ?? []).reduce((n, h) => n + (h.to - h.from + 1), 0);
+    const span = scan.to - scan.from + 1;
+    const n = (x) => x.toLocaleString("en-US");
+    // HEIGHTS ARE NOT FORMATTED. A block height is an identifier, not a
+    // quantity: "275,882,255" cannot be pasted into an explorer or an RPC call,
+    // and a reader checking the claim is exactly who this sentence is for. The
+    // COUNT is a quantity, so it keeps its separators.
+    let text = `Refusals have been read from blocks ${scan.from}–${scan.to} ` +
+        `(${n(span)} blocks). Outside that range they are UNKNOWN, not absent.`;
+    if (unreadBlocks > 0) {
+        text +=
+            ` ${n(unreadBlocks)} block${unreadBlocks === 1 ? "" : "s"} inside that range ` +
+                `could not be read and remain unread.`;
+    }
+    // The short form keeps the count, the unknown-outside caveat and the hole
+    // count, and drops only the heights. See the `short` field's own note for
+    // why it is built here and not in a component.
+    let short = `${n(span)} blocks read · outside them, unknown`;
+    if (unreadBlocks > 0)
+        short += ` · ${n(unreadBlocks)} unread inside`;
+    // "is" when blocks are known missing, "may be" when the only gap is
+    // everything outside the scanned window. See the `headline` field note.
+    const headline = unreadBlocks > 0
+        ? "refusal history is incomplete"
+        : "refusal history may be incomplete";
+    return { scanned: true, unreadBlocks, text, short, headline };
+}
+/** One access key, flattened, whichever permission variant NEAR reported. */
+function describeKey(k) {
+    const p = k.access_key.permission;
+    const obj = typeof p === "object" ? p : null;
+    // BOTH variants. A gas key is a `GasKeyFunctionCall`, NOT a `FunctionCall`
+    // with extra fields, so a check for the latter alone finds nothing on it and
+    // falls through to `restricted: false` — reporting a key that can call one
+    // method on one contract as if it could do anything.
+    const fc = obj && "FunctionCall" in obj ? obj.FunctionCall : null;
+    const gk = obj && "GasKeyFunctionCall" in obj ? obj.GasKeyFunctionCall : null;
+    const named = fc ?? gk;
+    return {
+        publicKey: k.public_key,
+        restricted: named !== null,
+        receiverId: named?.receiver_id ?? null,
+        methodNames: named?.method_names ?? [],
+        allowanceYocto: named?.allowance ?? null,
+        gasBalanceYocto: gk?.balance ?? null,
+    };
+}
+/**
+ * Every agent that may spend, with its keys read FROM THE CHAIN.
  *
  * The restriction is the product's central security claim, so the page that
  * states it must not state it from a constant. A hardcoded "restricted to
  * request_payment" would keep rendering happily if someone added a full-access
- * key to an agent account — exactly the regression a reader of that page is
- * trying to rule out. `restricted` here is computed from the permission NEAR
- * reports, and a FullAccess key makes it false.
+ * key to an agent — exactly the regression a reader of that page is trying to
+ * rule out. `restricted` is computed from the permission NEAR reports.
+ *
+ * TWO RAILS, and this used to see only one:
+ *
+ *   ACCOUNT  `bind_agent` sets `node.account`, and the keys live on that
+ *            account. Kept: it binds an account that already exists and whose
+ *            owner already controls it, so it strands nothing.
+ *
+ *   VIRTUAL  `bind_virtual_agent` maps a public key to a node and leaves
+ *            `node.account` as None — deliberately, because that field means
+ *            "a real sub-account is bound here" and a virtual agent is the
+ *            absence of one. The key is a NEP-611 gas key ON THE VAULT.
+ *
+ * This filtered on `n.account` alone. Once sub-accounts were retired that is
+ * null on every node of every new vault, so the page rendered an EMPTY LIST
+ * for a correctly configured vault — which reads as "nothing is authorised
+ * here", the exact inversion the `error` field exists to prevent elsewhere.
+ *
+ * There is no view that lists bound keys, only `get_virtual_agent_node(pk)`.
+ * So the enumeration runs the other way: take the vault's own access keys and
+ * ask the contract which of them are bound. That also means the owner's
+ * full-access key — which the factory now installs — is correctly excluded,
+ * because it is not bound to any node.
  */
-export async function getAgentKeys(view, keys, _cfg) {
+export async function getAgentKeys(view, keys, cfg) {
     const tree = await view("get_tree", {});
-    const bound = tree.filter((n) => n.account);
-    return Promise.all(bound.map(async (n) => {
-        const base = {
-            accountId: n.account,
-            nodeId: n.id,
-            label: n.label,
-            frozen: n.frozen,
-        };
+    const byId = new Map(tree.map((n) => [n.id, n]));
+    const accountRows = await Promise.all(tree
+        .filter((n) => n.account)
+        .map(async (n) => {
+        const base = { accountId: n.account, nodeId: n.id, label: n.label, frozen: n.frozen };
         try {
-            const list = await keys(n.account);
-            return {
-                ...base,
-                keys: list.map((k) => {
-                    const p = k.access_key.permission;
-                    const fc = typeof p === "object" && "FunctionCall" in p ? p.FunctionCall : null;
-                    return {
-                        publicKey: k.public_key,
-                        restricted: fc !== null,
-                        receiverId: fc?.receiver_id ?? null,
-                        methodNames: fc?.method_names ?? [],
-                        allowanceYocto: fc?.allowance ?? null,
-                    };
-                }),
-            };
+            return { ...base, keys: (await keys(n.account)).map(describeKey) };
         }
         catch (e) {
             // An unreadable key list is reported, never silently rendered as "no
@@ -155,6 +253,86 @@ export async function getAgentKeys(view, keys, _cfg) {
             return { ...base, keys: [], error: e instanceof Error ? e.message : String(e) };
         }
     }));
+    // Without a vault id there is nothing to enumerate. Degrade to account-only
+    // rather than guessing an account name.
+    if (!cfg.vault)
+        return accountRows;
+    let onVault;
+    try {
+        onVault = await keys(cfg.vault);
+    }
+    catch (e) {
+        return [
+            ...accountRows,
+            {
+                accountId: cfg.vault,
+                nodeId: -1,
+                label: "virtual agents",
+                frozen: false,
+                keys: [],
+                virtual: true,
+                error: e instanceof Error ? e.message : String(e),
+            },
+        ];
+    }
+    // Ask the contract which keys are bound. Concurrent: independent lookups.
+    const bindings = await Promise.all(onVault.map(async (k) => {
+        try {
+            return {
+                key: k,
+                nodeId: await view("get_virtual_agent_node", { public_key: k.public_key }),
+                error: null,
+            };
+        }
+        catch (e) {
+            return { key: k, nodeId: null, error: e instanceof Error ? e.message : String(e) };
+        }
+    }));
+    // A FAILED LOOKUP IS NOT "NOT AN AGENT". This first used
+    // `.catch(() => null)`, collapsing an RPC error into the same value as a
+    // genuine "not bound" — so a rate-limited chain renders "no virtual agents"
+    // for a vault that has them. That is the exact absent-versus-unreadable
+    // inversion the `error` field above exists to prevent, reintroduced while
+    // fixing the same class of bug. Surface it instead.
+    const unreadable = bindings.filter((b) => b.error !== null);
+    const lookupError = unreadable.length
+        ? `${unreadable.length} of ${bindings.length} key bindings could not be read: ${unreadable[0].error}`
+        : null;
+    // Group by node: MANY-TO-ONE is the point of virtual agents — several keys
+    // may share one node, so a swarm draws on a shared budget instead of
+    // consuming one of the 64 MAX_NODES per member.
+    const byNode = new Map();
+    for (const b of bindings) {
+        if (b.nodeId === null || b.nodeId === undefined)
+            continue;
+        const list = byNode.get(b.nodeId) ?? [];
+        list.push(b.key);
+        byNode.set(b.nodeId, list);
+    }
+    const virtualRows = [...byNode.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([nodeId, list]) => ({
+        accountId: cfg.vault,
+        nodeId,
+        label: byId.get(nodeId)?.label ?? `node ${nodeId}`,
+        frozen: byId.get(nodeId)?.frozen ?? false,
+        keys: list.map(describeKey),
+        virtual: true,
+    }));
+    // If some bindings were unreadable, say so as its own row rather than
+    // letting a short list imply a complete one.
+    if (lookupError) {
+        virtualRows.push({
+            accountId: cfg.vault,
+            nodeId: -1,
+            label: "virtual agents",
+            frozen: false,
+            keys: [],
+            virtual: true,
+            error: lookupError,
+        });
+    }
+    return [...accountRows, ...virtualRows];
 }
 export async function getDashboard(view, cfg) {
     const { tree, budgets, labels } = await loadTreeAndUsage(view, cfg);
@@ -175,7 +353,10 @@ export async function getDashboard(view, cfg) {
         treasury: {
             ownerId: cfgView.owner,
             walletAddress: cfgView.vault_id,
-            createdAt: new Date(0).toISOString(),
+            // null, not epoch zero: the contract records no vault creation time
+            // either. Inventing 1970 makes a missing value look like a known one.
+            // See ApiAgent.createdAt in map.ts.
+            createdAt: null,
             // The vault holds the tokens; the figure the dashboard cares about is
             // how much of the ROOT budget is still available today.
             amount: root?.limits[0]
@@ -190,6 +371,10 @@ export async function getDashboard(view, cfg) {
         // What the refusal history actually covers. A UI that shows "0 blocked"
         // without this cannot distinguish an honest zero from an unscanned range.
         blockedCoverage: cfg.blockedScan,
+        // The same fact as a sentence. Shipped alongside the raw range because the
+        // raw range sat here unrendered for weeks — a component had to compose the
+        // caveat itself, and none did. Giving it ready-made removes the excuse.
+        blockedCoverageNote: coverageNote(cfg.blockedScan),
         transactionStats: {
             total: onchain.length + cfg.blockedRing.length + Object.keys(cfg.chainBlocked ?? {}).length,
             // The Base rail's terminal states count as approved. "success" alone was
@@ -202,14 +387,62 @@ export async function getDashboard(view, cfg) {
             failed: onchain.filter((p) => p.status === "failed").length,
             other: onchain.filter((p) => p.status === "pending").length,
         },
+        /**
+         * RECIPIENT AND MEMO TRAVEL SEPARATELY.
+         *
+         * `venue` USED to be `memo || recipient`, collapsing two different facts
+         * into one string: the Overview table showed "work12.testnet" for one
+         * payment and "first payment from a vault created in one signature" for
+         * the next, under a single heading, with no way to tell which you were
+         * looking at. `recipient` and `memo` were added beside it to separate them.
+         *
+         * AS OF 2026-11-11 THE MEMO IS REDACTED on this public surface (see
+         * map.ts), so `venue` is simply the recipient and `memo` is always null.
+         * The dashboard is keyless and multi-tenant — anyone can type a vault name
+         * — and a memo is what a company paid FOR.
+         *
+         * It is NOT secret: the memo is on chain and one view call away. This
+         * removes it from the surface that turned "know how to query a NEAR RPC"
+         * into "type a name". The agent's own `vault_history` reads the chain
+         * directly and still sees everything.
+         */
         recentActivity: recent.map((p) => ({
             id: p.id,
             agent: p.agentName,
+            /**
+             * THE AGENT'S IDENTITY, not just its label.
+             *
+             * The Overview's activity rows seeded their avatar from `agent` (the
+             * NAME) while the budget tree two panels above seeded from `agentId`.
+             * Those hash differently, so one agent wore two colours on one page:
+             * "marketing" was yellow-green in the tree and pink in the table.
+             */
+            agentId: p.agentId,
             venue: p.venue,
+            recipient: p.recipientAddress,
+            // Empty string and "no memo" are the same thing to a reader, so both
+            // become null rather than making the UI test for two falsy shapes.
+            memo: p.prompt || null,
             amount: p.amount,
             rail: p.rail,
             time: p.createdAt,
             status: p.status,
+            /**
+             * THE REASON A PAYMENT WAS REFUSED, which this mapping used to drop.
+             *
+             * The blocked-row builder above already computes both of these from the
+             * contract's `request_blocked` event, and the Activity page renders
+             * them — but `recentActivity` listed eleven fields and neither was
+             * among them. So the Overview showed "BLOCKED" twice and said nothing
+             * about WHY, while the answer sat one object away.
+             *
+             * That is not cosmetic. The sharpest thing this product does is tell a
+             * sibling apart from its parent: `PARENT_DAILY_BUDGET` means someone
+             * else spent your pool, `DAILY_BUDGET` means you did. Dropping the code
+             * makes those two identical on the page a user actually lands on.
+             */
+            blockReason: p.blockReason ?? null,
+            blockMessage: p.blockMessage ?? null,
         })),
         paused: cfgView.paused,
     };