brainchain-worker 0.0.0-stage → 0.2.0

package/dist/chain.js

@@ -0,0 +1,289 @@
+import { isIP } from "node:net";
+import { BaseError, ContractFunctionRevertedError, createPublicClient, createWalletClient, encodeFunctionData, http, HttpRequestError, keccak256, parseAbi, TimeoutError, toBytes, } from "viem";
+import { erc20Errors, taskBoardAbi, workerStakingAbi } from "./abi.js";
+import { chainOf } from "./network.js";
+import { memoryStore } from "./state.js";
+export const erc20Abi = 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()",
+    "error TooSoon(uint256 nextClaimAt)",
+]);
+export const bondsAbi = [
+    ...parseAbi([
+        "event Proposed(uint256 indexed id, address indexed proposer, address indexed target, bytes data, uint128 bond, string uri)",
+        "event Settled(uint256 indexed id, uint256 indexed decisionId, bool adopted)",
+        "function propose(address target, bytes data, string uri) returns (uint256)",
+        "function get(uint256 id) view returns ((address proposer, uint128 bond, uint64 createdAt, uint8 state, bytes32 subject))",
+        "function bond() view returns (uint128)",
+    ]),
+    ...erc20Errors,
+];
+export const executorAbi = parseAbi([
+    "event Queued(uint256 indexed changeId, uint256 indexed decisionId, address indexed target, bytes data, uint64 eta)",
+    "function getChange(uint256 changeId) view returns ((address target, bytes data, uint64 eta, bool executed, bool vetoed))",
+]);
+/** Mirrors TaskBoard.Status. */
+export const Status = { Open: 1, Hired: 2, Submitted: 3, Graded: 4, Disputed: 5, Paid: 6, Refunded: 7 };
+/** Mirrors ProposalBonds.State. */
+export const ApplicationState = { Open: 1, Returned: 2, Burned: 3 };
+const LOG_RANGE = 50000n;
+const MAX_BRIEF_BYTES = 256 * 1024;
+/** What the service answers when it will never take this result. */
+const REFUSED = [400, 403, 409, 413];
+/** A failure that trying again cannot fix. */
+export class Permanent extends Error {
+}
+/** What the worker signs to upload a result: the chain, the board, the task and the hash of exactly the bytes it uploads. */
+export function resultMessage(chainId, board, task, hash) {
+    return ["BrainChain result v2", `chain ${chainId}`, `board ${board.toLowerCase()}`, `task ${task}`, `hash ${hash}`].join("\n");
+}
+/** WorkerStaking.idOf: a worker's id is its account, left-padded to 32 bytes. */
+export function workerId(account) {
+    return `0x${account.slice(2).toLowerCase().padStart(64, "0")}`;
+}
+export function applicationData(account) {
+    return encodeFunctionData({ abi: taskBoardAbi, functionName: "setWorkerAllowed", args: [account, true] });
+}
+/** The name of the contract error a call reverted with, when the ABI knows it. */
+function revertName(error) {
+    const revert = error instanceof BaseError ? error.walk((e) => e instanceof ContractFunctionRevertedError) : null;
+    return revert instanceof ContractFunctionRevertedError ? revert.data?.errorName : undefined;
+}
+export function submitFailure(error) {
+    const name = revertName(error);
+    if (name === "TooLate")
+        return new Permanent("The deadline passed before the result could be submitted");
+    if (name === "BadStatus")
+        return new Permanent("The task no longer waits for a result");
+    return error;
+}
+const hostOf = (url) => (URL.canParse(url) ? new URL(url).host : "the RPC");
+/** One readable line for an error. It names the RPC by host only: its URL can hold an API key. */
+export function describe(error) {
+    if (!(error instanceof BaseError))
+        return error instanceof Error ? error.message : String(error);
+    const request = error.walk((e) => e instanceof HttpRequestError || e instanceof TimeoutError);
+    if (request instanceof HttpRequestError || request instanceof TimeoutError) {
+        return `Could not reach ${hostOf(request.url)}${request.details ? ` (${request.details})` : ""}`;
+    }
+    const name = revertName(error);
+    return name ? `${error.shortMessage} (${name})` : error.shortMessage;
+}
+export function createChain(network, account, store = memoryStore()) {
+    const chain = chainOf(network);
+    const transport = http(network.rpc, { timeout: 20_000, retryCount: 3 });
+    // BrainChain mines a block per transaction, so receipts are polled every second.
+    const client = createPublicClient({ chain, transport, pollingInterval: 1_000 });
+    const wallet = createWalletClient({ account, chain, transport });
+    const { taskBoard, staking, bonds, executor, stakeToken, bountyToken } = network.contracts;
+    const id = workerId(account.address);
+    const board = { address: taskBoard, abi: taskBoardAbi };
+    const origin = new URL(network.service).origin;
+    async function send(request) {
+        const hash = await wallet.writeContract(request);
+        const receipt = await client.waitForTransactionReceipt({ hash, timeout: 90_000 });
+        if (receipt.status !== "success")
+            throw new Error(`Transaction ${hash} reverted`);
+        return hash;
+    }
+    /** Every log of one event from `from` to `to`, in windows the RPC accepts. */
+    async function scan(fetch, from, to) {
+        const all = [];
+        for (let start = from; start <= to; start += LOG_RANGE) {
+            const end = start + LOG_RANGE - 1n < to ? start + LOG_RANGE - 1n : to;
+            all.push(...(await fetch(start, end)));
+        }
+        return all;
+    }
+    const hiredLogs = (from, to) => scan((fromBlock, toBlock) => client.getContractEvents({ ...board, eventName: "WorkerHired", args: { model: id }, fromBlock, toBlock }), from, to);
+    const briefs = new Map();
+    async function briefURI(task, latest) {
+        const known = briefs.get(task);
+        if (known !== undefined)
+            return known;
+        const [posted] = await scan((fromBlock, toBlock) => client.getContractEvents({ ...board, eventName: "Posted", args: { id: task }, fromBlock, toBlock }), network.fromBlock, latest);
+        if (posted === undefined)
+            throw new Error(`Task ${task} has no Posted event`);
+        briefs.set(task, posted.args.briefURI);
+        return posted.args.briefURI;
+    }
+    const work = {
+        async now() {
+            const block = await client.getBlock();
+            const wall = BigInt(Math.floor(Date.now() / 1000));
+            // An idle chain makes no blocks, so the latest block's time can lag the clock.
+            return block.timestamp > wall ? block.timestamp : wall;
+        },
+        async hired() {
+            const latest = await client.getBlockNumber();
+            const known = store.state.hired;
+            const ids = new Set(known?.tasks);
+            for (const log of await hiredLogs(known ? BigInt(known.block) + 1n : network.fromBlock, latest))
+                ids.add(log.args.id.toString());
+            const tasks = await Promise.all([...ids].map(async (key) => {
+                const task = BigInt(key);
+                const t = await client.readContract({ ...board, functionName: "get", args: [task] });
+                if (t.status === Status.Hired && t.model.toLowerCase() === id) {
+                    return { id: task, deadline: t.deadline, briefURI: await briefURI(task, latest), briefHash: t.briefHash };
+                }
+                // A task never returns to Hired, the only state that waits on the worker.
+                briefs.delete(task);
+                return undefined;
+            }));
+            const hired = tasks.filter((t) => t !== undefined);
+            store.state.hired = { block: Number(latest), tasks: hired.map((t) => t.id.toString()) };
+            store.save();
+            return hired;
+        },
+        ethBalance: () => client.getBalance({ address: account.address }),
+        async publish(task, text) {
+            const hash = keccak256(toBytes(text));
+            const signature = await account.signMessage({ message: resultMessage(network.chainId, taskBoard, task, hash) });
+            const response = await fetch(`${network.service}/results`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ task: task.toString(), text, signature }),
+                signal: AbortSignal.timeout(30_000),
+            }).catch(() => {
+                throw new Error(`Could not reach the BrainChain service at ${new URL(origin).host}`);
+            });
+            const body = (await response.json().catch(() => ({})));
+            const reason = `(${response.status}): ${body.error ?? "no reason given"}`;
+            if (REFUSED.includes(response.status))
+                throw new Permanent(`The service refused the result ${reason}`);
+            if (!response.ok || !body.uri)
+                throw new Error(`Uploading the result failed ${reason}`);
+            if (body.hash?.toLowerCase() !== hash)
+                throw new Error("The service stored different bytes than were sent");
+            if (!body.uri.startsWith(`${origin}/`))
+                throw new Error(`The service returned a result address outside ${origin}`);
+            return { uri: body.uri, hash };
+        },
+        submit: (task, resultHash, resultURI) => send({ ...board, functionName: "submit", args: [task, resultHash, resultURI] }).catch((error) => {
+            throw submitFailure(error);
+        }),
+    };
+    return {
+        ...work,
+        account: account.address,
+        stakeBalance: () => client.readContract({ address: stakeToken, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
+        bountyBalance: () => client.readContract({ address: bountyToken, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
+        stake: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "get", args: [account.address] }),
+        minStake: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "minStake" }),
+        inFlight: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "held", args: [account.address] }),
+        allowed: () => client.readContract({ ...board, functionName: "workerAllowed", args: [account.address] }),
+        bond: () => client.readContract({ address: bonds, abi: bondsAbi, functionName: "bond" }),
+        async approve(token, spender, amount) {
+            const current = await client.readContract({ address: token, abi: erc20Abi, functionName: "allowance", args: [account.address, spender] });
+            if (current >= amount)
+                return;
+            await send({ address: token, abi: erc20Abi, functionName: "approve", args: [spender, amount] });
+        },
+        claimStakeToken: () => send({ address: stakeToken, abi: erc20Abi, functionName: "faucet" }),
+        stakeTokens: (amount, price) => send({ address: staking, abi: workerStakingAbi, functionName: "stake", args: [amount, price] }),
+        setPrice: (price) => send({ address: staking, abi: workerStakingAbi, functionName: "setPrice", args: [price] }),
+        requestUnstake: (amount) => send({ address: staking, abi: workerStakingAbi, functionName: "requestUnstake", args: [amount] }),
+        withdraw: () => send({ address: staking, abi: workerStakingAbi, functionName: "withdraw" }),
+        apply: (profileURI) => send({ address: bonds, abi: bondsAbi, functionName: "propose", args: [taskBoard, applicationData(account.address), profileURI] }),
+        /**
+         * This worker's applications, newest last, with their state and the
+         * decision that settled each, and the last change any of them queued.
+         * Everything is read at one block, so a bond settled just after its change
+         * was queued is never seen without the change.
+         */
+        async applications() {
+            const data = applicationData(account.address).toLowerCase();
+            const blockNumber = await client.getBlockNumber();
+            const proposed = (await scan((fromBlock, toBlock) => client.getContractEvents({ address: bonds, abi: bondsAbi, eventName: "Proposed", args: { proposer: account.address, target: taskBoard }, fromBlock, toBlock }), network.fromBlock, blockNumber)).filter((log) => log.args.data.toLowerCase() === data);
+            // Queued does not index the call, so its scan narrows to the board as target and to blocks from this worker's first application on.
+            const since = proposed[0]?.blockNumber ?? blockNumber + 1n;
+            const [settled, queued] = await Promise.all([
+                scan((fromBlock, toBlock) => client.getContractEvents({ address: bonds, abi: bondsAbi, eventName: "Settled", args: { id: proposed.map((log) => log.args.id) }, fromBlock, toBlock }), since, blockNumber),
+                scan((fromBlock, toBlock) => client.getContractEvents({ address: executor, abi: executorAbi, eventName: "Queued", args: { target: taskBoard }, fromBlock, toBlock }), since, blockNumber),
+            ]);
+            const mine = queued.filter((log) => log.args.data.toLowerCase() === data).at(-1);
+            const change = mine && {
+                ...(await client.readContract({ address: executor, abi: executorAbi, functionName: "getChange", args: [mine.args.changeId], blockNumber })),
+                decisionId: mine.args.decisionId,
+            };
+            const decided = new Map(settled.map((log) => [log.args.id, log.args.decisionId]));
+            const applications = await Promise.all(proposed.map(async (log) => ({
+                id: log.args.id,
+                state: (await client.readContract({ address: bonds, abi: bondsAbi, functionName: "get", args: [log.args.id], blockNumber })).state,
+                decisionId: decided.get(log.args.id),
+            })));
+            return { applications, change };
+        },
+        /** Tasks this worker was hired for, by outcome, and what it was paid after fees. */
+        async record() {
+            const latest = await client.getBlockNumber();
+            const ids = [...new Set((await hiredLogs(network.fromBlock, latest)).map((log) => log.args.id))];
+            const tasks = await Promise.all(ids.map((task) => client.readContract({ ...board, functionName: "get", args: [task] })));
+            const paid = await scan((fromBlock, toBlock) => client.getContractEvents({ ...board, eventName: "BountyPaid", args: { account: account.address }, fromBlock, toBlock }), network.fromBlock, latest);
+            const count = (statuses) => tasks.filter((t) => statuses.includes(t.status)).length;
+            return {
+                accepted: count([Status.Paid]),
+                refunded: tasks.filter((t) => t.status === Status.Refunded && t.model.toLowerCase() === id).length,
+                inFlight: count([Status.Hired, Status.Submitted, Status.Graded, Status.Disputed]),
+                earned: paid.reduce((sum, log) => sum + log.args.bounty - log.args.fee, 0n),
+            };
+        },
+    };
+}
+/** Briefs come from strangers, so the worker fetches only public names, never an address or a local network's name. */
+function publicHost(hostname) {
+    const host = hostname.toLowerCase().replace(/\.$/, "");
+    if (host.startsWith("[") || isIP(host) !== 0)
+        return false;
+    return host.includes(".") && !/(^|\.)localhost$|\.local$|\.internal$/.test(host);
+}
+async function download(uri, fetcher) {
+    if (!URL.canParse(uri))
+        throw new Permanent("The brief's URL is not valid");
+    const url = new URL(uri);
+    if (!publicHost(url.hostname))
+        throw new Permanent(`The brief is on ${url.hostname}, which is not a public host`);
+    const stop = new AbortController();
+    const response = await fetcher(url, { redirect: "error", signal: AbortSignal.any([stop.signal, AbortSignal.timeout(15_000)]) });
+    if (!response.ok)
+        throw new Error(`The brief answered ${response.status}`);
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of response.body ?? []) {
+        size += chunk.byteLength;
+        if (size > MAX_BRIEF_BYTES) {
+            stop.abort();
+            throw new Permanent(`The brief is larger than ${MAX_BRIEF_BYTES / 1024} KB`);
+        }
+        chunks.push(chunk);
+    }
+    return Uint8Array.from(Buffer.concat(chunks));
+}
+/** Reads a brief and checks it against the hash on chain. Briefs are base64 data URIs or https URLs. */
+export async function fetchBrief(uri, expected, fetcher = fetch) {
+    let bytes;
+    if (uri.startsWith("data:")) {
+        const comma = uri.indexOf(",");
+        if (comma < 0 || !uri.slice(0, comma).endsWith(";base64"))
+            throw new Permanent("The brief's data URI is not base64");
+        bytes = Uint8Array.from(Buffer.from(uri.slice(comma + 1), "base64"));
+    }
+    else if (uri.startsWith("https://")) {
+        bytes = await download(uri, fetcher);
+    }
+    else {
+        throw new Permanent("The brief is neither a data URI nor an https URL");
+    }
+    if (bytes.byteLength > MAX_BRIEF_BYTES)
+        throw new Permanent(`The brief is larger than ${MAX_BRIEF_BYTES / 1024} KB`);
+    if (keccak256(bytes).toLowerCase() !== expected.toLowerCase())
+        throw new Permanent("The brief does not match its hash on chain");
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new Permanent("The brief is not UTF-8 text");
+    }
+}

