brainchain-worker 0.0.0-stage → 0.1.0

package/dist/chain.js

@@ -0,0 +1,200 @@
+import { createPublicClient, createWalletClient, encodeFunctionData, http, keccak256, parseAbi, toBytes, } from "viem";
+import { taskBoardAbi, workerStakingAbi } from "./abi.js";
+import { chainOf } from "./network.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)",
+    "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)",
+]);
+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;
+/** What the worker signs to upload a result: the task and the hash of exactly the bytes it uploads. */
+export function resultMessage(task, hash) {
+    return `BrainChain result\ntask ${task}\nhash ${hash}`;
+}
+/** 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] });
+}
+export function createChain(network, account) {
+    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 };
+    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 up to `latest`, in windows the RPC accepts. */
+    async function scan(fetch, upTo) {
+        const latest = upTo ?? (await client.getBlockNumber());
+        const all = [];
+        for (let from = network.fromBlock; from <= latest; from += LOG_RANGE) {
+            const to = from + LOG_RANGE - 1n < latest ? from + LOG_RANGE - 1n : latest;
+            all.push(...(await fetch(from, to)));
+        }
+        return all;
+    }
+    const hiredIds = () => scan((fromBlock, toBlock) => client.getContractEvents({ ...board, eventName: "WorkerHired", args: { model: id }, fromBlock, toBlock })).then((logs) => logs.map((log) => log.args.id));
+    const briefs = new Map();
+    async function briefURI(task) {
+        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 }));
+        if (posted === undefined)
+            throw new Error(`Task ${task} has no Posted event`);
+        briefs.set(task, posted.args.briefURI);
+        return posted.args.briefURI;
+    }
+    const settled = new Set();
+    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 ids = (await hiredIds()).filter((t) => !settled.has(t));
+            const tasks = [];
+            for (const task of ids) {
+                const t = await client.readContract({ ...board, functionName: "get", args: [task] });
+                if (t.status !== Status.Hired || t.model.toLowerCase() !== id) {
+                    if (t.status >= Status.Paid)
+                        settled.add(task);
+                    continue;
+                }
+                tasks.push({ id: task, deadline: t.deadline, briefURI: await briefURI(task), briefHash: t.briefHash });
+            }
+            return tasks;
+        },
+        async publish(task, text) {
+            const hash = keccak256(toBytes(text));
+            const signature = await account.signMessage({ message: resultMessage(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),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok || !body.uri)
+                throw new Error(`Uploading the result failed (${response.status}): ${body.error ?? "no reason given"}`);
+            if (body.hash?.toLowerCase() !== hash.toLowerCase())
+                throw new Error("The service stored different bytes than were sent");
+            return { uri: body.uri, hash };
+        },
+        submit: (task, resultHash, resultURI) => send({ ...board, functionName: "submit", args: [task, resultHash, resultURI] }),
+    };
+    return {
+        ...work,
+        account: account.address,
+        id,
+        client,
+        send,
+        ethBalance: () => client.getBalance({ address: account.address }),
+        balance: (token) => client.readContract({ address: token, abi: erc20Abi, functionName: "balanceOf", args: [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 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, queued] = await Promise.all([
+                scan((fromBlock, toBlock) => client.getContractEvents({ address: bonds, abi: bondsAbi, eventName: "Proposed", args: { proposer: account.address, target: taskBoard }, fromBlock, toBlock }), blockNumber),
+                scan((fromBlock, toBlock) => client.getContractEvents({ address: executor, abi: executorAbi, eventName: "Queued", args: { target: taskBoard }, fromBlock, toBlock }), 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 }) : undefined;
+            const applications = await Promise.all(proposed
+                .filter((log) => log.args.data.toLowerCase() === data)
+                .map(async (log) => ({ id: log.args.id, state: (await client.readContract({ address: bonds, abi: bondsAbi, functionName: "get", args: [log.args.id], blockNumber })).state })));
+            return { applications, change };
+        },
+        /** Tasks this worker was hired for, by outcome, and what it was paid after fees. */
+        async record() {
+            const ids = [...new Set(await hiredIds())];
+            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 }));
+            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),
+            };
+        },
+    };
+}
+/** 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) {
+    const MAX = 256 * 1024;
+    let bytes;
+    if (uri.startsWith("data:")) {
+        const comma = uri.indexOf(",");
+        if (comma < 0 || !uri.slice(0, comma).endsWith(";base64"))
+            throw new Error("The brief's data URI is not base64");
+        bytes = Uint8Array.from(Buffer.from(uri.slice(comma + 1), "base64"));
+    }
+    else if (uri.startsWith("https://")) {
+        const response = await fetcher(uri, { redirect: "error", signal: AbortSignal.timeout(15_000) });
+        if (!response.ok)
+            throw new Error(`The brief answered ${response.status}`);
+        bytes = new Uint8Array(await response.arrayBuffer());
+    }
+    else {
+        throw new Error("The brief is neither a data URI nor an https URL");
+    }
+    if (bytes.byteLength > MAX)
+        throw new Error("The brief is too large");
+    if (keccak256(bytes).toLowerCase() !== expected.toLowerCase())
+        throw new Error("The brief does not match its hash on chain");
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}

package/dist/index.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { BaseError, formatEther, formatUnits, HttpRequestError, parseUnits } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { ApplicationState, createChain } from "./chain.js";
+import { resolveNetwork } from "./network.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] [--once]
+                                            Do every task Jev hires you for: the command reads the
+                                            task on stdin and prints the deliverable on stdout.
+  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.
+
+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.
+
+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, 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 account() {
+    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");
+    try {
+        return privateKeyToAccount(`0x${hex}`);
+    }
+    catch {
+        throw new UsageError("BRAINCHAIN_WORKER_KEY is not a valid private key. `npx brainchain-worker new-key` makes one.");
+    }
+}
+/** 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)
+        return `no: the guardian vetoed application ${last.id}`;
+    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 asking = price(values.get("price") ?? "0.20");
+    await needGas(chain, network);
+    if (await chain.allowed()) {
+        console.log("This worker can already be hired. Start it with `npx brainchain-worker run`.");
+        return;
+    }
+    const { applications, change } = await chain.applications();
+    if (change && !change.executed && !change.vetoed) {
+        console.log(`Jev already allowed this worker. It can be hired after ${when(change.eta)}; keep \`npx brainchain-worker run\` going until then.`);
+        return;
+    }
+    const open = applications.find((a) => a.state === ApplicationState.Open);
+    const [w, min, bond, balance] = await Promise.all([chain.stake(), chain.minStake(), chain.bond(), chain.stakeBalance()]);
+    const toStake = w.staked >= min ? 0n : min - w.staked;
+    const needed = toStake + (open ? 0n : bond);
+    if (balance < needed) {
+        console.log(`Claiming ${network.stakeSymbol} from the testnet faucet...`);
+        await chain.claimStakeToken();
+    }
+    if (toStake > 0n) {
+        console.log(`Staking ${stake(network, toStake)} 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 (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(chain, network, 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 log = (message) => console.log(`${new Date().toISOString().slice(11, 19)} ${message}`);
+    const work = createWork({ chain, command: shellCommand(exec), format, log });
+    log(`worker ${chain.account} on ${network.name}; hireable: ${await hireable(chain, network)}`);
+    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;
+    }
+    let stopping = false;
+    process.once("SIGINT", () => {
+        stopping = true;
+        log("stopping after the current task");
+    });
+    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 chain = createChain(network, account());
+    switch (command) {
+        case "join":
+            return join(chain, network, values);
+        case "status":
+            return status(chain, network);
+        case "run":
+            return run(chain, network, values, switches.has("once"));
+        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;
+        }
+    }
+}
+/** One readable line for an error, with the cause viem keeps apart from its summary. */
+function describe(error) {
+    if (error instanceof HttpRequestError)
+        return `Could not reach ${error.url}${error.details ? ` (${error.details})` : ""}`;
+    if (error instanceof BaseError)
+        return error.shortMessage;
+    return error instanceof Error ? error.message : String(error);
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof UsageError ? error.message : `brainchain-worker: ${describe(error)}`);
+    process.exit(1);
+});

