brainchain-worker 0.18.4 → 0.19.0

package/README.md

@@ -15,7 +15,7 @@ Workers run on BrainChain testnet by default, where tasks pay in test USDG (tUSD
 
 ## Quick start
 
-You need Node.js 22 or later.
+You need Node.js 22 or later, on macOS or Linux. On Windows, run the worker inside [WSL](https://learn.microsoft.com/windows/wsl/install): `run` refuses on Windows itself, while every other command works there.
 
 ```sh
 npx brainchain-worker new-key            # prints BRAINCHAIN_WORKER_KEY=0x... and the address
@@ -53,7 +53,7 @@ Leave `run` going: it takes each task as soon as Jev hires the worker. In anothe
 
 ## Mainnet
 
-Set `BRAINCHAIN_NETWORK=mainnet` and the commands run on BrainChain mainnet, where the worker stakes BRAIN and earns USDG. Two work on testnet only: fast exits are off on mainnet, and appeals run on testnet.
+Set `BRAINCHAIN_NETWORK=mainnet` and the commands run on BrainChain mainnet, where the worker stakes BRAIN and earns USDG. One works on testnet only: fast exits are off on mainnet.
 
 ```sh
 export BRAINCHAIN_NETWORK=mainnet
@@ -114,7 +114,7 @@ BRAINCHAIN_NETWORK=mainnet npx brainchain-worker bond claim 12      # collect a
 ```
 
 - **Amount.** At least the task's bounty and at least 2 USDG, from the worker's wallet on Robinhood Chain, which also pays the gas: about 1.2M gas for the approval, the bond and the claim together. `bond` prints the fee, the gas in ETH and both outcomes before it asks.
-- **When.** After Jev hires this worker for the task, before the task's deadline, and never on a task the worker's own wallet posted or paid for. The bond's deadline is the task's plus 48 hours.
+- **When.** After Jev hires this worker for the task, before the task's deadline, and never on a task the worker's own wallet posted or paid for. The bond's deadline is the task's plus 72 hours.
 - **How it settles.** Shipped's on-chain check reads BrainChain's ProofIndex on Robinhood Chain: `proofOf(board, task)` is the Proof's token id once the task is paid and its Proof minted. BrainChain writes the index, marks the check and confirms it an hour later; `bond claim` then collects the bond less 1%. With no Proof by the deadline, the bond settles as missed 25 hours later. A bond on a task that was refunded can only be missed, and `bond status` says so.
 - **Mainnet only.** Testnet has no Shipped registry.
 
@@ -267,7 +267,7 @@ A transfer that was sent and not confirmed can still land, so `exit` names its t
 | `propose --target <contract> --call <function> --args <JSON> --title <text> --rationale <text> [--current <text>] [--proposed <text>] [--data <hex>] [--dry]` | Bond the stake token and propose a change for Jev to decide. See [Propose a change](#propose-a-change). |
 | `proposal <id>` | Where a proposal stands: waiting for Jev and until when, adopted and when its change runs, kept with the bond burned, or undecided with the bond returned. Needs no key, and does not read one that is set. |
 | `dispute <task>` | Dispute the grade on a task the worker delivered, inside the dispute window. Jev rules; a confident ruling decides, otherwise the grade stands. |
-| `appeal <task>` | Appeal a ruling that went against the worker, inside the appeal window, approving the bond (a quarter of the bounty) first. A wallet holding less tUSDG than the bond claims it from the test USDG faucet before that, which gives 100 tUSDG once a day. Jev rules again; the bond comes back unless Jev confidently rules the same way. Testnet only for now. |
+| `appeal <task>` | Appeal a ruling that went against the worker, inside the appeal window, approving the bond (a quarter of the bounty) first. On testnet, a wallet holding less tUSDG than the bond claims it from the test USDG faucet before that, which gives 100 tUSDG once a day. Jev rules again; the bond comes back unless Jev confidently rules the same way. |
 | `leave` | Start unstaking. The stake unlocks after 3 days, once no task of the worker's is in flight. |
 | `withdraw` | Withdraw the unlocked stake. |
 | `--version` | Print the version. |
@@ -289,7 +289,7 @@ A transfer that was sent and not confirmed can still land, so `exit` names its t
 
 - **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 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 with `npx brainchain-worker dispute <task>`; if it loses a dispute it opened, 20% of its stake is burned, stake still unstaking included. On testnet a ruling against the worker can be appealed once with `npx brainchain-worker appeal <task>`, for a bond of a quarter of the bounty: Jev rules again, and the bond comes back unless Jev confidently rules the same way. The stake is burned only if the final ruling goes against the worker.
+- **Stake.** The stake is held while the worker has a task in flight. A worker can dispute a grade with `npx brainchain-worker dispute <task>`; if it loses a dispute it opened, 20% of its stake is burned, stake still unstaking included. A ruling against the worker can be appealed once with `npx brainchain-worker appeal <task>`, for a bond of a quarter of the bounty: Jev rules again, and the bond comes back unless Jev confidently rules the same way. The stake is burned only if the final ruling goes against the worker.
 
 ## Links
 

package/dist/bond.js

@@ -31,8 +31,8 @@ export const Ruling = { None: 0, Accepted: 1, Rejected: 2, Partial: 3, Invalid:
 export const MISSED_TO = "the agent that paid BrainChain's desk for the task, or to the poster for a task posted on the board directly";
 const BPS = 10000n;
 const ZERO = "0x0000000000000000000000000000000000000000";
-/** The bond's deadline is the task's plus this: grading, the worker's day to mint and the check's hold all fit. */
-export const BOND_LEAD_SEC = 48n * 3600n;
+/** The bond's deadline is the task's plus this: 48 hours for a grade, a dispute and an appealed ruling on set 3.5.0, then the worker's day to mint. */
+export const BOND_LEAD_SEC = 72n * 3600n;
 /** A marked check is confirmed an hour later; a bond with no Proof can be settled a day after that. */
 export const CHECK_HOLD_SEC = 3600n;
 export const CHECK_CONFIRM_SEC = 86400n;
@@ -113,8 +113,8 @@ export function createBondChain(network, config, account, fetcher = fetch) {
     }
     return {
         account: account.address,
-        async task(id) {
-            const t = await brainchain.readContract({ address: network.contracts.taskBoard, abi: taskBoardAbi, functionName: "get", args: [id] });
+        async task(id, board = network.contracts.taskBoard) {
+            const t = await brainchain.readContract({ address: board, abi: taskBoardAbi, functionName: "get", args: [id] });
             return t.status === 0 ? undefined : { poster: t.poster, bounty: t.bounty, deadline: t.deadline, status: t.status, model: t.model };
         },
         now: async () => (await client.getBlock()).timestamp,
@@ -150,12 +150,15 @@ export function createBondChain(network, config, account, fetcher = fetch) {
             const deeds = await client.multicall({ contracts: mine.map((id) => ({ ...registry, functionName: "getDeed", args: [id] })), allowFailure: false });
             return mine.flatMap((deed, i) => {
                 const d = deeds[i];
-                if (d.terms.check.toLowerCase() !== config.check.toLowerCase() || taskOfCheck(d.terms.checkData, config.proofIndex, network.contracts.taskBoard) !== task)
+                if (d.terms.check.toLowerCase() !== config.check.toLowerCase())
                     return [];
-                return [{ deed, task, amount: d.balance, deadline: d.terms.deadline, status: d.status, ruling: d.ruling, remainderBps: d.remainderBps, checkMetAt: d.checkMetAt, settledAt: d.settledAt, refundTo: d.terms.refundTo }];
+                const board = [network.contracts.taskBoard, ...(network.retired ?? []).map((r) => r.taskBoard)].find((b) => taskOfCheck(d.terms.checkData, config.proofIndex, b) === task);
+                if (!board)
+                    return [];
+                return [{ deed, task, board, amount: d.balance, deadline: d.terms.deadline, status: d.status, ruling: d.ruling, remainderBps: d.remainderBps, checkMetAt: d.checkMetAt, settledAt: d.settledAt, refundTo: d.terms.refundTo }];
             });
         },
-        proofOf: (task) => client.readContract({ address: config.proofIndex, abi: proofIndexAbi, functionName: "proofOf", args: [network.contracts.taskBoard, task] }),
+        proofOf: (task, board = network.contracts.taskBoard) => client.readContract({ address: config.proofIndex, abi: proofIndexAbi, functionName: "proofOf", args: [board, task] }),
         async payerOf(task) {
             const host = new URL(network.service).host;
             const response = await fetcher(`${network.service}/bonds/refund-to/${task}`, { signal: AbortSignal.timeout(15_000) }).catch(() => {
@@ -260,7 +263,8 @@ export async function bond(network, config, chain, task, options) {
         throw new Error(`The bond must be at least the task's bounty, ${usdg(network, t.bounty)}; ${usdg(network, options.amount)} is under it.`);
     if (options.amount < MIN_BOND)
         throw new Error(`The bond must be at least ${usdg(network, MIN_BOND)}: under that, Shipped's fee and the gas take too much of it.`);
-    const existing = (await chain.bondsOn(task)).find((b) => b.status !== DeedStatus.Settled);
+    // Task ids restart with each board, so a bond on a retired board's task of this number is another task's.
+    const existing = (await chain.bondsOn(task)).find((b) => b.status !== DeedStatus.Settled && b.board.toLowerCase() === network.contracts.taskBoard.toLowerCase());
     if (existing) {
         const page = await deedPage(existing.deed, options.fetch);
         throw new Error(`This worker already has ${page ? `bond No. ${page.number}` : "a bond"} open on task ${task} (registry id ${existing.deed}${page ? `, ${page.url}` : ""}). \`bond status ${task}\` shows where it stands.`);
@@ -311,18 +315,18 @@ export async function bondStatus(network, config, chain, task, log, fetchImpl =
     if (bonds.length === 0)
         return log(`${chain.account} has no bond on task ${task}.`);
     const delivered = bonds.some((b) => b.status === DeedStatus.Settled && b.remainderBps === Number(BPS));
-    // Only a bond still waiting for its Proof is worded by where the task stands.
-    const waiting = bonds.some((b) => b.status !== DeedStatus.Settled && b.checkMetAt === 0n);
-    const [now, indexed, t, owed, pages] = await Promise.all([
+    const [now, indexed, tasks, owed, pages] = await Promise.all([
         chain.now(),
-        chain.proofOf(task),
-        waiting ? chain.task(task) : undefined,
+        Promise.all(bonds.map((b) => chain.proofOf(task, b.board))),
+        // Only a bond still waiting for its Proof is worded by where the task stands.
+        Promise.all(bonds.map((b) => (b.status !== DeedStatus.Settled && b.checkMetAt === 0n ? chain.task(task, b.board) : undefined))),
         delivered ? chain.owed() : 0n,
         Promise.all(bonds.map((b) => deedPage(b.deed, fetchImpl))),
     ]);
     bonds.forEach((b, i) => {
         const page = pages[i];
-        log(`${bondLine(network, b, { indexed: indexed > 0n, now, page, owed, taskStatus: t?.status })}${page ? ` ${page.url}` : ""}`);
+        const old = network.retired?.find((r) => r.taskBoard.toLowerCase() === b.board.toLowerCase());
+        log(`${bondLine(network, b, { indexed: indexed[i] > 0n, now, page, owed, taskStatus: tasks[i]?.status })}${old ? ` (task of set ${old.release})` : ""}${page ? ` ${page.url}` : ""}`);
     });
 }
 /** Collects what a settled bond left the worker: withdraw(USDG) on the registry. */
@@ -335,7 +339,7 @@ export async function bondClaim(network, config, chain, task, log, fetchImpl = f
         throw new Error(`${chain.account} has no bond on task ${task}.`);
     const page = await deedPage(latest.deed, fetchImpl);
     if (latest.status !== DeedStatus.Settled) {
-        const [now, indexed, t] = await Promise.all([chain.now(), chain.proofOf(task), chain.task(task)]);
+        const [now, indexed, t] = await Promise.all([chain.now(), chain.proofOf(task, latest.board), chain.task(task, latest.board)]);
         throw new Error(`${bondLine(network, latest, { indexed: indexed > 0n, now, page, taskStatus: t?.status })}. Nothing can be claimed before it settles.`);
     }
     const owed = await chain.owed();

package/dist/chain.js

@@ -438,8 +438,14 @@ export function createChain(network, account, store = memoryStore()) {
         },
         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" }),
+        requestUnstake: (amount, at = staking) => send({ address: at, abi: workerStakingAbi, functionName: "requestUnstake", args: [amount] }),
+        withdraw: (at = staking) => send({ address: at, abi: workerStakingAbi, functionName: "withdraw" }),
+        /** Stake left on earlier sets' contracts, which this set's reads do not see. */
+        async retiredStakes() {
+            const sets = network.retired ?? [];
+            const stakes = await Promise.all(sets.map((s) => client.readContract({ address: s.staking, abi: workerStakingAbi, functionName: "get", args: [account.address] })));
+            return sets.flatMap((s, i) => (stakes[i].staked > 0n || stakes[i].unstaking > 0n ? [{ ...s, w: stakes[i] }] : []));
+        },
         /**
          * Whether this wallet owns the ERC-8004 agent `agentId` on the parent chain or is
          * its registered wallet; undefined when the registry could not be read.

package/dist/cli.js

@@ -137,9 +137,9 @@ const COMMAND_USAGE = {
                                             window. Jev rules on it; a confident ruling decides.`,
     appeal: `  brainchain-worker appeal <task>           Appeal the ruling on a task, when it went against the worker, within the
                                             appeal window, with the bond the task's terms fix (a quarter of the
-                                            bounty), claimed from the test USDG faucet when the wallet holds less.
-                                            Jev rules again; the bond comes back unless Jev confidently rules the
-                                            same way. Testnet only for now.`,
+                                            bounty); on testnet it is claimed from the test USDG faucet when the
+                                            wallet holds less. Jev rules again; the bond comes back unless Jev
+                                            confidently rules the same way.`,
     leave: `  brainchain-worker leave                   Start unstaking (3-day cooldown).`,
     withdraw: `  brainchain-worker withdraw                Withdraw stake once the cooldown has passed.`,
 };
@@ -404,7 +404,7 @@ export async function join(chain, network, values) {
         "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, gasPrice, sent, s, held, record, bountyBalance, stakeBalance, bond, faucet, now] = await Promise.all([
+    const [gas, gasPrice, sent, s, held, record, bountyBalance, stakeBalance, bond, faucet, now, oldStakes] = await Promise.all([
         chain.ethBalance(),
         chain.gasPrice(),
         chain.sent(),
@@ -417,12 +417,13 @@ async function status(chain, network) {
         // 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(),
+        chain.retiredStakes(),
     ]);
     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}
+  Stake     ${stake(network, w.staked)} (minimum ${stake(network, min)})${unstaking}${oldStakes.map((o) => `\n  Old stake ${stake(network, o.w.staked + o.w.unstaking)} on set ${o.release}, which does not count here; leave and withdraw collect it`).join("")}
   Wallet    ${wallet(network, s, stakeBalance, bond, faucet, now)}
   Price     ${w.registered ? `${usdg(network, w.price)} per task` : "not set until you join"}
   Record    ${record.paid} paid, ${record.refunded} refunded, ${record.inFlight.length} in flight${held > 0 ? " (stake held until they settle)" : ""}${record.inFlight.map((f) => `\n            ${flightLine(f)}`).join("")}
@@ -622,6 +623,12 @@ export function watching(network, address, veto) {
         return `watching ${network.name} (read-only, no key)`;
     return `watching ${network.name} as ${address}${veto ? ", vetoing through the guardian gate" : ""}, reporting rounds to the service`;
 }
+/** `run` starts the worker's command in its own process group, which Windows does not have, and loses its output there. */
+export function requirePosix(platform) {
+    if (platform === "win32") {
+        throw new Error("run works on macOS and Linux. On Windows, run the worker inside WSL: https://learn.microsoft.com/windows/wsl/install. Every other command works on Windows as it is.");
+    }
+}
 export async function main(argv) {
     const [command, ...rest] = argv;
     if (command === undefined || command === "help" || command === "--help" || command === "-h") {
@@ -649,6 +656,8 @@ export async function main(argv) {
         return;
     }
     const { positional, values, switches } = parse(command, rest);
+    if (command === "run")
+        requirePosix(process.platform);
     const network = resolveNetwork(process.env);
     if (process.env.BRAINCHAIN_RPC_URL?.trim()) {
         await requireChainId(network, () => createPublicClient({ transport: http(network.rpc, { timeout: 10_000, retryCount: 0 }) }).getChainId());
@@ -823,6 +832,12 @@ export async function main(argv) {
         case "leave": {
             const w = await chain.stake();
             if (w.staked === 0n) {
+                const old = (await chain.retiredStakes()).find((o) => o.w.staked > 0n);
+                if (old) {
+                    await needGas(chain, network);
+                    await chain.requestUnstake(old.w.staked, old.staking);
+                    return console.log(`Unstaking ${stake(network, old.w.staked)} from set ${old.release}. Run \`npx brainchain-worker withdraw\` once its cooldown has passed and no task of the worker's on that set is in flight.`);
+                }
                 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);
@@ -833,8 +848,16 @@ export async function main(argv) {
         }
         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 (w.unstaking === 0n) {
+                const old = (await chain.retiredStakes()).find((o) => o.w.unstaking > 0n);
+                if (!old)
+                    throw new Error("Nothing is unstaking. Run leave first.");
+                if (now < old.w.unlocksAt)
+                    throw new Error(`${stake(network, old.w.unstaking)} on set ${old.release} unlocks at ${when(old.w.unlocksAt)}. Withdraw after that.`);
+                await needGas(chain, network);
+                await chain.withdraw(old.staking);
+                return console.log(`Withdrew ${stake(network, old.w.unstaking)} from set ${old.release}.`);
+            }
             if (now < w.unlocksAt)
                 throw new Error(`${stake(network, w.unstaking)} unlocks at ${when(w.unlocksAt)}. Withdraw after that.`);
             if (held > 0)

package/dist/mint.js

@@ -23,8 +23,8 @@ export const wethAbi = parseAbi([
 export const MAX_MINT = 10;
 /** How often a delivered task's status is read until it settles. */
 const STATUS_SEC = 300;
-/** Each step from grading to a ruling on appeal has a window of at most 6 hours, so a task unsettled two days after delivery is left. */
-const WATCH_SEC = 2 * 86_400;
+/** Grading, a dispute, its ruling, the appeal window and the ruling on appeal take up to 48 hours on set 3.5.0, so a task unsettled three days after delivery is left. */
+const WATCH_SEC = 3 * 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. */
@@ -93,7 +93,8 @@ export async function pendingTasks(network, worker, fetcher = fetch) {
     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));
+    // Task ids restart with each board and the list spans them, so a repeated id is another task.
+    return tasks.map((id) => BigInt(id));
 }
 const proofCount = (n) => `${n} Proof${n === 1 ? "" : "s"}`;
 /** "task 12", "tasks 12 and 15", "tasks 12, 15 and 18". */
@@ -218,7 +219,7 @@ export function createSettlementWatch(options) {
         }
         if (outcome === undefined) {
             if (clock() - entry.deliveredAt >= WATCH_SEC)
-                drop(key, "not settled two days after delivery, so the worker stops watching it");
+                drop(key, "not settled three days after delivery, so the worker stops watching it");
             else
                 later(entry, STATUS_SEC);
             return false;

package/dist/network.js

@@ -50,20 +50,20 @@ export const TESTNET = {
         bountyToken: "0xC4ec72794bF3Ce9ba1DE4B38085464c2eb0cDCf2",
     },
 };
-// The 3.3.0 set. Its DecisionExecutor is new too, and applications are read from its events.
-export const MAINNET_TASK_BOARD = "0x8385bb4b8990411CcdD8e851B2676da1A4C1f3C4";
-export const MAINNET_WORKER_STAKING = "0x21Fe66c04da07f85D855E9920251Df7d584c3D9F";
-export const MAINNET_PROPOSAL_BONDS = "0x1129435A110AB3Ffd3fFEE345A48f648DdE3D52c";
-export const MAINNET_DECISION_EXECUTOR = "0x98BEA2E455539dB38b7337d81C673326128EA17F";
+// The 3.5.0 set. Its DecisionExecutor is new too, and applications are read from its events.
+export const MAINNET_TASK_BOARD = "0x44b8464342Bbfb9B565FAE494DfDefa37D33A211";
+export const MAINNET_WORKER_STAKING = "0xa4351E2b84eb634E93D9082907B2d0D3Aa91B98F";
+export const MAINNET_PROPOSAL_BONDS = "0x33260Cd6b4F368031F5AF2B5413d0CE6bb2aFAA4";
+export const MAINNET_DECISION_EXECUTOR = "0xFD268Ae2c1Ec0Db03C3C6b17E1AEDE973729FE29";
 const BRAIN = "0x3367085Eb6C79BfB0fCa4f1433ec77bFA8CB8a37";
-/** BrainChain mainnet, release 3.4.0. */
+/** BrainChain mainnet, release 3.5.0. */
 export const MAINNET = {
     id: "mainnet",
     name: "BrainChain",
     chainId: 274663,
     rpc: "https://rpc.usebrainchain.com",
     service: "https://brain.usebrainchain.com",
-    fromBlock: 839n,
+    fromBlock: 965n,
     explorer: "https://usebrainchain.com",
     stakeSymbol: "BRAIN",
     bountySymbol: "USDG",
@@ -99,14 +99,18 @@ export const MAINNET = {
         tokens: { stake: "0xC80333bf7f4078e14Ce5b6e223aF607aDcA44418", bounty: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168" },
     },
     exitDesk: "0xafB0C4Ef895D4895040cdC6435B96D3EE8350c6E",
+    retired: [
+        { release: "3.4.0", taskBoard: "0x8385bb4b8990411CcdD8e851B2676da1A4C1f3C4", staking: "0x21Fe66c04da07f85D855E9920251Df7d584c3D9F" },
+        { release: "3.3.0", taskBoard: "0x72C890AA996bF7efcA88e3F5063B626560215160", staking: "0x0fb02559e704549794EdF3FBBBe91DB88bB849ee" },
+    ],
     contracts: {
         taskBoard: MAINNET_TASK_BOARD,
         staking: MAINNET_WORKER_STAKING,
         bonds: MAINNET_PROPOSAL_BONDS,
         executor: MAINNET_DECISION_EXECUTOR,
-        registry: "0x870B0BFB24aF2C06180FbEe266117305e0B0E00F",
-        log: "0xFdFEDb376c9632A4D6F15a1697E2b6853f12B4d7",
-        gate: "0x48c2Ed99Dc786ba667eFcFF721ff4cA92a1f344A",
+        registry: "0xA7f8A21Cc9574DB049F525a4fd499DA49c0D51ed",
+        log: "0x2EF509bd9cA1e7C5FBe2C2FD7Ff25cE9F6f9cB68",
+        gate: "0x71B2dc3dEC1aEB000936380981DfC51E47AA4fb8",
         stakeToken: BRAIN,
         bountyToken: "0x8eBFEce96c0AeF7Fd23425D846a302a552c8c451",
     },

package/dist/state.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, readlinkSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { copyFileSync, closeSync, fsyncSync, mkdirSync, openSync, readFileSync, readlinkSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import { dirname, join } from "node:path";
 import { startTime } from "./proc.js";
@@ -82,6 +82,19 @@ export function fileStore(file, board, warn = console.warn) {
     const saved = text === undefined ? undefined : parse(text);
     if (saved?.board === state.board)
         state = saved;
+    else if (saved) {
+        // Task ids restart with each board, so none of this can carry over, but it must not vanish in silence.
+        const left = [
+            [Object.keys(saved.tasks).length, "tasks with results"],
+            [saved.hired?.tasks.length ?? 0, "hired tasks"],
+            [Object.keys(saved.proofs ?? {}).length, "tasks waiting to settle or mint"],
+        ].flatMap(([count, what]) => (count ? [`${count} ${what}`] : []));
+        if (left.length > 0) {
+            const aside = `${file}.${saved.board}`;
+            copyFileSync(file, aside);
+            warn(`${file} holds work for the task board ${saved.board}, not this one: ${left.join(", ")}. This run starts without it, and a copy is at ${aside}.`);
+        }
+    }
     if (text !== undefined && saved === undefined) {
         // Refusing to start would turn one bad file into a crash loop under a supervisor.
         const aside = `${file}.corrupt-${new Date().toISOString().replace(/\.\d+Z$/, "Z").replace(/[-:]/g, "")}`;

package/package.json

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