brainchain-worker 0.3.0 → 0.4.0

package/README.md

@@ -46,9 +46,22 @@ npx brainchain-worker run --exec 'claude -p --tools ""'
 - **Review.** If Jev allows the worker, it can be hired once a 48-hour timelock passes.
 - **Pay.** Accepted work is paid in USDG, less the 3% protocol fee, once the 6-hour dispute window closes. The USDG stays on BrainChain until it is [bridged back](https://docs.usebrainchain.com/bridging) to Robinhood Chain.
 
-## Proof income
+## Proofs
 
-BrainChain Proofs are NFTs on Robinhood Chain, and each one earns an equal share of the income the $BRAIN launch on ripples.run pays to Proof holders, in ETH. `claim` pays out what the worker's Proofs have earned:
+Every task BrainChain pays for becomes a Proof: an NFT in the BrainChain Proofs collection on Robinhood Chain that shows the task's title, Jev's hire and grade, and the hashes that check them against the chain.
+
+**The worker mints its own.** Once a task it delivered is paid, `run` mints that task's Proof from the worker's key, so the worker holds the piece and the income it earns. Each Proof costs 0.001 WETH on Robinhood Chain, plus gas, so the wallet needs WETH and a little ETH there. A Proof the worker has not minted a day after payment goes to a public pool instead. `run --no-mint` mints nothing.
+
+`mint` catches up on paid tasks still waiting for their Proof, such as tasks paid while `run` was stopped:
+
+```sh
+npx brainchain-worker mint --dry   # the tasks waiting, what they cost and what the wallet lacks; nothing sent
+npx brainchain-worker mint         # mints up to 10, one for each task
+```
+
+If the wallet is short, `mint` and `run` say exactly what is missing. On testnet, Proofs live on Robinhood Chain testnet and cost test WETH, which the worker claims from its faucet when it runs short: one claim of 1 WETH a day per wallet.
+
+**Income.** Each mainnet Proof earns an equal share of the income the $BRAIN launch on ripples.run pays to Proof holders, in ETH. `claim` pays out what the worker's Proofs have earned:
 
 ```sh
 BRAINCHAIN_NETWORK=mainnet npx brainchain-worker claim --dry   # each Proof and what it is due, nothing sent
@@ -81,8 +94,8 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 ## Keep it running
 
 - **Stopping.** A `run` with no task in hand stops at once on Ctrl-C or SIGTERM. During a task, the first one stops `run` from taking new tasks and lets the current command finish and deliver; a second one stops the command at once. SIGHUP, which a closed terminal or a dropped SSH session sends, stops the command and `run` at once.
-- **Restarts.** `run` saves unfinished work to `~/.config/brainchain-worker/<address>.json`, readable only by you: a result waiting to be uploaded or submitted, a submit already sent, when each failed task is due again, and how far it has read the chain. A restart, or the next `--once` run, picks up from there without running the command again for a result it already has, and waits for a sent submit before sending another. A command left running by a `run` that was killed is stopped when the next one starts. If the file is damaged, `run` moves it aside and starts without saved work.
-- **One run per worker.** A second `run` for the same address refuses to start while the first is alive.
+- **Restarts.** `run` saves unfinished work to `~/.config/brainchain-worker/<address>.<network>.json`, readable only by you: a result waiting to be uploaded or submitted, a submit already sent, when each failed task is due again, and how far it has read the chain, and the delivered tasks waiting for their Proof. A restart, or the next `--once` run, picks up from there without running the command again for a result it already has, and waits for a sent submit before sending another. A command left running by a `run` that was killed is stopped when the next one starts. If the file is damaged, `run` moves it aside and starts without saved work.
+- **One run per worker and network.** State is kept per network, where `<network>` is `testnet` or `mainnet`, so one key can run on both at the same time, and a second `run` for the same address on the same network refuses to start while the first is alive.
 - **Under a supervisor.** systemd sends SIGTERM to every process of a service by default, the command included, and every supervisor kills what is left after a timeout: 90 seconds for systemd, 10 for Docker and 30 for Kubernetes. For a stop that lets the current task deliver, signal the worker alone and allow the task timeout plus two minutes, 22 minutes with the default `--timeout`:
 
   | Supervisor | Settings |
@@ -97,9 +110,10 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 | --- | --- |
 | `new-key` | Print a fresh private key and its address. |
 | `join --name <name> --about <text> [--price <tUSDG>]` | Claim tBRAIN from the faucet if needed, stake the minimum and apply. Jev reads the name and description to decide, and refuses an empty one. The name is at most 60 characters and the description at most 500. A new worker's price defaults to 0.20; a worker that has staked keeps its price unless `--price` changes it. An allowed worker whose stake fell below the minimum, after `leave` or a slash, stakes back up to it. Stake that is unstaking does not count, so the tBRAIN comes from the wallet or the faucet until `withdraw` returns it. |
-| `run --exec "<command>" [--format prompt\|json] [--timeout <minutes>] [--once]` | Do every task the worker is hired for, earliest deadline first. `--timeout` sets how many minutes the command may spend on one task: 20 by default, at most 1440, fractions allowed. `--once` does one pass and exits, with code 1 if a task failed or was left too close to its deadline, for a cron job. |
+| `run --exec "<command>" [--format prompt\|json] [--timeout <minutes>] [--once] [--no-mint]` | Do every task the worker is hired for, earliest deadline first, and mint the Proof of each one that is paid. `--timeout` sets how many minutes the command may spend on one task: 20 by default, at most 1440, fractions allowed. `--once` does one pass and exits, with code 1 if a task failed or was left too close to its deadline, for a cron job. `--no-mint` mints no Proofs. |
 | `status` | Whether the worker can be hired, its stake, its tBRAIN balance, price, record and earnings. Below the minimum stake, it also says where `join` will find the tBRAIN it needs. |
 | `price <tUSDG>` | Change the asking price. |
+| `mint [--count <n>] [--dry]` | Mint the Proof of each paid task waiting for one, up to 10 at a time or `--count`, at 0.001 WETH each on Robinhood Chain plus gas. `--dry` lists the tasks and what the wallet lacks without sending anything. |
 | `claim [--dry]` | Claim the ETH due on the worker's Proofs on Robinhood Chain, in one transaction. `--dry` lists each Proof and what it is due without sending anything. |
 | `leave` | Start unstaking. The stake unlocks after 3 days, once no task of the worker's is in flight. |
 | `withdraw` | Withdraw the unlocked stake. |

package/dist/chain.js

@@ -355,6 +355,11 @@ export function createChain(network, account, store = memoryStore()) {
             })));
             return { applications, change };
         },
+        /** How a task settled, or undefined while it has not. */
+        async settled(task) {
+            const { status } = await client.readContract({ ...board, functionName: "get", args: [task] });
+            return status === Status.Paid ? "paid" : status === Status.Refunded ? "refunded" : undefined;
+        },
         /** Tasks this worker was hired for, by outcome, and what it was paid after fees. */
         async record() {
             const latest = await client.getBlockNumber();

package/dist/claim.js

@@ -1,5 +1,6 @@
-import { createPublicClient, createWalletClient, defineChain, formatEther, http, parseAbi, parseEventLogs } from "viem";
+import { createPublicClient, createWalletClient, formatEther, http, parseAbi, parseEventLogs } from "viem";
 import { RECEIPT_MS } from "./chain.js";
+import { proofsChainOf } from "./network.js";
 export const proofsIncomeAbi = parseAbi([
     "function due(uint256 tokenId) view returns (uint256)",
     "function claimMany(uint256[] tokenIds)",
@@ -9,15 +10,8 @@ export const proofsIncomeAbi = parseAbi([
 ]);
 /** The most Proofs one claim pays for, which keeps the transaction far inside a block. */
 export const MAX_CLAIM = 200;
-const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
 export function createIncome(proofs, income, account) {
-    const chain = defineChain({
-        id: proofs.chainId,
-        name: proofs.name,
-        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-        rpcUrls: { default: { http: [proofs.rpc] } },
-        contracts: { multicall3: { address: MULTICALL3 } },
-    });
+    const chain = proofsChainOf(proofs);
     const transport = http(proofs.rpc, { timeout: 20_000, retryCount: 3 });
     const client = createPublicClient({ chain, transport, pollingInterval: 1_000 });
     const wallet = createWalletClient({ account, chain, transport });

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import { join as joinPath } from "node:path";
 import { formatEther, parseUnits } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { createChain, faucetReopens, reason, unhealthy } from "./chain.js";
 import { claim, createIncome } from "./claim.js";
+import { createProofMinter, createProofsChain, MAX_MINT, mint } from "./mint.js";
 import { resolveNetwork } from "./network.js";
 import { hireable, shortOfStake, snapshot, stake, usdg, wallet, when } from "./standing.js";
-import { fileStore, lock, stateDir } from "./state.js";
+import { openStore } from "./state.js";
 import { createWork, shellCommand, stopLeftover, stopper } from "./work.js";
 const { version } = createRequire(import.meta.url)("../package.json");
 const USAGE = `brainchain-worker ${version}
@@ -19,12 +19,16 @@ Usage:
   brainchain-worker join --name <name> --about <text> [--price <USDG>]
                                             Stake the minimum and apply to take tasks. The name is at
                                             most 60 characters, the description at most 500.
-  brainchain-worker run --exec "<command>" [--format prompt|json] [--timeout <minutes>] [--once]
+  brainchain-worker run --exec "<command>" [--format prompt|json] [--timeout <minutes>] [--once] [--no-mint]
                                             Do every task Jev hires you for: the command reads the
                                             task on stdin and prints the deliverable on stdout, within
-                                            --timeout minutes (20 by default, at most 1440).
+                                            --timeout minutes (20 by default, at most 1440). The worker
+                                            mints the Proof of each task it is paid for, unless --no-mint.
   brainchain-worker status                  Stake, wallet, application, record and earnings.
   brainchain-worker price <USDG>            Change your asking price per task.
+  brainchain-worker mint [--count <n>] [--dry]
+                                            Mint a Proof for each paid task waiting for one, up to 10 or
+                                            --count, at 0.001 WETH each on Robinhood Chain. --dry sends nothing.
   brainchain-worker claim [--dry]           Claim the ETH due on the worker's Proofs, on Robinhood Chain.
                                             --dry lists what is due and sends nothing.
   brainchain-worker leave                   Start unstaking (3-day cooldown).
@@ -39,8 +43,8 @@ Environment:
                           localhost or 127.0.0.1.
 
 The command sees the worker's environment without any BRAINCHAIN_ variable, plus BRAINCHAIN_TASK_ID.
-Unfinished work is kept in ~/.config/brainchain-worker/<address>.json across restarts, and one
-run at a time works for each address.
+Unfinished work is kept in ~/.config/brainchain-worker/<address>.<network>.json across restarts,
+and one run at a time works for each address on each network.
 
 Docs: https://docs.usebrainchain.com/run-a-worker`;
 /** A mistake in the command line. Every other error is printed after the program's name. */
@@ -49,12 +53,13 @@ class UsageError extends Error {
 /** The flags each command takes; `true` marks a switch, which takes no value. */
 const FLAGS = {
     join: { name: false, about: false, price: false },
-    run: { exec: false, format: false, timeout: false, once: true },
+    run: { exec: false, format: false, timeout: false, once: true, "no-mint": true },
     status: {},
     price: {},
     leave: {},
     withdraw: {},
     claim: { dry: true },
+    mint: { count: false, dry: true },
 };
 const POSITIONAL = { price: 1 };
 function parse(command, args) {
@@ -208,7 +213,7 @@ async function status(chain, network) {
   Earned    ${usdg(network, record.earned)} after fees; wallet holds ${usdg(network, bountyBalance)}
   Gas       ${formatEther(gas)} ETH`);
 }
-async function run(network, { key, account }, values, once) {
+async function run(network, { key, account }, values, once, mints) {
     const exec = values.get("exec");
     if (!exec)
         throw new UsageError(`--exec is required: the command that does the work, such as --exec 'claude -p --tools ""'`);
@@ -220,12 +225,11 @@ async function run(network, { key, account }, values, once) {
         throw new UsageError("--timeout is the most minutes the command may spend on one task: more than 0, at most 1440, and 20 by default");
     }
     const log = (message) => console.log(`${new Date().toISOString().slice(0, 19)}Z ${message}`);
-    const file = joinPath(stateDir(), account.address);
-    lock(`${file}.lock`);
-    const store = fileStore(`${file}.json`, network.contracts.taskBoard, (message) => log(`warning: ${message}`));
+    const store = openStore(account.address, network, (message) => log(`warning: ${message}`));
     // The lock rules out a live run, so a command still in the state was left by one that died.
     await stopLeftover(store, log);
     const chain = createChain(network, account, store);
+    const proofs = createProofMinter({ network, chain: createProofsChain(network.proofs, account), settled: chain.settled, store, log, enabled: mints });
     const command = shellCommand(exec);
     // An idle stop keeps the exit code of a task that failed earlier in a --once pass.
     const stop = stopper({ busy: () => work.busy(), kill: command.kill, log, exit: (code) => process.exit(code || process.exitCode) });
@@ -240,6 +244,7 @@ async function run(network, { key, account }, values, once) {
         stopping: stop.stopping,
         // A cron job sees a failed task as a failed run.
         failed: once ? () => void (process.exitCode = 1) : undefined,
+        delivered: proofs.track,
     });
     for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
         process.on(signal, stop.signal);
@@ -273,14 +278,22 @@ async function run(network, { key, account }, values, once) {
         });
         if (result?.hired === 0 && result.delivered === 0)
             log("no task is hired to this worker right now");
+        await proofs.round().catch((error) => log(`proofs round failed: ${reason(error)}`));
         return;
     }
     log("waiting for tasks (Ctrl-C to stop)");
+    // Minting waits on receipts from another chain, so it runs beside the work, one round at a time.
+    let minting;
     while (!stop.stopping()) {
         await work.round().catch((error) => log(`round failed: ${reason(error)}`));
+        minting ??= proofs
+            .round()
+            .catch((error) => log(`proofs round failed: ${reason(error)}`))
+            .finally(() => (minting = undefined));
         for (let i = 0; i < 15 && !stop.stopping(); i++)
             await new Promise((resolve) => setTimeout(resolve, 1_000));
     }
+    await minting;
     log("stopped");
 }
 async function main(argv) {
@@ -303,9 +316,16 @@ async function main(argv) {
     if (command === "claim") {
         return claim(network, (income) => createIncome(network.proofs, income, signer().account), { dry: switches.has("dry"), log: console.log });
     }
+    if (command === "mint") {
+        const count = values.get("count");
+        if (count !== undefined && !(/^\d{1,2}$/.test(count) && Number(count) >= 1 && Number(count) <= MAX_MINT)) {
+            throw new UsageError(`--count is how many Proofs to mint: 1 to ${MAX_MINT}`);
+        }
+        return mint(network, createProofsChain(network.proofs, signer().account), { count: count === undefined ? undefined : Number(count), dry: switches.has("dry"), log: console.log });
+    }
     const worker = signer();
     if (command === "run")
-        return run(network, worker, values, switches.has("once"));
+        return run(network, worker, values, switches.has("once"), !switches.has("no-mint"));
     const chain = createChain(network, worker.account);
     switch (command) {
         case "join":

package/dist/mint.js

@@ -0,0 +1,278 @@
+import { createPublicClient, createWalletClient, formatEther, http, parseAbi, parseEventLogs, zeroAddress, } from "viem";
+import { reason, RECEIPT_MS } from "./chain.js";
+import { proofsChainOf } from "./network.js";
+import { when } from "./standing.js";
+export const collectionAbi = parseAbi([
+    "function PRICE_QUOTE() view returns (uint256)",
+    "function mint(uint256 quantity, uint256 minRoutedTotal) payable",
+    "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)",
+    "error SupplyExceeded()",
+    "error WalletCapExceeded()",
+    "error Ended()",
+    "error NotStarted()",
+]);
+export const wethAbi = parseAbi([
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function faucet() returns (uint256)",
+    "function nextFaucetAt(address) view returns (uint256)",
+    "error FaucetCoolingDown(uint256 nextAt)",
+]);
+/** The most pieces one mint run pays for. */
+export const MAX_MINT = 10;
+/** How often a delivered task's status is read until it settles. */
+const STATUS_SEC = 300;
+/** Grading, a dispute and its ruling take up to 6 hours each on mainnet, so a task unsettled after a day is left. */
+const WATCH_SEC = 86_400;
+/** A day after payment the task joins the public pool, so the worker's own attempts stop an hour short of it. */
+const OWN_SEC = 23 * 3_600;
+/** The least time between two mint attempts for one task. */
+const RETRY_SEC = 3_600;
+/** The service lists a payment a round or two after it lands; a task still unlisted this long after has its piece. */
+const LISTING_SEC = 900;
+/** The piece a mint's receipt shows the collection minting to `to`. */
+export function mintedToken(logs, collection, to) {
+    // WETH's Transfer shares the event's signature but not its indexed token id, so only the collection's own logs decode.
+    return parseEventLogs({ abi: collectionAbi, eventName: "Transfer", args: { from: zeroAddress, to }, logs }).find((log) => log.address.toLowerCase() === collection.toLowerCase())?.args.tokenId;
+}
+export function createProofsChain(proofs, account) {
+    const chain = proofsChainOf(proofs);
+    const transport = http(proofs.rpc, { timeout: 20_000, retryCount: 3 });
+    const client = createPublicClient({ chain, transport, pollingInterval: 1_000 });
+    const wallet = createWalletClient({ account, chain, transport });
+    const weth = { address: proofs.weth, abi: wethAbi };
+    const collection = { address: proofs.collection, abi: collectionAbi };
+    async function send(request) {
+        const hash = await wallet.writeContract(request);
+        const receipt = await client.waitForTransactionReceipt({ hash, timeout: RECEIPT_MS });
+        if (receipt.status !== "success")
+            throw new Error(`Transaction ${hash} reverted`);
+        return { hash, receipt };
+    }
+    return {
+        account: account.address,
+        price: () => client.readContract({ ...collection, functionName: "PRICE_QUOTE" }),
+        weth: () => client.readContract({ ...weth, functionName: "balanceOf", args: [account.address] }),
+        ethBalance: () => client.getBalance({ address: account.address }),
+        faucetOpensAt: () => client.readContract({ ...weth, functionName: "nextFaucetAt", args: [account.address] }),
+        async claimWeth() {
+            await send({ ...weth, functionName: "faucet" });
+        },
+        async approve(amount) {
+            const current = await client.readContract({ ...weth, functionName: "allowance", args: [account.address, proofs.collection] });
+            if (current >= amount)
+                return;
+            await send({ ...weth, functionName: "approve", args: [proofs.collection, amount] });
+        },
+        async mint() {
+            const { hash, receipt } = await send({ ...collection, functionName: "mint", args: [1n, 0n] });
+            const tokenId = mintedToken(receipt.logs, proofs.collection, account.address);
+            if (tokenId === undefined)
+                throw new Error(`The mint ${hash} minted no piece to ${account.address}`);
+            return { tokenId, tx: hash };
+        },
+    };
+}
+/**
+ * The worker's paid tasks the service has bound no piece to, in the order it
+ * binds the worker's own mints to them: oldest payment first.
+ */
+export async function pendingTasks(network, worker, fetcher = fetch) {
+    const host = new URL(network.service).host;
+    const response = await fetcher(`${network.service}/proofs/${network.chainId}/pending/${worker}`, { signal: AbortSignal.timeout(15_000) }).catch(() => {
+        throw new Error(`Could not reach the BrainChain service at ${host}`);
+    });
+    if (!response.ok) {
+        await response.body?.cancel();
+        if (response.status === 404)
+            throw new Error(`The BrainChain service at ${host} does not list the tasks waiting for a Proof yet`);
+        throw new Error(`The BrainChain service at ${host} answered ${response.status} when asked for the tasks waiting for a Proof`);
+    }
+    const tasks = (await response.json().catch(() => undefined))?.tasks;
+    if (!Array.isArray(tasks) || !tasks.every((id) => typeof id === "string" && /^\d{1,78}$/.test(id))) {
+        throw new Error(`The BrainChain service at ${host} listed the tasks waiting for a Proof in a form the worker cannot read`);
+    }
+    return [...new Set(tasks)].map((id) => BigInt(id));
+}
+const proofCount = (n) => `${n} Proof${n === 1 ? "" : "s"}`;
+/** "task 12", "tasks 12 and 15", "tasks 12, 15 and 18". */
+function taskList(tasks) {
+    const ids = tasks.map(String);
+    if (ids.length === 1)
+        return `task ${ids[0]}`;
+    return `tasks ${ids.slice(0, -1).join(", ")} and ${ids.at(-1)}`;
+}
+const wall = () => Math.floor(Date.now() / 1000);
+/**
+ * What the wallet lacks to pay for `count` pieces, if anything. Short of test
+ * WETH while the faucet is open, it claims from the faucet first, calling
+ * `claiming` as it starts, unless `dry`, which only sets `claim`.
+ */
+async function afford(proofs, chain, count, options) {
+    const [price, eth] = await Promise.all([chain.price(), chain.ethBalance()]);
+    const cost = price * BigInt(count);
+    let weth = await chain.weth();
+    let opensAt = 0n;
+    if (weth < cost && proofs.faucet) {
+        opensAt = await chain.faucetOpensAt();
+        // The claim pays gas too.
+        if (opensAt <= BigInt(options.now()) && eth > 0n) {
+            if (options.dry)
+                return { price, claim: true };
+            options.claiming();
+            await chain.claimWeth();
+            [weth, opensAt] = await Promise.all([chain.weth(), chain.faucetOpensAt()]);
+        }
+    }
+    const needWeth = weth < cost;
+    const needEth = eth === 0n;
+    if (!needWeth && !needEth)
+        return { price };
+    const fixes = [];
+    if (needWeth && !proofs.faucet)
+        fixes.push(`Send it ${formatEther(cost - weth)} WETH (${proofs.weth}) on ${proofs.name}.`);
+    if (needEth)
+        fixes.push(`${proofs.gas}.`);
+    if (needWeth && proofs.faucet) {
+        fixes.push(opensAt <= BigInt(options.now())
+            ? "The worker claims test WETH from the faucet once it has ETH."
+            : `The test WETH faucet allows one claim a day, and this wallet can claim again at ${when(opensAt)}.`);
+    }
+    const holds = `${chain.account} holds ${formatEther(weth)} WETH${needEth ? " and no ETH" : ""} on ${proofs.name}`;
+    return { price, missing: `${holds}, and ${proofCount(count)} cost${count === 1 ? "s" : ""} ${formatEther(cost)} WETH plus gas. ${fixes.join(" ")}` };
+}
+/**
+ * Mints a piece for each of the worker's paid tasks the service lists without
+ * one, up to `count` and at most MAX_MINT, from the worker's key. The service
+ * binds each piece the worker mints to its oldest paid task waiting for one.
+ */
+export async function mint(network, chain, options) {
+    const { log } = options;
+    const { proofs } = network;
+    const listed = await pendingTasks(network, chain.account, options.fetcher);
+    if (listed.length === 0)
+        return log(`The BrainChain service lists no paid task of ${chain.account} waiting for a Proof, so there is nothing to mint.`);
+    const batch = listed.slice(0, Math.min(options.count ?? MAX_MINT, MAX_MINT));
+    const left = listed.length - batch.length;
+    const rest = left > 0 ? ` ${left} more paid task${left === 1 ? " waits" : "s wait"} for a Proof: run mint again.` : "";
+    const funds = await afford(proofs, chain, batch.length, { dry: options.dry, claiming: () => log("Claiming test WETH from the faucet..."), now: options.now ?? wall });
+    const each = `${formatEther(funds.price)} WETH each plus gas`;
+    if (options.dry) {
+        log(`Dry run, nothing sent: mint would mint ${proofCount(batch.length)} on ${proofs.name} for ${taskList(batch)}, at ${each}.${rest}`);
+        if (funds.claim)
+            log("The wallet is short of WETH, so mint would claim test WETH from the faucet first.");
+        if (funds.missing)
+            log(funds.missing);
+        return;
+    }
+    if (funds.missing)
+        throw new Error(`${funds.missing} Then run mint again.`);
+    log(`Minting ${proofCount(batch.length)} on ${proofs.name} at ${each}...`);
+    for (const task of batch) {
+        await chain.approve(funds.price);
+        const { tokenId, tx } = await chain.mint();
+        log(`Minted Proof ${tokenId} for task ${task} (${tx}).`);
+    }
+    if (rest)
+        log(rest.trim());
+}
+/**
+ * What `run` does for Proofs: it watches each task the worker delivers until
+ * it settles and mints a piece for each paid one, at most once an hour per
+ * task, and only while the service lists the task as waiting for a piece. The
+ * watched tasks live in the state, so a restart neither forgets nor repeats a
+ * mint. With `enabled` false, as under --no-mint, it does nothing.
+ */
+export function createProofMinter(options) {
+    const { network, chain, store, log } = options;
+    const clock = options.now ?? wall;
+    const watched = () => (store.state.proofs ??= {});
+    const drop = (key, why) => {
+        delete watched()[key];
+        store.save();
+        if (why)
+            log(`task ${key}: ${why}`);
+    };
+    const later = (entry, seconds) => {
+        entry.nextAt = clock() + seconds;
+        store.save();
+    };
+    /** Reads whether a delivered task settled; true once it is paid. */
+    async function settle(key, entry) {
+        let outcome;
+        try {
+            outcome = await options.settled(BigInt(key));
+        }
+        catch (error) {
+            later(entry, STATUS_SEC);
+            log(`task ${key}: could not read whether it was paid (${reason(error)})`);
+            return false;
+        }
+        if (outcome === "refunded") {
+            drop(key, "refunded to its poster, so it gets no proof");
+            return false;
+        }
+        if (outcome === undefined) {
+            if (clock() - entry.deliveredAt >= WATCH_SEC)
+                drop(key, "not settled a day after delivery, so the worker mints no proof for it");
+            else
+                later(entry, STATUS_SEC);
+            return false;
+        }
+        entry.paidAt = clock();
+        store.save();
+        return true;
+    }
+    async function mintFor(key, entry, listed) {
+        const paidAt = entry.paidAt;
+        if (clock() - paidAt >= OWN_SEC)
+            return drop(key, "no proof minted within a day of payment, so the task joins the public pool");
+        if (Array.isArray(listed) && !listed.includes(BigInt(key))) {
+            if (clock() - paidAt < LISTING_SEC)
+                return later(entry, 60);
+            return drop(key, "the BrainChain service lists no proof waiting for it, so the worker mints none");
+        }
+        // Counted before anything is sent, so a restart during the mint waits out the hour too.
+        later(entry, RETRY_SEC);
+        if (listed instanceof Error)
+            return log(`task ${key}: no proof minted yet (${reason(listed)}); trying again in an hour`);
+        try {
+            const funds = await afford(network.proofs, chain, 1, { dry: false, claiming: () => log("claiming test WETH from the faucet"), now: clock });
+            if (funds.missing)
+                return log(`task ${key}: no proof minted yet. ${funds.missing} Trying again in an hour.`);
+            await chain.approve(funds.price);
+            const { tokenId, tx } = await chain.mint();
+            drop(key);
+            log(`minted proof ${tokenId} for task ${key} (${tx})`);
+        }
+        catch (error) {
+            log(`task ${key}: minting its proof failed (${reason(error)}); trying again in an hour`);
+        }
+    }
+    return {
+        /** Watches a task the worker just delivered. */
+        track(task) {
+            if (!options.enabled)
+                return;
+            const now = clock();
+            watched()[task.toString()] = { deliveredAt: now, nextAt: now + STATUS_SEC };
+            store.save();
+        },
+        /** Reads every watched task that is due, and mints for each paid one. */
+        async round() {
+            if (!options.enabled || store.state.proofs === undefined)
+                return;
+            const due = Object.entries(watched()).filter(([, entry]) => clock() >= entry.nextAt);
+            const paid = [];
+            for (const [key, entry] of due)
+                if (entry.paidAt !== undefined || (await settle(key, entry)))
+                    paid.push([key, entry]);
+            if (paid.length === 0)
+                return;
+            const listed = await pendingTasks(network, chain.account, options.fetcher).catch((error) => (error instanceof Error ? error : new Error(String(error))));
+            for (const [key, entry] of paid)
+                await mintFor(key, entry, listed);
+        },
+    };
+}

package/dist/network.js

@@ -1,6 +1,7 @@
 import { defineChain, zeroAddress } from "viem";
 /** BrainChain testnet, release 3.1.0. */
 export const TESTNET = {
+    id: "testnet",
     name: "BrainChain testnet",
     chainId: 274630,
     rpc: "https://rpc.testnet.usebrainchain.com",
@@ -10,7 +11,15 @@ export const TESTNET = {
     stakeSymbol: "tBRAIN",
     bountySymbol: "tUSDG",
     gas: "Get Robinhood Chain testnet ETH from https://faucet.testnet.chain.robinhood.com and bridge some at https://usebrainchain.com/testnet",
-    proofs: { chainId: 46630, name: "Robinhood Chain testnet", rpc: "https://rpc.testnet.chain.robinhood.com" },
+    proofs: {
+        chainId: 46630,
+        name: "Robinhood Chain testnet",
+        rpc: "https://rpc.testnet.chain.robinhood.com",
+        collection: "0x324B52EE2182641ec29652076ab541bc9F9907d2",
+        weth: "0x1F852eF3Afa13156b807204d838BbB46B4b452eb",
+        faucet: true,
+        gas: "Get Robinhood Chain testnet ETH for gas at https://faucet.testnet.chain.robinhood.com",
+    },
     contracts: {
         taskBoard: "0xC74564F100e70F95346A6e399ebf1Ce14309C8B6",
         staking: "0xbdC08799D865DA79FE44a469de1FeaE84bb45059",
@@ -28,6 +37,7 @@ export const MAINNET_DECISION_EXECUTOR = "0xA03614B09Dcc3813eD665a1693123f2a4f2C
 const BRAIN = "0x3367085Eb6C79BfB0fCa4f1433ec77bFA8CB8a37";
 /** BrainChain mainnet, release 3.3.0. */
 export const MAINNET = {
+    id: "mainnet",
     name: "BrainChain",
     chainId: 274663,
     rpc: "https://rpc.usebrainchain.com",
@@ -40,7 +50,15 @@ export const MAINNET = {
     buyStake: "Buy BRAIN on ripples.run (https://ripples.run/t/0xa06e3D898Bce92F67617E0Bfb640F153A5b65AB7) and bridge it to BrainChain through the " +
         "Robinhood Chain gateway router 0x03f06a370A59AfB23de029F4EF5EA2F9EB034F96 (docs: https://docs.usebrainchain.com/bridging); " +
         `the stake token on BrainChain is ${BRAIN}.`,
-    proofs: { chainId: 4663, name: "Robinhood Chain", rpc: "https://rpc.mainnet.chain.robinhood.com", income: "0xeb1b4168D4b87D3d9F0D64E13B7071251BBB63b7" },
+    proofs: {
+        chainId: 4663,
+        name: "Robinhood Chain",
+        rpc: "https://rpc.mainnet.chain.robinhood.com",
+        collection: "0xE6E6B7DBF1a66dFB25c6F6A87a916B3186113169",
+        weth: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
+        gas: "Send it a little ETH there for gas",
+        income: "0xeb1b4168D4b87D3d9F0D64E13B7071251BBB63b7",
+    },
     contracts: {
         taskBoard: MAINNET_TASK_BOARD,
         staking: MAINNET_WORKER_STAKING,
@@ -88,3 +106,13 @@ export function chainOf(network) {
         rpcUrls: { default: { http: [network.rpc] } },
     });
 }
+const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export function proofsChainOf(proofs) {
+    return defineChain({
+        id: proofs.chainId,
+        name: proofs.name,
+        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: [proofs.rpc] } },
+        contracts: { multicall3: { address: MULTICALL3 } },
+    });
+}

package/dist/state.js

@@ -19,15 +19,22 @@ function isTask(value) {
         return false;
     return value.stored === undefined || (isObject(value.stored) && typeof value.stored.uri === "string" && isHash(value.stored.hash));
 }
+function isProofs(value) {
+    if (!isObject(value) || !isIds(Object.keys(value)))
+        return false;
+    return Object.values(value).every((p) => isObject(p) && isCount(p.deliveredAt) && isCount(p.nextAt) && (p.paidAt === undefined || isCount(p.paidAt)));
+}
 /** Whether a parsed file is a state this worker can go on from; any other shape fails every round that reads it. */
 function isState(value) {
     if (!isObject(value) || typeof value.board !== "string" || !isObject(value.tasks) || !isIds(value.done))
         return false;
     if (!Object.values(value.tasks).every(isTask))
         return false;
-    const { hired, command } = value;
+    const { hired, command, proofs } = value;
     if (hired !== undefined && !(isObject(hired) && isCount(hired.block) && isIds(hired.tasks)))
         return false;
+    if (proofs !== undefined && !isProofs(proofs))
+        return false;
     // Group 0 is this process's own and -1 is every process, so only a real command's group is signalled.
     return command === undefined || (isObject(command) && isCount(command.pgid) && command.pgid > 1 && isCount(command.startedAt));
 }
@@ -90,6 +97,8 @@ function alive(pid) {
         return error.code === "EPERM";
     }
 }
+const holder = (file) => (existsSync(file) ? Number(readFileSync(file, "utf8").trim()) : 0);
+const held = (pid, file) => new Error(`Another run (pid ${pid}) is already working for this worker. Stop it before starting another; ${file} holds its lock.`);
 /** Takes the lock in `file` for this process until it exits; refuses while a live process holds it. */
 export function lock(file) {
     mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
@@ -103,9 +112,9 @@ export function lock(file) {
                 throw error;
         }
         // The holder may have released it since the write failed; then the next try takes it.
-        const holder = existsSync(file) ? Number(readFileSync(file, "utf8").trim()) : 0;
-        if (alive(holder))
-            throw new Error(`Another run (pid ${holder}) is already working for this worker. Stop it before starting another; ${file} holds its lock.`);
+        const pid = holder(file);
+        if (alive(pid))
+            throw held(pid, file);
         rmSync(file, { force: true });
     }
     const release = () => {
@@ -115,3 +124,42 @@ export function lock(file) {
     process.once("exit", release);
     return release;
 }
+/**
+ * Moves the state 0.3.0 and earlier kept per address alone to `file`, once,
+ * when it was kept for `board`. State for the other network stays where it is
+ * until a run there moves it.
+ */
+function migrate(old, file, board) {
+    let text;
+    try {
+        text = readFileSync(`${old}.json`, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    if (parse(text)?.board !== board.toLowerCase())
+        return;
+    // A run from before the move may still be working on this network's tasks from the old file.
+    const pid = holder(`${old}.lock`);
+    if (alive(pid))
+        throw held(pid, `${old}.lock`);
+    if (existsSync(`${file}.json`))
+        return;
+    // Removed rather than moved: this run already holds the new lock.
+    rmSync(`${old}.lock`, { force: true });
+    renameSync(`${old}.json`, `${file}.json`);
+}
+/**
+ * Takes the worker's lock on one network and loads its saved state. Each
+ * network has its own `<address>.<network>.json` and `.lock`, so one key can
+ * run on testnet and mainnet at once without sharing cursors or tasks.
+ */
+export function openStore(address, network, warn, dir = stateDir()) {
+    const old = join(dir, address);
+    const file = `${old}.${network.id}`;
+    lock(`${file}.lock`);
+    migrate(old, file, network.contracts.taskBoard);
+    return fileStore(`${file}.json`, network.contracts.taskBoard, warn);
+}

package/dist/work.js

@@ -315,6 +315,7 @@ export function createWork(options) {
             const delivered = (key, text, tx) => {
                 result.delivered += 1;
                 log(`task ${key}: delivered (${toBytes(text).byteLength} bytes, ${tx}). Jev grades it next.`);
+                options.delivered?.(BigInt(key));
             };
             const current = new Set(hired.map((t) => t.id.toString()));
             for (const [key, attempt] of Object.entries(state.tasks)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Earn on BrainChain: stake, apply, and do the tasks Jev hires your agent for, with any command that reads a task and prints the work.",
   "license": "MIT",
   "author": "BrainChain <hello@usebrainchain.com>",