package/dist/network.js

@@ -0,0 +1,40 @@
+import { defineChain } from "viem";
+/** BrainChain testnet, release 3.1.0. Mainnet has no open staking yet. */
+export const TESTNET = {
+    name: "BrainChain testnet",
+    chainId: 274630,
+    rpc: "https://rpc.testnet.usebrainchain.com",
+    service: "https://brain.testnet.usebrainchain.com",
+    fromBlock: 898n,
+    explorer: "https://usebrainchain.com/testnet",
+    stakeSymbol: "tBRAIN",
+    bountySymbol: "tUSDG",
+    contracts: {
+        taskBoard: "0xC74564F100e70F95346A6e399ebf1Ce14309C8B6",
+        staking: "0xbdC08799D865DA79FE44a469de1FeaE84bb45059",
+        bonds: "0x574060D1A7CA8f3786d2D14fe1A782cc4638CB1e",
+        executor: "0x420484B139001ED5B1DA330e689Cc2f4814001Fb",
+        stakeToken: "0xc717546497343911750768335b649b86d0a6eCcf",
+        bountyToken: "0xC4ec72794bF3Ce9ba1DE4B38085464c2eb0cDCf2",
+    },
+};
+export function resolveNetwork(env) {
+    const name = (env.BRAINCHAIN_NETWORK?.trim() || "testnet").toLowerCase();
+    if (name === "mainnet")
+        throw new Error("Outside workers run on BrainChain testnet for now. Unset BRAINCHAIN_NETWORK or set it to testnet.");
+    if (name !== "testnet")
+        throw new Error(`BRAINCHAIN_NETWORK must be testnet, not "${env.BRAINCHAIN_NETWORK}"`);
+    return {
+        ...TESTNET,
+        ...(env.BRAINCHAIN_RPC_URL ? { rpc: env.BRAINCHAIN_RPC_URL } : {}),
+        ...(env.BRAINCHAIN_SERVICE_URL ? { service: env.BRAINCHAIN_SERVICE_URL.replace(/\/$/, "") } : {}),
+    };
+}
+export function chainOf(network) {
+    return defineChain({
+        id: network.chainId,
+        name: network.name,
+        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: [network.rpc] } },
+    });
+}