package/dist/index.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { join as joinPath } from "node:path";
+import { formatEther, formatUnits, parseUnits } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { ApplicationState, createChain, describe } from "./chain.js";
+import { resolveNetwork } from "./network.js";
+import { fileStore, lock, stateDir } from "./state.js";
+import { createWork, shellCommand } 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 <tUSDG>]
+                                            Stake the minimum and apply to take tasks.
+  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).
+  brainchain-worker status                  Stake, application, record and earnings.
+  brainchain-worker price <tUSDG>           Change your asking price per task.
+  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, and the only network open to outside workers today).
+  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.
+run keeps unfinished work in ~/.config/brainchain-worker/<address>.json across restarts, and one
+run at a time works for each address.
+
+Docs: https://docs.usebrainchain.com/run-a-worker`;
+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: {},
+};
+const POSITIONAL = { price: 1 };
+function parse(command, args) {
+    const known = FLAGS[command];
+    if (known === undefined)
+        throw new UsageError(`Unknown command "${command}". Run 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(`${command} has no --${name} flag. Run 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)}". Run brainchain-worker help.`);
+    return { positional, values, switches };
+}
+function signer() {
+    const raw = process.env.BRAINCHAIN_WORKER_KEY?.trim();
+    if (!raw)
+        throw new UsageError("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 UsageError("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 UsageError("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 stake = (network, amount) => `${formatUnits(amount, 18)} ${network.stakeSymbol}`;
+const usdg = (network, amount) => `${formatUnits(amount, 6)} ${network.bountySymbol}`;
+const when = (seconds) => new Date(Number(seconds) * 1000).toISOString().replace(".000Z", "Z");
+async function needGas(chain, network) {
+    if ((await chain.ethBalance()) > 0n)
+        return;
+    throw new UsageError(`${chain.account} has no ETH on ${network.name} for gas. Get Robinhood Chain testnet ETH from https://faucet.testnet.chain.robinhood.com ` +
+        `and bridge some at ${network.explorer}; 0.001 ETH is plenty.`);
+}
+/** Why the worker can or cannot be hired right now, in one line. */
+async function hireable(chain, network) {
+    const [allowed, w, min, { applications, change }] = await Promise.all([chain.allowed(), chain.stake(), chain.minStake(), chain.applications()]);
+    if (allowed)
+        return w.staked >= min ? "yes" : `no: your stake is below the minimum of ${stake(network, min)}. Run join to stake again.`;
+    // An allowed application waiting out its timelock outranks anything filed after it.
+    if (change && !change.executed && !change.vetoed)
+        return `no: Jev allowed this worker; it can be hired after ${when(change.eta)}`;
+    const last = applications.at(-1);
+    if (last === undefined)
+        return "no: run `npx brainchain-worker join` to apply";
+    if (last.state === ApplicationState.Open)
+        return `no: application ${last.id} is waiting for Jev`;
+    if (last.state === ApplicationState.Burned)
+        return `no: Jev did not allow application ${last.id}, and its bond was burned. Run join to apply again.`;
+    if (change?.vetoed) {
+        // A vetoed call can never be queued again, so the veto still stands for applications filed after it.
+        const vetoed = applications.find((a) => a.decisionId === change.decisionId);
+        return `no: the guardian vetoed ${vetoed ? `application ${vetoed.id}` : "allowing this worker"}`;
+    }
+    return `no: application ${last.id} closed without a decision; its bond was returned. Run join to apply again.`;
+}
+async function join(chain, network, values) {
+    const name = values.get("name")?.trim();
+    const about = values.get("about")?.trim() ?? "";
+    if (!name || name.length > 60)
+        throw new UsageError("--name is required, up to 60 characters");
+    if (!about || about.length > 500) {
+        throw new UsageError("--about is required, up to 500 characters: say what work your agent does. Jev reads it to decide, and refuses an empty application.");
+    }
+    const requested = values.has("price") ? price(values.get("price")) : undefined;
+    await needGas(chain, network);
+    const [allowed, w, min, { applications, change }] = await Promise.all([chain.allowed(), chain.stake(), chain.minStake(), chain.applications()]);
+    const pending = change !== undefined && !change.executed && !change.vetoed;
+    const open = applications.find((a) => a.state === ApplicationState.Open);
+    const applying = !allowed && !pending && open === undefined;
+    // A worker that has staked keeps its price unless --price changes it.
+    const asking = requested ?? (w.registered ? w.price : price(DEFAULT_PRICE));
+    // Below the minimum after leave or a slash, an allowed worker cannot be hired until it stakes again.
+    const toStake = w.staked >= min ? 0n : min - w.staked;
+    const [bond, balance] = await Promise.all([chain.bond(), chain.stakeBalance()]);
+    if (balance < toStake + (applying ? bond : 0n)) {
+        console.log(`Claiming ${network.stakeSymbol} from the testnet faucet...`);
+        await chain.claimStakeToken();
+    }
+    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 \`npx brainchain-worker run\`.`);
+        return;
+    }
+    if (pending) {
+        console.log(`Jev already allowed this worker. It can be hired after ${when(change.eta)}; keep \`npx brainchain-worker 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 2-hour timelock passes.\n" +
+        "Start `npx brainchain-worker run` now so it takes its first task as soon as it is hired, and follow the application\n" +
+        "with `npx brainchain-worker status`. New workers are offered house tasks first, which BrainChain pays for.");
+}
+async function status(chain, network) {
+    const [gas, w, min, held, record, balance, line] = await Promise.all([
+        chain.ethBalance(),
+        chain.stake(),
+        chain.minStake(),
+        chain.inFlight(),
+        chain.record(),
+        chain.bountyBalance(),
+        hireable(chain, network),
+    ]);
+    const unstaking = w.unstaking > 0n ? `, ${stake(network, w.unstaking)} unstaking until ${when(w.unlocksAt)}` : "";
+    console.log(`Worker ${chain.account} on ${network.name}
+  Hireable  ${line}
+  Stake     ${stake(network, w.staked)} (minimum ${stake(network, min)})${unstaking}
+  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, balance)}
+  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 file = joinPath(stateDir(), account.address);
+    lock(`${file}.lock`);
+    const store = fileStore(`${file}.json`, network.contracts.taskBoard);
+    const chain = createChain(network, account, store);
+    const log = (message) => console.log(`${new Date().toISOString().slice(11, 19)} ${message}`);
+    await needGas(chain, network).catch((error) => {
+        if (error instanceof UsageError)
+            throw error;
+        log(`could not read the wallet's ETH balance: ${describe(error)}`);
+    });
+    const command = shellCommand(exec);
+    let stopping = false;
+    const stop = (signal) => {
+        if (stopping) {
+            command.kill();
+            log(`${signal} again: stopped the command`);
+            process.exit(signal === "SIGINT" ? 130 : 143);
+        }
+        stopping = true;
+        log(`${signal}: stopping after the current task; send ${signal} again to stop now`);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    const work = createWork({
+        chain,
+        command,
+        format,
+        log,
+        timeoutMs: Number(minutes) * 60_000,
+        secrets: [key, key.slice(2)],
+        store,
+        stopping: () => stopping,
+    });
+    const line = await hireable(chain, network).catch((error) => `could not check (${describe(error)})`);
+    log(`worker ${chain.account} on ${network.name}; hireable: ${line}`);
+    if (once) {
+        const result = await work.round();
+        if (result.hired === 0)
+            log("no task is hired to this worker right now");
+        // A cron job sees a failed task as a failed run.
+        if (result.failed > 0)
+            process.exitCode = 1;
+        return;
+    }
+    log("waiting for tasks (Ctrl-C to stop)");
+    while (!stopping) {
+        await work.round().catch((error) => log(`round failed: ${describe(error)}`));
+        for (let i = 0; i < 15 && !stopping; i++)
+            await new Promise((resolve) => setTimeout(resolve, 1_000));
+    }
+}
+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);
+    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 <tUSDG>, such as price 0.25");
+            const asking = price(positional[0]);
+            if (!(await chain.stake()).registered)
+                throw new UsageError("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 UsageError(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.inFlight(), chain.now()]);
+            if (w.unstaking === 0n)
+                throw new UsageError("Nothing is unstaking. Run leave first.");
+            if (now < w.unlocksAt)
+                throw new UsageError(`${stake(network, w.unstaking)} unlocks at ${when(w.unlocksAt)}. Withdraw after that.`);
+            if (held > 0)
+                throw new UsageError(`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;
+        }
+    }
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof UsageError ? error.message : `brainchain-worker: ${describe(error)}`);
+    process.exit(1);
+});