brainchain-worker 0.18.2 → 0.18.4

package/dist/watch.js

@@ -2,9 +2,11 @@ import { concat, createPublicClient, createWalletClient, keccak256, parseAbi, to
 import { brainchainTransport, executorAbi, reason } from "./chain.js";
 import { chainOf } from "./network.js";
 /**
- * The constitution's floors, by the function a change calls. A change that
- * crosses one is what the guardian's veto is for. Values in the units the
- * contracts take: basis points, seconds, and USDG in 6 decimals.
+ * The calls the constitution's monitor knows, by the function a change calls.
+ * A change that crosses a floor is what the guardian's veto is for, and any
+ * other call counts as crossing one. Three known calls have no floor, and say
+ * what they do instead. Values in the units the contracts take: basis points,
+ * seconds, and USDG in 6 decimals.
  */
 export const FLOORS = {
     "0x85327a44": {
@@ -32,9 +34,9 @@ export const FLOORS = {
         name: "setModel",
         check: (w) => [w[1] === 0n && "a house model with no account", w[2] > 5000000n && "a house model priced above 5 USDG"].filter((r) => typeof r === "string"),
     },
-    "0x16c38b3c": { name: "setPaused", check: () => [] },
-    "0x1f1e4d9f": { name: "setWorkerAllowed", check: () => [] },
-    "0xa9059cbb": { name: "transfer", check: () => [] },
+    "0x16c38b3c": { name: "setPaused", check: () => [], does: "pauses or resumes new posts" },
+    "0x1f1e4d9f": { name: "setWorkerAllowed", check: () => [], does: "allows or removes a worker" },
+    "0xa9059cbb": { name: "transfer", check: () => [], does: "moves house treasury funds" },
 };
 /** The static words after the selector; a call with dynamic arguments is read as far as its words go. */
 export function argumentsOf(data) {
@@ -44,13 +46,13 @@ export function argumentsOf(data) {
         words.push(BigInt(`0x${body.slice(i, i + 64)}`));
     return words;
 }
-/** What a queued change does to the constitution: nothing, or the floors it crosses. */
+/** What a queued change does to the constitution: nothing, the floors it crosses, or, for a known call with no floor, what it does. */
 export function judge(data) {
     const selector = data.slice(0, 10).toLowerCase();
     const floor = FLOORS[selector];
     if (!floor)
-        return { name: selector, broken: ["a call the constitution does not list"] };
-    return { name: floor.name, broken: floor.check(argumentsOf(data)) };
+        return { name: selector, broken: ["a call the monitor does not know, which counts as breaking a floor"] };
+    return { name: floor.name, broken: floor.check(argumentsOf(data)), ...(floor.does ? { does: floor.does } : {}) };
 }
 const gateAbi = parseAbi(["function veto(uint256 changeId, string reason)", "function watcher() view returns (address)"]);
 const logAbi = parseAbi(["function count() view returns (uint256)"]);
@@ -108,10 +110,53 @@ export async function requireWatcher(chain, log) {
         throw new Error(`This key cannot veto: the gate's watcher is ${watcher}, not ${chain.account}. Set BRAINCHAIN_WORKER_KEY to the watcher's key, or run watch without --veto.`);
     }
 }
+/** How long after a decision was recorded a record that cannot be read may hold a round's place. */
+export const UNREADABLE_MS = 86_400_000;
+/**
+ * A record that cannot be read stops the round and holds its place, so a host's
+ * outage costs no check. Only for a day from the decision's block time: one dead
+ * address would otherwise blind a watcher to every decision after it, so past
+ * that it is a finding, reported once, and the round moves on.
+ */
+function unreadable(why, recordedAt, now) {
+    if (recordedAt === undefined || !(now - Date.parse(recordedAt) >= UNREADABLE_MS))
+        throw new Error(why);
+    return { findings: [`the record could not be read a day or more after it was recorded: ${why}`] };
+}
+/**
+ * What one decision's checks come to. A check that failed is a finding, whatever
+ * else could not be read. A check that could not run says nothing about the
+ * decision, so it follows the rule for an unreadable record. A record served
+ * without its work leaves its hash checks unrun, which is neither a finding nor a
+ * verified decision: `withheld` names them. With `refetch`, a verified decision
+ * comes with the record's bytes as served, for the report, and a failure to fetch
+ * them follows the same rule.
+ */
+export async function outcome(report, options = {}) {
+    const now = options.now ?? Date.now();
+    const said = (status) => report.checks.filter((c) => c.status === status).map((c) => `${c.name}: ${c.message}`);
+    const findings = said("fail");
+    if (findings.length > 0)
+        return { findings };
+    const unread = said("error");
+    if (unread.length > 0)
+        return unreadable(unread.join("; "), report.recordedAt, now);
+    if (report.withheld)
+        return { findings, withheld: report.checks.filter((c) => c.status === "skip" && c.name.endsWith("-hash")).map((c) => c.name) };
+    if (!options.refetch || !report.payloadURI)
+        return { findings };
+    try {
+        return { findings, record: await options.refetch(report.payloadURI) };
+    }
+    catch (error) {
+        return unreadable(reason(error), report.recordedAt, now);
+    }
+}
 /** The service's prefix on a report; the worker signs the prefix and the report's JSON text. */
 export const REPORT_PREFIX = "BrainChain watchtower report\n";
-/** A report lists at most this many decisions checked. */
+/** A report lists at most this many decisions checked and this many findings; a longer round sends several. */
 export const MAX_CHECKED = 200;
+export const MAX_FINDINGS = 50;
 /** The proof a record was fetched: the hash of its bytes followed by the worker's address, which nothing on chain gives away. */
 export const fetchProof = (bytes, worker) => keccak256(concat([bytes, toBytes(worker)]));
 /** The service answered and will not take this report, so sending it again would not help. */
@@ -123,14 +168,17 @@ export class ReportRefused extends Error {
  * Resolves to the line to log.
  */
 export function createReporter(network, account, fetcher = fetch) {
-    return async (checked, findings) => {
+    // The service takes a report only if it was signed later than the last it took, by the second.
+    let lastAt = 0;
+    async function send(checked, findings) {
+        lastAt = Math.max(Math.floor(Date.now() / 1000), lastAt + 1);
         const report = {
             worker: account.address,
             chainId: network.chainId,
             log: network.contracts.log,
-            at: Math.floor(Date.now() / 1000),
-            checked: checked.slice(0, MAX_CHECKED).map((c) => ({ id: Number(c.id), proof: c.proof })),
-            findings: findings.slice(0, 50).map((f) => ({ id: Number(f.id), checks: f.checks.slice(0, 20).map((c) => c.slice(0, 400)) })),
+            at: lastAt,
+            checked: checked.map((c) => ({ id: Number(c.id), proof: c.proof })),
+            findings: findings.map((f) => ({ id: Number(f.id), checks: f.checks.slice(0, 20).map((c) => c.slice(0, 400)) })),
         };
         const text = JSON.stringify(report);
         const signature = await account.signMessage({ message: `${REPORT_PREFIX}${text}` });
@@ -148,6 +196,13 @@ export function createReporter(network, account, fetcher = fetch) {
         return body.mark
             ? `reported to ${network.name}: ${body.checked} decisions re-verified in all, watchtower mark since ${body.mark.since}`
             : `reported to ${network.name}: ${body.checked} of the ${body.markAfter} re-verified decisions that earn the watchtower mark`;
+    }
+    return async (checked, findings) => {
+        let line = await send(checked.slice(0, MAX_CHECKED), findings.slice(0, MAX_FINDINGS));
+        for (let i = 1; MAX_CHECKED * i < checked.length || MAX_FINDINGS * i < findings.length; i++) {
+            line = await send(checked.slice(MAX_CHECKED * i, MAX_CHECKED * (i + 1)), findings.slice(MAX_FINDINGS * i, MAX_FINDINGS * (i + 1)));
+        }
+        return line;
     };
 }
 /**
@@ -176,7 +231,7 @@ export function createWatch(options) {
                 const key = change.changeId.toString();
                 if (judged.has(key))
                     continue;
-                const { name, broken } = judge(change.data);
+                const { name, broken, does } = judge(change.data);
                 // A failed read leaves the change unjudged and the block range unread, so the next round comes back to it.
                 const open = await chain.open(change.changeId);
                 judged.add(key);
@@ -185,9 +240,9 @@ export function createWatch(options) {
                     log(`change ${change.changeId}: ${name} on ${change.target}${broken.length > 0 ? ` broke the constitution (${why})` : ""}; closed, it has run or was vetoed`);
                     continue;
                 }
-                const runsAt = new Date(Number(change.eta) * 1000).toISOString().replace("T", " ").slice(0, 16);
+                const runsAt = new Date(Number(change.eta) * 1000).toISOString().replace("T", " ").slice(0, 19);
                 if (broken.length === 0) {
-                    log(`change ${change.changeId}: ${name} on ${change.target}, within the constitution, runs after ${runsAt} UTC`);
+                    log(`change ${change.changeId}: ${name} on ${change.target}${does ? ` ${does}, which no floor covers` : ", within the constitution"}, runs after ${runsAt} UTC`);
                     continue;
                 }
                 findings += 1;
@@ -239,8 +294,11 @@ export function createWatch(options) {
         let reached = seenDecision;
         for (let id = seenDecision + 1n; id <= count; id++) {
             try {
-                const { findings: wrong, record } = await verify(id);
-                if (wrong.length === 0) {
+                const { findings: wrong, record, withheld } = await verify(id);
+                if (withheld) {
+                    log(`decision ${id} withheld: its record is served without the work, so ${withheld.join(" and ")} did not run; the checks that ran agree with the chain`);
+                }
+                else if (wrong.length === 0) {
                     log(`decision ${id} verified`);
                     if (record)
                         checked.push({ id, proof: fetchProof(record, chain.account) });
@@ -266,11 +324,10 @@ export function createWatch(options) {
             }
             catch (error) {
                 log(`report not taken: ${reason(error)}`);
-                // Only an answer from the service settles a report; these decisions are checked and sent again otherwise.
-                if (!(error instanceof ReportRefused)) {
-                    incomplete = true;
+                incomplete = true;
+                // Only an answer from the service settles a report: a refusal would only repeat, and these decisions are checked and sent again otherwise.
+                if (!(error instanceof ReportRefused))
                     reached = seenDecision;
-                }
             }
         }
         seenDecision = reached;

package/dist/work.js

@@ -36,6 +36,16 @@ export const printable = (text) => stripAnsi(text)
     .replace(/[\t\n\r]+/g, " ")
     .replace(/[\x00-\x1f\x7f-\x9f]/g, "")
     .replace(new RegExp(HIDDEN.source, "g"), "");
+/** The longest title the log quotes. */
+const LOGGED_TITLE = 80;
+/**
+ * A title from a stranger as the log shows it: one line, cut short and JSON-quoted,
+ * so it cannot close its quotes and pass for the worker's own words.
+ */
+export function loggedTitle(title) {
+    const characters = [...printable(title)];
+    return JSON.stringify(characters.length > LOGGED_TITLE ? `${characters.slice(0, LOGGED_TITLE - 1).join("")}…` : characters.join(""));
+}
 export function parseBrief(text) {
     let value;
     try {
@@ -437,7 +447,7 @@ export function createWork(options) {
                         // A stop asked for while the brief downloaded or the balance was read starts no command.
                         if (options.stopping?.())
                             continue;
-                        log(`task ${task.id}: working on "${brief.title}"`);
+                        log(`task ${task.id}: working on ${loggedTitle(brief.title)}`);
                         const input = options.format === "json" ? JSON.stringify(taskInput(task, brief)) : taskPrompt(task, brief);
                         const timeoutMs = Math.min(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, Number(task.deadline - MARGIN_SEC - now) * 1000);
                         const output = stripAnsi(await command.run(input, { BRAINCHAIN_TASK_ID: key }, timeoutMs, remember).finally(forget)).trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "Earn on BrainChain and propose changes to it: stake, apply, do the tasks Jev hires your agent for, and bond BRAIN to put a change to Jev.",
   "license": "MIT",
   "author": "BrainChain <hello@usebrainchain.com>",