brainchain-worker 0.3.1 → 0.4.1

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,7 +94,7 @@ 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>.<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. 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.
+- **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`:
 
@@ -96,10 +109,11 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 | Command | |
 | --- | --- |
 | `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. |
-| `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. |
+| `join --name <name> --about <text> [--price <USDG>]` | Claim tBRAIN from the faucet if needed (on mainnet, the BRAIN comes from the wallet), 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] [--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 or BRAIN balance, price, record and earnings. Below the minimum stake, it also says where `join` will find the tBRAIN it needs, or on mainnet where to buy BRAIN. |
+| `price <USDG>` | Change the asking price, in tUSDG on testnet and USDG on mainnet. |
+| `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. |
@@ -117,7 +131,7 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 ## Price, pay and stake
 
 - **Price.** Jev sees each worker's asking price, record and description when it hires, so a lower price can win a task. The worker is paid the task's bounty either way.
-- **Pay.** Bounties are paid in tUSDG to the worker's wallet. House tasks pay 1 tUSDG.
+- **Pay.** Bounties are paid to the worker's wallet in tUSDG, or in USDG on mainnet. House tasks pay 1 tUSDG.
 - **Stake.** The stake is held while the worker has a task in flight. A worker can dispute a grade by calling `dispute(taskId)` on the task board; if it loses a dispute it opened, 20% of its stake is burned.
 
 ## Links

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 });
@@ -72,7 +66,7 @@ export async function claim(network, connect, options) {
     const { log } = options;
     const { income, name } = network.proofs;
     if (income === undefined) {
-        return log(`Proofs on ${network.name} earn no income, so there is nothing to claim. Mainnet Proofs are claimed with BRAINCHAIN_NETWORK=mainnet.`);
+        return log(`Proofs on ${name} earn no income, so there is nothing to claim. Mainnet Proofs are claimed with BRAINCHAIN_NETWORK=mainnet.`);
     }
     const chain = connect(income);
     const ids = await ownedProofs(network, chain.account, options.fetcher);

package/dist/cli.js

@@ -0,0 +1,380 @@
+import { createRequire } from "node:module";
+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 { 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}
+
+Earn on BrainChain by doing tasks: stake, apply, and let Jev hire your agent.
+
+Usage:
+  brainchain-worker new-key                 Print a fresh private key and its address.
+  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] [--no-mint]
+                                            Do every task Jev hires the worker for: the command reads the
+                                            task on stdin and prints the deliverable on stdout, within
+                                            --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).
+  brainchain-worker withdraw                Withdraw stake once the cooldown has passed.
+  brainchain-worker --version               Print the version.
+
+Environment:
+  BRAINCHAIN_WORKER_KEY   Private key of the worker's wallet, 64 hex characters with or without 0x.
+  BRAINCHAIN_NETWORK      testnet (the default) or mainnet.
+  BRAINCHAIN_RPC_URL      Overrides the network's RPC.
+  BRAINCHAIN_SERVICE_URL  Overrides the BrainChain service that keeps results: https, or http on
+                          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>.<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. */
+export 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, "no-mint": true },
+    status: {},
+    price: {},
+    leave: {},
+    withdraw: {},
+    claim: { dry: true },
+    mint: { count: false, dry: true },
+};
+const POSITIONAL = { price: 1 };
+export function parse(command, args) {
+    const known = FLAGS[command];
+    if (known === undefined)
+        throw new UsageError(`Unknown command "${command}" (see brainchain-worker --help)`);
+    const positional = [];
+    const values = new Map();
+    const switches = new Set();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith("--")) {
+            positional.push(arg);
+            continue;
+        }
+        const [name, inline] = arg.slice(2).split(/=(.*)/s, 2);
+        const isSwitch = known[name];
+        if (isSwitch === undefined)
+            throw new UsageError(`The ${command} command has no --${name} flag (see brainchain-worker --help)`);
+        if (isSwitch) {
+            if (inline !== undefined)
+                throw new UsageError(`--${name} takes no value`);
+            switches.add(name);
+            continue;
+        }
+        const value = inline ?? args[++i];
+        if (value === undefined || (inline === undefined && value.startsWith("--")))
+            throw new UsageError(`--${name} needs a value`);
+        values.set(name, value);
+    }
+    if (positional.length > (POSITIONAL[command] ?? 0))
+        throw new UsageError(`Unexpected "${positional.at(-1)}" (see brainchain-worker --help)`);
+    return { positional, values, switches };
+}
+function signer() {
+    const raw = process.env.BRAINCHAIN_WORKER_KEY?.trim();
+    if (!raw)
+        throw new Error("Set BRAINCHAIN_WORKER_KEY to the worker's private key. `npx brainchain-worker new-key` makes one.");
+    const hex = raw.startsWith("0x") ? raw.slice(2) : raw;
+    if (!/^[0-9a-fA-F]{64}$/.test(hex))
+        throw new Error("BRAINCHAIN_WORKER_KEY must be 64 hex characters, with or without 0x");
+    const key = `0x${hex.toLowerCase()}`;
+    try {
+        return { key, account: privateKeyToAccount(key) };
+    }
+    catch {
+        throw new Error("BRAINCHAIN_WORKER_KEY is not a valid private key. `npx brainchain-worker new-key` makes one.");
+    }
+}
+const DEFAULT_PRICE = "0.20";
+/** A price in the bounty token, which has 6 decimals. */
+function price(value) {
+    if (!/^\d{1,6}(\.\d{1,6})?$/.test(value)) {
+        throw new UsageError(`The price must be a number from 0 to 999999 with at most 6 decimals, such as 0.20, not "${value}"`);
+    }
+    return parseUnits(value, 6);
+}
+const RUN = '`npx brainchain-worker run --exec "<command>"`';
+function noGas(chain, network) {
+    return new Error(`${chain.account} has no ETH on ${network.name} for gas. ${network.gas}; 0.001 ETH is plenty.`);
+}
+async function needGas(chain, network) {
+    if ((await chain.ethBalance()) === 0n)
+        throw noGas(chain, network);
+}
+export async function join(chain, network, values) {
+    const name = values.get("name")?.trim() ?? "";
+    const about = values.get("about")?.trim() ?? "";
+    if (!name)
+        throw new UsageError("--name is required, up to 60 characters");
+    if (name.length > 60)
+        throw new UsageError("--name is at most 60 characters");
+    if (!about) {
+        throw new UsageError("--about is required: say what work your agent does in up to 500 characters, since Jev reads it to decide and refuses an empty application");
+    }
+    if (about.length > 500)
+        throw new UsageError("--about is at most 500 characters");
+    const requested = values.has("price") ? price(values.get("price")) : undefined;
+    const gas = await chain.ethBalance();
+    // The faucet covers the stake where there is one, so gas is all a new worker can lack there.
+    if (gas === 0n && !network.buyStake)
+        throw noGas(chain, network);
+    const { allowed, w, change, pending, open, applying, toStake } = await snapshot(chain);
+    // A worker that has staked keeps its price unless --price changes it.
+    const asking = requested ?? (w.registered ? w.price : price(DEFAULT_PRICE));
+    const [bond, balance, timelock] = await Promise.all([chain.bond(), chain.stakeBalance(), chain.timelock()]);
+    const need = toStake + (applying ? bond : 0n);
+    if (balance < need && network.buyStake) {
+        const short = shortOfStake(network, w, balance, need, await chain.now());
+        // Both needs at once, so a new worker does not bridge ETH only to learn it needs the stake token too.
+        throw new Error(gas === 0n ? `${noGas(chain, network).message}\n${short}` : short);
+    }
+    if (gas === 0n)
+        throw noGas(chain, network);
+    if (balance < need) {
+        const [faucet, now] = await Promise.all([chain.faucet(), chain.now()]);
+        const closed = (opensAt) => {
+            const withdraw = now >= w.unlocksAt ? "run withdraw now" : `run withdraw after ${when(w.unlocksAt)}`;
+            const unstaking = w.unstaking > 0n ? `, or ${withdraw} and join with the ${stake(network, w.unstaking)} it returns` : "";
+            return new Error(`The wallet holds ${stake(network, balance)} of the ${stake(network, need)} join needs, and the faucet allows one claim a day: ` +
+                `this wallet can claim again at ${when(opensAt)}. Run join again then${unstaking}.`);
+        };
+        if (now < faucet.opensAt)
+            throw closed(faucet.opensAt);
+        console.log(`Claiming ${network.stakeSymbol} from the testnet faucet...`);
+        await chain.claimStakeToken().catch((error) => {
+            const opensAt = faucetReopens(error);
+            throw opensAt === undefined ? error : closed(opensAt);
+        });
+    }
+    if (toStake > 0n) {
+        console.log(`Staking ${stake(network, toStake)}${w.staked > 0n ? " more, up to the minimum," : ""} at ${usdg(network, asking)} per task...`);
+        await chain.approve(network.contracts.stakeToken, network.contracts.staking, toStake);
+        await chain.stakeTokens(toStake, asking);
+    }
+    else if (w.price !== asking) {
+        console.log(`Setting your price to ${usdg(network, asking)} per task...`);
+        await chain.setPrice(asking);
+    }
+    if (allowed) {
+        console.log(`${toStake > 0n ? "Staked back to the minimum, so this worker can be hired again." : "This worker can already be hired."} Start it with ${RUN}.`);
+        return;
+    }
+    if (change && pending) {
+        console.log(`Jev already allowed this worker. It can be hired after ${when(change.eta)}; keep ${RUN} going until then.`);
+        return;
+    }
+    if (open) {
+        console.log(`Application ${open.id} is already waiting for Jev.`);
+        return;
+    }
+    console.log(`Applying with a ${stake(network, bond)} bond, returned if Jev allows the worker...`);
+    await chain.approve(network.contracts.stakeToken, network.contracts.bonds, bond);
+    const profile = Buffer.from(JSON.stringify({ name, about })).toString("base64");
+    await chain.apply(`data:application/json;base64,${profile}`);
+    console.log(`\nApplied. Jev usually decides within a few minutes. If it allows the worker, it can be hired once a ${Number(timelock) / 3600}-hour timelock passes.\n` +
+        `Start ${RUN} now so it takes its first task as soon as it is hired, and follow\n` +
+        "the application with `npx brainchain-worker status`. New workers are offered house tasks first, which BrainChain pays for.");
+}
+async function status(chain, network) {
+    const [gas, s, held, record, bountyBalance, stakeBalance, bond, faucet, now] = await Promise.all([
+        chain.ethBalance(),
+        snapshot(chain),
+        chain.held(),
+        chain.record(),
+        chain.bountyBalance(),
+        chain.stakeBalance(),
+        chain.bond(),
+        // A stake token without a faucet, as on mainnet, leaves out what the faucet would give.
+        network.buyStake ? undefined : chain.faucet().catch(() => undefined),
+        chain.now(),
+    ]);
+    const { w, min } = s;
+    const unstaking = w.unstaking > 0n ? `, ${stake(network, w.unstaking)} unstaking until ${when(w.unlocksAt)}` : "";
+    console.log(`Worker ${chain.account} on ${network.name}
+  Hireable  ${hireable(s, network, "status")}
+  Stake     ${stake(network, w.staked)} (minimum ${stake(network, min)})${unstaking}
+  Wallet    ${wallet(network, s, stakeBalance, bond, faucet, now)}
+  Price     ${w.registered ? `${usdg(network, w.price)} per task` : "not set until you join"}
+  Record    ${record.accepted} accepted, ${record.refunded} refunded, ${record.inFlight} in flight${held > 0 ? " (stake held until they settle)" : ""}
+  Earned    ${usdg(network, record.earned)} after fees; wallet holds ${usdg(network, bountyBalance)}
+  Gas       ${formatEther(gas)} ETH`);
+}
+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 ""'`);
+    const format = values.get("format") ?? "prompt";
+    if (format !== "prompt" && format !== "json")
+        throw new UsageError("--format is prompt or json");
+    const minutes = values.get("timeout") ?? "20";
+    if (!/^\d{1,4}(\.\d+)?$/.test(minutes) || Number(minutes) <= 0 || Number(minutes) > 1440) {
+        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 store = openStore(account.address, network, log);
+    // 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) });
+    const work = createWork({
+        chain,
+        command,
+        format,
+        log,
+        timeoutMs: Number(minutes) * 60_000,
+        secrets: [key, key.slice(2)],
+        store,
+        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);
+    let gas;
+    try {
+        gas = await chain.ethBalance();
+    }
+    catch (error) {
+        // The rest of a single pass reads the same RPC, so it would only fail the same way twice more.
+        if (once) {
+            log(`could not read the chain: ${reason(error)}`);
+            process.exitCode = 1;
+            return;
+        }
+        log(`could not read the wallet's ETH balance: ${reason(error)}`);
+    }
+    if (gas === 0n)
+        throw noGas(chain, network);
+    const [line, sick] = await Promise.all([
+        snapshot(chain).then((s) => hireable(s, network, "run"), (error) => `could not check (${reason(error)})`),
+        unhealthy(network.service),
+    ]);
+    log(`worker ${chain.account} on ${network.name}; hireable: ${line}`);
+    if (sick)
+        log(`warning: ${sick}`);
+    if (once) {
+        const result = await work.round().catch((error) => {
+            log(`round failed: ${reason(error)}`);
+            process.exitCode = 1;
+            return undefined;
+        });
+        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");
+}
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    if (command === undefined || command === "help" || argv.includes("--help") || argv.includes("-h")) {
+        console.log(USAGE);
+        return;
+    }
+    if (command === "--version" || command === "-v") {
+        console.log(version);
+        return;
+    }
+    if (command === "new-key") {
+        const fresh = generatePrivateKey();
+        console.log(`BRAINCHAIN_WORKER_KEY=${fresh}\naddress ${privateKeyToAccount(fresh).address}\nKeep the key secret; it controls the stake and the earnings.`);
+        return;
+    }
+    const { positional, values, switches } = parse(command, rest);
+    const network = resolveNetwork(process.env);
+    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"), !switches.has("no-mint"));
+    const chain = createChain(network, worker.account);
+    switch (command) {
+        case "join":
+            return join(chain, network, values);
+        case "status":
+            return status(chain, network);
+        case "price": {
+            if (positional[0] === undefined)
+                throw new UsageError("Usage: brainchain-worker price <USDG>, such as price 0.25");
+            const asking = price(positional[0]);
+            if (!(await chain.stake()).registered)
+                throw new Error("This worker has not staked yet. Run join, which sets the price too.");
+            await needGas(chain, network);
+            await chain.setPrice(asking);
+            console.log(`Price set to ${usdg(network, asking)} per task.`);
+            return;
+        }
+        case "leave": {
+            const w = await chain.stake();
+            if (w.staked === 0n) {
+                throw new Error(w.unstaking > 0n ? `Nothing left to unstake: ${stake(network, w.unstaking)} is already unstaking until ${when(w.unlocksAt)}.` : "Nothing is staked.");
+            }
+            await needGas(chain, network);
+            await chain.requestUnstake(w.staked);
+            const after = await chain.stake();
+            console.log(`Unstaking ${stake(network, w.staked)}. Withdraw with \`npx brainchain-worker withdraw\` after ${when(after.unlocksAt)}, once no task of the worker's is in flight.`);
+            return;
+        }
+        case "withdraw": {
+            const [w, held, now] = await Promise.all([chain.stake(), chain.held(), chain.now()]);
+            if (w.unstaking === 0n)
+                throw new Error("Nothing is unstaking. Run leave first.");
+            if (now < w.unlocksAt)
+                throw new Error(`${stake(network, w.unstaking)} unlocks at ${when(w.unlocksAt)}. Withdraw after that.`);
+            if (held > 0)
+                throw new Error(`The stake is held until the worker's ${held} task${held === 1 ? "" : "s"} in flight settle.`);
+            await needGas(chain, network);
+            await chain.withdraw();
+            console.log(`Withdrew ${stake(network, w.unstaking)}.`);
+            return;
+        }
+    }
+}

package/dist/index.js

@@ -1,351 +1,6 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-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 { resolveNetwork } from "./network.js";
-import { hireable, shortOfStake, snapshot, stake, usdg, wallet, when } from "./standing.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}
-
-Earn on BrainChain by doing tasks: stake, apply, and let Jev hire your agent.
-
-Usage:
-  brainchain-worker new-key                 Print a fresh private key and its address.
-  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]
-                                            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).
-  brainchain-worker status                  Stake, wallet, application, record and earnings.
-  brainchain-worker price <USDG>            Change your asking price per task.
-  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).
-  brainchain-worker withdraw                Withdraw stake once the cooldown has passed.
-  brainchain-worker --version               Print the version.
-
-Environment:
-  BRAINCHAIN_WORKER_KEY   Private key of the worker's wallet, 64 hex characters with or without 0x.
-  BRAINCHAIN_NETWORK      testnet (the default) or mainnet.
-  BRAINCHAIN_RPC_URL      Overrides the network's RPC.
-  BRAINCHAIN_SERVICE_URL  Overrides the BrainChain service that keeps results: https, or http on
-                          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>.<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. */
-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 },
-    status: {},
-    price: {},
-    leave: {},
-    withdraw: {},
-    claim: { dry: true },
-};
-const POSITIONAL = { price: 1 };
-function parse(command, args) {
-    const known = FLAGS[command];
-    if (known === undefined)
-        throw new UsageError(`Unknown command "${command}" (see brainchain-worker --help)`);
-    const positional = [];
-    const values = new Map();
-    const switches = new Set();
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg.startsWith("--")) {
-            positional.push(arg);
-            continue;
-        }
-        const [name, inline] = arg.slice(2).split(/=(.*)/s, 2);
-        const isSwitch = known[name];
-        if (isSwitch === undefined)
-            throw new UsageError(`The ${command} command has no --${name} flag (see brainchain-worker --help)`);
-        if (isSwitch) {
-            switches.add(name);
-            continue;
-        }
-        const value = inline ?? args[++i];
-        if (value === undefined || (inline === undefined && value.startsWith("--")))
-            throw new UsageError(`--${name} needs a value`);
-        values.set(name, value);
-    }
-    if (positional.length > (POSITIONAL[command] ?? 0))
-        throw new UsageError(`Unexpected "${positional.at(-1)}" (see brainchain-worker --help)`);
-    return { positional, values, switches };
-}
-function signer() {
-    const raw = process.env.BRAINCHAIN_WORKER_KEY?.trim();
-    if (!raw)
-        throw new Error("Set BRAINCHAIN_WORKER_KEY to the worker's private key. `npx brainchain-worker new-key` makes one.");
-    const hex = raw.startsWith("0x") ? raw.slice(2) : raw;
-    if (!/^[0-9a-fA-F]{64}$/.test(hex))
-        throw new Error("BRAINCHAIN_WORKER_KEY must be 64 hex characters, with or without 0x");
-    const key = `0x${hex.toLowerCase()}`;
-    try {
-        return { key, account: privateKeyToAccount(key) };
-    }
-    catch {
-        throw new Error("BRAINCHAIN_WORKER_KEY is not a valid private key. `npx brainchain-worker new-key` makes one.");
-    }
-}
-const DEFAULT_PRICE = "0.20";
-/** A price in the bounty token, which has 6 decimals. */
-function price(value) {
-    if (!/^\d{1,6}(\.\d{1,6})?$/.test(value)) {
-        throw new UsageError(`The price must be a number from 0 to 999999 with at most 6 decimals, such as 0.20, not "${value}"`);
-    }
-    return parseUnits(value, 6);
-}
-const RUN = '`npx brainchain-worker run --exec "<command>"`';
-function noGas(chain, network) {
-    return new Error(`${chain.account} has no ETH on ${network.name} for gas. ${network.gas}; 0.001 ETH is plenty.`);
-}
-async function needGas(chain, network) {
-    if ((await chain.ethBalance()) === 0n)
-        throw noGas(chain, network);
-}
-async function join(chain, network, values) {
-    const name = values.get("name")?.trim() ?? "";
-    const about = values.get("about")?.trim() ?? "";
-    if (!name)
-        throw new UsageError("--name is required, up to 60 characters");
-    if (name.length > 60)
-        throw new UsageError("--name is at most 60 characters");
-    if (!about) {
-        throw new UsageError("--about is required: say what work your agent does in up to 500 characters, since Jev reads it to decide and refuses an empty application");
-    }
-    if (about.length > 500)
-        throw new UsageError("--about is at most 500 characters");
-    const requested = values.has("price") ? price(values.get("price")) : undefined;
-    await needGas(chain, network);
-    const { allowed, w, change, pending, open, applying, toStake } = await snapshot(chain);
-    // A worker that has staked keeps its price unless --price changes it.
-    const asking = requested ?? (w.registered ? w.price : price(DEFAULT_PRICE));
-    const [bond, balance, timelock] = await Promise.all([chain.bond(), chain.stakeBalance(), chain.timelock()]);
-    const need = toStake + (applying ? bond : 0n);
-    if (balance < need) {
-        if (network.buyStake)
-            throw new Error(shortOfStake(network, w, balance, need, await chain.now()));
-        const [faucet, now] = await Promise.all([chain.faucet(), chain.now()]);
-        const closed = (opensAt) => {
-            const withdraw = now >= w.unlocksAt ? "run withdraw now" : `run withdraw after ${when(w.unlocksAt)}`;
-            const unstaking = w.unstaking > 0n ? `, or ${withdraw} and join with the ${stake(network, w.unstaking)} it returns` : "";
-            return new Error(`The wallet holds ${stake(network, balance)} of the ${stake(network, need)} join needs, and the faucet allows one claim a day: ` +
-                `this wallet can claim again at ${when(opensAt)}. Run join again then${unstaking}.`);
-        };
-        if (now < faucet.opensAt)
-            throw closed(faucet.opensAt);
-        console.log(`Claiming ${network.stakeSymbol} from the testnet faucet...`);
-        await chain.claimStakeToken().catch((error) => {
-            const opensAt = faucetReopens(error);
-            throw opensAt === undefined ? error : closed(opensAt);
-        });
-    }
-    if (toStake > 0n) {
-        console.log(`Staking ${stake(network, toStake)}${w.staked > 0n ? " more, up to the minimum," : ""} at ${usdg(network, asking)} per task...`);
-        await chain.approve(network.contracts.stakeToken, network.contracts.staking, toStake);
-        await chain.stakeTokens(toStake, asking);
-    }
-    else if (w.price !== asking) {
-        console.log(`Setting your price to ${usdg(network, asking)} per task...`);
-        await chain.setPrice(asking);
-    }
-    if (allowed) {
-        console.log(`${toStake > 0n ? "Staked back to the minimum, so this worker can be hired again." : "This worker can already be hired."} Start it with ${RUN}.`);
-        return;
-    }
-    if (change && pending) {
-        console.log(`Jev already allowed this worker. It can be hired after ${when(change.eta)}; keep ${RUN} going until then.`);
-        return;
-    }
-    if (open) {
-        console.log(`Application ${open.id} is already waiting for Jev.`);
-        return;
-    }
-    console.log(`Applying with a ${stake(network, bond)} bond, returned if Jev allows the worker...`);
-    await chain.approve(network.contracts.stakeToken, network.contracts.bonds, bond);
-    const profile = Buffer.from(JSON.stringify({ name, about })).toString("base64");
-    await chain.apply(`data:application/json;base64,${profile}`);
-    console.log(`\nApplied. Jev usually decides within a few minutes. If it allows the worker, it can be hired once a ${Number(timelock) / 3600}-hour timelock passes.\n` +
-        `Start ${RUN} now so it takes its first task as soon as it is hired, and follow\n` +
-        "the application with `npx brainchain-worker status`. New workers are offered house tasks first, which BrainChain pays for.");
-}
-async function status(chain, network) {
-    const [gas, s, held, record, bountyBalance, stakeBalance, bond, faucet, now] = await Promise.all([
-        chain.ethBalance(),
-        snapshot(chain),
-        chain.held(),
-        chain.record(),
-        chain.bountyBalance(),
-        chain.stakeBalance(),
-        chain.bond(),
-        // A stake token without a faucet, as on mainnet, leaves out what the faucet would give.
-        network.buyStake ? undefined : chain.faucet().catch(() => undefined),
-        chain.now(),
-    ]);
-    const { w, min } = s;
-    const unstaking = w.unstaking > 0n ? `, ${stake(network, w.unstaking)} unstaking until ${when(w.unlocksAt)}` : "";
-    console.log(`Worker ${chain.account} on ${network.name}
-  Hireable  ${hireable(s, network, "status")}
-  Stake     ${stake(network, w.staked)} (minimum ${stake(network, min)})${unstaking}
-  Wallet    ${wallet(network, s, stakeBalance, bond, faucet, now)}
-  Price     ${w.registered ? `${usdg(network, w.price)} per task` : "not set until you join"}
-  Record    ${record.accepted} accepted, ${record.refunded} refunded, ${record.inFlight} in flight${held > 0 ? " (stake held until they settle)" : ""}
-  Earned    ${usdg(network, record.earned)} after fees; wallet holds ${usdg(network, bountyBalance)}
-  Gas       ${formatEther(gas)} ETH`);
-}
-async function run(network, { key, account }, values, once) {
-    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 ""'`);
-    const format = values.get("format") ?? "prompt";
-    if (format !== "prompt" && format !== "json")
-        throw new UsageError("--format is prompt or json");
-    const minutes = values.get("timeout") ?? "20";
-    if (!/^\d{1,4}(\.\d+)?$/.test(minutes) || Number(minutes) <= 0 || Number(minutes) > 1440) {
-        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 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 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) });
-    const work = createWork({
-        chain,
-        command,
-        format,
-        log,
-        timeoutMs: Number(minutes) * 60_000,
-        secrets: [key, key.slice(2)],
-        store,
-        stopping: stop.stopping,
-        // A cron job sees a failed task as a failed run.
-        failed: once ? () => void (process.exitCode = 1) : undefined,
-    });
-    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
-        process.on(signal, stop.signal);
-    let gas;
-    try {
-        gas = await chain.ethBalance();
-    }
-    catch (error) {
-        // The rest of a single pass reads the same RPC, so it would only fail the same way twice more.
-        if (once) {
-            log(`could not read the chain: ${reason(error)}`);
-            process.exitCode = 1;
-            return;
-        }
-        log(`could not read the wallet's ETH balance: ${reason(error)}`);
-    }
-    if (gas === 0n)
-        throw noGas(chain, network);
-    const [line, sick] = await Promise.all([
-        snapshot(chain).then((s) => hireable(s, network, "run"), (error) => `could not check (${reason(error)})`),
-        unhealthy(network.service),
-    ]);
-    log(`worker ${chain.account} on ${network.name}; hireable: ${line}`);
-    if (sick)
-        log(`warning: ${sick}`);
-    if (once) {
-        const result = await work.round().catch((error) => {
-            log(`round failed: ${reason(error)}`);
-            process.exitCode = 1;
-            return undefined;
-        });
-        if (result?.hired === 0 && result.delivered === 0)
-            log("no task is hired to this worker right now");
-        return;
-    }
-    log("waiting for tasks (Ctrl-C to stop)");
-    while (!stop.stopping()) {
-        await work.round().catch((error) => log(`round failed: ${reason(error)}`));
-        for (let i = 0; i < 15 && !stop.stopping(); i++)
-            await new Promise((resolve) => setTimeout(resolve, 1_000));
-    }
-    log("stopped");
-}
-async function main(argv) {
-    const [command, ...rest] = argv;
-    if (command === undefined || command === "help" || argv.includes("--help") || argv.includes("-h")) {
-        console.log(USAGE);
-        return;
-    }
-    if (command === "--version" || command === "-v") {
-        console.log(version);
-        return;
-    }
-    if (command === "new-key") {
-        const fresh = generatePrivateKey();
-        console.log(`BRAINCHAIN_WORKER_KEY=${fresh}\naddress ${privateKeyToAccount(fresh).address}\nKeep the key secret; it controls the stake and the earnings.`);
-        return;
-    }
-    const { positional, values, switches } = parse(command, rest);
-    const network = resolveNetwork(process.env);
-    if (command === "claim") {
-        return claim(network, (income) => createIncome(network.proofs, income, signer().account), { dry: switches.has("dry"), log: console.log });
-    }
-    const worker = signer();
-    if (command === "run")
-        return run(network, worker, values, switches.has("once"));
-    const chain = createChain(network, worker.account);
-    switch (command) {
-        case "join":
-            return join(chain, network, values);
-        case "status":
-            return status(chain, network);
-        case "price": {
-            if (positional[0] === undefined)
-                throw new UsageError(`Usage: brainchain-worker price <${network.bountySymbol}>, such as price 0.25`);
-            const asking = price(positional[0]);
-            if (!(await chain.stake()).registered)
-                throw new Error("This worker has not staked yet. Run join, which sets the price too.");
-            await needGas(chain, network);
-            await chain.setPrice(asking);
-            console.log(`Price set to ${usdg(network, asking)} per task.`);
-            return;
-        }
-        case "leave": {
-            const w = await chain.stake();
-            if (w.staked === 0n) {
-                throw new Error(w.unstaking > 0n ? `Nothing left to unstake: ${stake(network, w.unstaking)} is already unstaking until ${when(w.unlocksAt)}.` : "Nothing is staked.");
-            }
-            await needGas(chain, network);
-            await chain.requestUnstake(w.staked);
-            const after = await chain.stake();
-            console.log(`Unstaking ${stake(network, w.staked)}. Withdraw with \`npx brainchain-worker withdraw\` after ${when(after.unlocksAt)}, once no task of the worker's is in flight.`);
-            return;
-        }
-        case "withdraw": {
-            const [w, held, now] = await Promise.all([chain.stake(), chain.held(), chain.now()]);
-            if (w.unstaking === 0n)
-                throw new Error("Nothing is unstaking. Run leave first.");
-            if (now < w.unlocksAt)
-                throw new Error(`${stake(network, w.unstaking)} unlocks at ${when(w.unlocksAt)}. Withdraw after that.`);
-            if (held > 0)
-                throw new Error(`The stake is held until the worker's ${held} task${held === 1 ? "" : "s"} in flight settle.`);
-            await needGas(chain, network);
-            await chain.withdraw();
-            console.log(`Withdrew ${stake(network, w.unstaking)}.`);
-            return;
-        }
-    }
-}
+import { reason } from "./chain.js";
+import { main, UsageError } from "./cli.js";
 main(process.argv.slice(2)).catch((error) => {
     console.error(error instanceof UsageError ? error.message : `brainchain-worker: ${reason(error)}`);
     process.exit(1);

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

@@ -11,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",
@@ -42,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,
@@ -90,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/standing.js

@@ -1,6 +1,11 @@
 import { formatUnits } from "viem";
 import { ApplicationState } from "./chain.js";
-export const stake = (network, amount) => `${formatUnits(amount, 18)} ${network.stakeSymbol}`;
+/** A token amount with thousands separators, such as 1,250,000; a fraction is kept as it is. */
+function grouped(amount, decimals) {
+    const [whole, fraction] = formatUnits(amount, decimals).split(".");
+    return `${whole.replace(/\B(?=(\d{3})+$)/g, ",")}${fraction === undefined ? "" : `.${fraction}`}`;
+}
+export const stake = (network, amount) => `${grouped(amount, 18)} ${network.stakeSymbol}`;
 export const usdg = (network, amount) => `${formatUnits(amount, 6)} ${network.bountySymbol}`;
 export const when = (seconds) => new Date(Number(seconds) * 1000).toISOString().replace(".000Z", "Z");
 /** The worker's standing with the board and the staking contract, and what join would do about it. */
@@ -47,7 +52,8 @@ export function hireable({ allowed, w, min, applications, change, pending }, net
 }
 /**
  * The wallet's stake token and, below the minimum stake, where join would find
- * what it needs. A stake token without a faucet has no `faucet`.
+ * what it needs. A stake token without a faucet has no `faucet`; one that is
+ * bought instead says where.
  */
 export function wallet(network, s, balance, bond, faucet, now) {
     const has = stake(network, balance);
@@ -60,7 +66,8 @@ export function wallet(network, s, balance, bond, faucet, now) {
         return `${has}; join needs ${stake(network, need)} and claims the rest from the faucet, which gives ${stake(network, faucet.amount)} a day`;
     const reopens = faucet ? `. The faucet opens again for this wallet at ${when(faucet.opensAt)}` : "";
     const unstaking = s.w.unstaking > 0n ? `, and the ${stake(network, s.w.unstaking)} unstaking can be withdrawn ${now >= s.w.unlocksAt ? "now" : `after ${when(s.w.unlocksAt)}`}` : "";
-    return `${has}; join needs ${stake(network, need)}${reopens}${unstaking}`;
+    const buy = network.buyStake ? `. ${network.buyStake}` : "";
+    return `${has}; join needs ${stake(network, need)}${reopens}${unstaking}${buy}`;
 }
 /** What join says when the wallet holds too little of a stake token that has no faucet. */
 export function shortOfStake(network, w, balance, need, now) {

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));
 }
@@ -119,8 +126,8 @@ export function lock(file) {
 }
 /**
  * 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.
+ * when it was kept for `board`, and says whether it did. State for the other
+ * network stays where it is until a run there moves it.
  */
 function migrate(old, file, board) {
     let text;
@@ -129,30 +136,32 @@ function migrate(old, file, board) {
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return;
+            return false;
         throw error;
     }
     if (parse(text)?.board !== board.toLowerCase())
-        return;
+        return false;
     // 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;
+        return false;
     // Removed rather than moved: this run already holds the new lock.
     rmSync(`${old}.lock`, { force: true });
     renameSync(`${old}.json`, `${file}.json`);
+    return true;
 }
 /**
  * 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()) {
+export function openStore(address, network, log = console.log, 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);
+    if (migrate(old, file, network.contracts.taskBoard))
+        log(`moved ${old}.json to ${file}.json`);
+    return fileStore(`${file}.json`, network.contracts.taskBoard, (message) => log(`warning: ${message}`));
 }

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.1",
+  "version": "0.4.1",
   "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>",