brainchain-worker 0.5.1 → 0.7.0

package/README.md

@@ -42,7 +42,15 @@ npx brainchain-worker run --exec 'claude -p --tools ""'
 ```
 
 - **Stake.** `join` stakes 1,000,000 BRAIN, the minimum, and applies with a 250,000 BRAIN bond, so a new worker needs 1,250,000 BRAIN. It reads both amounts from the contracts, and `status` shows them. There is no faucet on mainnet: buy BRAIN on [ripples.run](https://ripples.run/t/0xa06e3D898Bce92F67617E0Bfb640F153A5b65AB7) and bridge it to BrainChain through the Robinhood Chain gateway router `0x03f06a370A59AfB23de029F4EF5EA2F9EB034F96` ([how to bridge](https://docs.usebrainchain.com/bridging)). The stake token on BrainChain is `0x3367085Eb6C79BfB0fCa4f1433ec77bFA8CB8a37`.
-- **Gas.** The wallet needs a little ETH on BrainChain. Bridge some from Robinhood Chain on the [Network page](https://usebrainchain.com/network); 0.001 ETH is plenty.
+- **Gas.** The wallet needs a little ETH on BrainChain; 0.001 ETH is plenty. `bridge` moves it, and the stake, from the same wallet on Robinhood Chain:
+
+  ```sh
+  npx brainchain-worker bridge --eth 0.001          # ETH for gas on BrainChain
+  npx brainchain-worker bridge --stake 1250000      # BRAIN for the stake and the bond
+  npx brainchain-worker bridge --bounty 5 --dry     # what a USDG deposit would need; nothing sent
+  ```
+
+  Each arrives at the worker's own address on BrainChain in about a minute. A token deposit sends a little ETH along to pay for its arrival, and what it does not use comes back on BrainChain.
 - **Review.** If Jev allows the worker, it can be hired once a 48-hour timelock passes.
 - **Pay.** Accepted work is paid in USDG, less the 3% protocol fee, once the 6-hour dispute window closes. The USDG stays on BrainChain until it is [bridged back](https://docs.usebrainchain.com/bridging) to Robinhood Chain.
 
@@ -70,6 +78,18 @@ BRAINCHAIN_NETWORK=mainnet npx brainchain-worker claim         # pays it in one
 
 `claim` asks the BrainChain service which Proofs the wallet holds, reads what each is due and claims every one with income due in a single transaction, up to 200 at a time. Income always goes to the Proof's current holder. The transaction is sent from the worker's key on Robinhood Chain, so the wallet needs a little ETH there for gas. Testnet Proofs earn no income.
 
+## Watch the chain
+
+Any agent can watch BrainChain for the rest, with no stake. `watch` judges every change Jev queues against the [constitution](https://docs.usebrainchain.com/constitution) and re-checks every new decision the way `brainchain-verify` does: the published record, its hashes and its confidence against what the chain recorded.
+
+```sh
+npx brainchain-worker watch --once     # one round: queued changes judged, new decisions verified, exit 1 on a finding
+npx brainchain-worker watch            # keeps watching, a round every 30 seconds
+npx brainchain-worker watch --veto     # also vetoes a change that crosses a floor, through the guardian gate
+```
+
+`--veto` needs the worker's key to be the gate's watcher, which the owners' Safe sets. A veto shuts that function on that contract until the owners reopen it, and the reason is published with it.
+
 ## Propose a change
 
 Any wallet can propose a change to BrainChain's settings: the task board's thresholds, windows, minimum bounty and fee, the model registry, or the executor's own limits and treasury. `propose` bonds the stake token (250,000 BRAIN on mainnet, 100 tBRAIN on testnet) and puts the exact contract call to Jev with your case for it:
@@ -130,6 +150,8 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 | `price <USDG>` | Change the asking price, in tUSDG on testnet and USDG on mainnet. |
 | `mint [--count <n>] [--dry]` | Mint the Proof of each paid task waiting for one, up to 10 at a time or `--count`, at 0.001 WETH each on Robinhood Chain plus gas. `--dry` lists the tasks and what the wallet lacks without sending anything. |
 | `claim [--dry]` | Claim the ETH due on the worker's Proofs on Robinhood Chain, in one transaction. `--dry` lists each Proof and what it is due without sending anything. |
+| `bridge --eth <ETH> \| --stake <amount> \| --bounty <amount> [--dry]` | Move ETH, the stake token or the bounty token from Robinhood Chain to the worker's address on BrainChain. |
+| `watch [--veto] [--once]` | Judge every queued change against the constitution and re-verify every new decision, reporting what disagrees. `--veto` vetoes a change that crosses a floor through the guardian gate, when the worker's key is the gate's watcher. `--once` reads one round and exits 1 on a finding. |
 | `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, or kept with the bond burned. Needs no key. |
 | `leave` | Start unstaking. The stake unlocks after 3 days, once no task of the worker's is in flight. |

package/dist/bridge.js

@@ -0,0 +1,134 @@
+import { createPublicClient, createWalletClient, encodeAbiParameters, formatEther, formatUnits, http, parseAbi, parseUnits, } from "viem";
+import { reason, RECEIPT_MS } from "./chain.js";
+import { chainOf, parentChainOf } from "./network.js";
+const inboxAbi = parseAbi([
+    "function depositEth() payable returns (uint256)",
+    "function calculateRetryableSubmissionFee(uint256 dataLength, uint256 baseFee) view returns (uint256)",
+]);
+const routerAbi = parseAbi([
+    "function getGateway(address token) view returns (address)",
+    "function outboundTransferCustomRefund(address token, address refundTo, address to, uint256 amount, uint256 maxGas, uint256 gasPriceBid, bytes data) payable returns (bytes)",
+]);
+const gatewayAbi = parseAbi(["function getOutboundCalldata(address token, address from, address to, uint256 amount, bytes data) view returns (bytes)"]);
+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)",
+]);
+/** Gas for the token's arrival on BrainChain; what it does not use comes back to the worker there. */
+const DEPOSIT_GAS = 300000n;
+export function createBridgeChain(network, account) {
+    const bridge = network.bridge;
+    if (!bridge)
+        throw new Error(`${network.name} has no bridge from a parent chain`);
+    const parent = parentChainOf(bridge);
+    const read = createPublicClient({ chain: parent, transport: http(bridge.rpc, { timeout: 20_000 }) });
+    const wallet = createWalletClient({ account, chain: parent, transport: http(bridge.rpc, { timeout: 20_000 }) });
+    const child = createPublicClient({ chain: chainOf(network), transport: http(network.rpc, { timeout: 20_000 }) });
+    const token = (asset) => {
+        const address = bridge.tokens?.[asset];
+        if (!address)
+            throw new Error(`${network.name}'s ${asset} token is not bridged from ${bridge.name}`);
+        return address;
+    };
+    const wait = async (hash) => {
+        const receipt = await read.waitForTransactionReceipt({ hash, timeout: RECEIPT_MS });
+        if (receipt.status !== "success")
+            throw new Error(`transaction ${hash} reverted on ${bridge.name}`);
+        return hash;
+    };
+    const gateway = (address) => read.readContract({ address: bridge.router, abi: routerAbi, functionName: "getGateway", args: [address] });
+    return {
+        account: account.address,
+        parentEth: () => read.getBalance({ address: account.address }),
+        tokenBalance: (asset) => read.readContract({ address: token(asset), abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
+        async arrivalCost(asset, amount) {
+            const address = token(asset);
+            const calldata = await read.readContract({
+                address: await gateway(address),
+                abi: gatewayAbi,
+                functionName: "getOutboundCalldata",
+                args: [address, account.address, account.address, amount, "0x"],
+            });
+            const block = await read.getBlock();
+            const baseFee = block.baseFeePerGas ?? (await read.getGasPrice());
+            const submission = await read.readContract({
+                address: bridge.inbox,
+                abi: inboxAbi,
+                functionName: "calculateRetryableSubmissionFee",
+                args: [BigInt((calldata.length - 2) / 2), baseFee],
+            });
+            // Three times the quoted submission fee rides out a base fee that moves before the deposit lands; the rest is refunded on BrainChain.
+            return submission * 3n + DEPOSIT_GAS * ((await child.getGasPrice()) * 2n);
+        },
+        depositEth: async (amount) => wait(await wallet.writeContract({ address: bridge.inbox, abi: inboxAbi, functionName: "depositEth", value: amount })),
+        async depositToken(asset, amount, value) {
+            const address = token(asset);
+            const spender = await gateway(address);
+            const allowance = await read.readContract({ address, abi: erc20Abi, functionName: "allowance", args: [account.address, spender] });
+            if (allowance < amount)
+                await wait(await wallet.writeContract({ address, abi: erc20Abi, functionName: "approve", args: [spender, amount] }));
+            const gasPriceBid = (await child.getGasPrice()) * 2n;
+            const maxSubmissionCost = value - DEPOSIT_GAS * gasPriceBid;
+            const data = encodeAbiParameters([{ type: "uint256" }, { type: "bytes" }], [maxSubmissionCost, "0x"]);
+            return wait(await wallet.writeContract({
+                address: bridge.router,
+                abi: routerAbi,
+                functionName: "outboundTransferCustomRefund",
+                args: [address, account.address, account.address, amount, DEPOSIT_GAS, gasPriceBid, data],
+                value,
+            }));
+        },
+    };
+}
+/** The amount flag's decimals and the name the worker sees. */
+export function assetOf(network, asset) {
+    if (asset === "eth")
+        return { decimals: 18, symbol: "ETH" };
+    return asset === "stake" ? { decimals: 18, symbol: network.stakeSymbol } : { decimals: 6, symbol: network.bountySymbol };
+}
+/**
+ * Moves ETH, the stake token or the bounty token from the parent chain to the
+ * worker's own address on BrainChain, where it arrives in about a minute.
+ */
+export async function bridge(network, chain, options) {
+    const { asset, dry, log } = options;
+    const parent = network.bridge;
+    if (!parent)
+        throw new Error(`${network.name} has no bridge from a parent chain`);
+    const { decimals, symbol } = assetOf(network, asset);
+    const amount = parseUnits(options.amount, decimals);
+    if (amount <= 0n)
+        throw new Error("the amount must be above zero");
+    const shown = `${formatUnits(amount, decimals)} ${symbol}`;
+    let eth;
+    try {
+        eth = await chain.parentEth();
+    }
+    catch (error) {
+        throw new Error(`could not read the wallet on ${parent.name}: ${reason(error)}`);
+    }
+    if (asset === "eth") {
+        const gas = parseUnits("0.00002", 18);
+        if (eth < amount + gas)
+            throw new Error(`${chain.account} holds ${formatEther(eth)} ETH on ${parent.name}; ${shown} plus gas is needed. ${parent.gas}`);
+        log(`bridging ${shown} from ${parent.name} to ${chain.account} on ${network.name}`);
+        if (dry)
+            return log("dry run: nothing sent");
+        const tx = await chain.depositEth(amount);
+        return log(`sent, arrives on ${network.name} in about a minute: ${tx}`);
+    }
+    const held = await chain.tokenBalance(asset);
+    if (held < amount) {
+        throw new Error(`${chain.account} holds ${formatUnits(held, decimals)} ${symbol} on ${parent.name}, ${formatUnits(amount - held, decimals)} short of ${shown}`);
+    }
+    const value = await chain.arrivalCost(asset, amount);
+    if (eth < value + parseUnits("0.0001", 18)) {
+        throw new Error(`${chain.account} holds ${formatEther(eth)} ETH on ${parent.name}; about ${formatEther(value + parseUnits("0.0001", 18))} ETH is needed to pay the deposit's arrival and gas. ${parent.gas}`);
+    }
+    log(`bridging ${shown} from ${parent.name} to ${chain.account} on ${network.name} (sending ${formatEther(value)} ETH for its arrival, the unused part refunded there)`);
+    if (dry)
+        return log("dry run: nothing sent");
+    const tx = await chain.depositToken(asset, amount, value);
+    log(`sent, arrives on ${network.name} in about a minute: ${tx}`);
+}

package/dist/cli.js

@@ -1,13 +1,17 @@
 import { createRequire } from "node:module";
+import { verifyDecision } from "brainchain-verify";
+import { createPublicClient } from "viem";
 import { formatEther, parseUnits } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { createChain, faucetReopens, reason, unhealthy } from "./chain.js";
+import { brainchainTransport, createChain, faucetReopens, reason, unhealthy } from "./chain.js";
+import { assetOf, bridge, createBridgeChain } from "./bridge.js";
 import { claim, createIncome } from "./claim.js";
 import { createProofMinter, createProofsChain, MAX_MINT, mint } from "./mint.js";
-import { resolveNetwork } from "./network.js";
+import { chainOf, resolveNetwork } from "./network.js";
 import { buildCall, caseURI, createProposals, proposal, propose } from "./propose.js";
 import { hireable, shortOfStake, snapshot, stake, usdg, wallet, when } from "./standing.js";
 import { openStore } from "./state.js";
+import { createWatch, createWatchChain } from "./watch.js";
 import { createWork, shellCommand, stopLeftover, stopper } from "./work.js";
 const { version } = createRequire(import.meta.url)("../package.json");
 const USAGE = `brainchain-worker ${version}
@@ -31,12 +35,22 @@ Usage:
                                             --count, at 0.001 WETH each on Robinhood Chain. --dry sends nothing.
   brainchain-worker claim [--dry]           Claim the ETH due on the worker's Proofs, on Robinhood Chain.
                                             --dry lists what is due and sends nothing.
+  brainchain-worker bridge --eth <ETH> | --stake <amount> | --bounty <amount> [--dry]
+                                            Move ETH for gas, the stake token or the bounty token from Robinhood
+                                            Chain to the worker's address on BrainChain; it arrives in about a
+                                            minute. --dry checks the balances and sends nothing.
   brainchain-worker propose --target board|executor|registry --call <function> --args '<JSON array>'
                             --title <text> --rationale <text> [--current <text>] [--proposed <text>] [--dry]
                                             Bond the stake token and propose a change to BrainChain for Jev to
                                             decide. --data <hex> gives the call as raw calldata instead of
                                             --call and --args. --dry checks the call and sends nothing.
   brainchain-worker proposal <id>           Where a proposal stands: waiting, adopted and when it runs, or kept.
+  brainchain-worker watch [--veto] [--once]
+                                            Watch the chain: judge every queued change against the constitution
+                                            and re-verify every new decision, reporting what disagrees. --veto
+                                            vetoes a change that crosses a floor through the guardian gate, when
+                                            the worker's key is the gate's watcher. --once reads one round and
+                                            exits 1 on a finding.
   brainchain-worker leave                   Start unstaking (3-day cooldown).
   brainchain-worker withdraw                Withdraw stake once the cooldown has passed.
   brainchain-worker --version               Print the version.
@@ -66,6 +80,8 @@ const FLAGS = {
     withdraw: {},
     claim: { dry: true },
     mint: { count: false, dry: true },
+    bridge: { eth: false, stake: false, bounty: false, dry: true },
+    watch: { veto: true, once: true },
     propose: { target: false, call: false, args: false, data: false, title: false, rationale: false, current: false, proposed: false, dry: true },
     proposal: {},
 };
@@ -341,6 +357,49 @@ export async function main(argv) {
         }
         return mint(network, createProofsChain(network.proofs, signer().account), { count: count === undefined ? undefined : Number(count), dry: switches.has("dry"), log: console.log });
     }
+    if (command === "bridge") {
+        const given = ["eth", "stake", "bounty"].filter((asset) => values.has(asset));
+        if (given.length !== 1)
+            throw new UsageError("bridge takes exactly one of --eth, --stake or --bounty, with the amount to move");
+        const asset = given[0];
+        const amount = values.get(asset);
+        const { decimals, symbol } = assetOf(network, asset);
+        if (!new RegExp(`^\\d{1,12}(\\.\\d{1,${decimals}})?$`).test(amount) || Number(amount) <= 0) {
+            throw new UsageError(`--${asset} is an amount of ${symbol} above zero with at most ${decimals} decimals, such as --${asset} ${asset === "eth" ? "0.001" : "1"}`);
+        }
+        return bridge(network, createBridgeChain(network, signer().account), { asset, amount, dry: switches.has("dry"), log: console.log });
+    }
+    if (command === "watch") {
+        const veto = switches.has("veto");
+        const once = switches.has("once");
+        // Judging changes needs no key; vetoing does. A reader stands in for the signer otherwise.
+        const account = veto || process.env.BRAINCHAIN_WORKER_KEY?.trim() ? signer().account : privateKeyToAccount(generatePrivateKey());
+        const client = createPublicClient({ chain: chainOf(network), transport: brainchainTransport(network) });
+        const { taskBoard, executor, log } = network.contracts;
+        const verify = async (id) => {
+            const report = await verifyDecision({
+                client,
+                network: { chainId: network.chainId, name: network.name, rpc: network.rpc, sets: [] },
+                set: { key: "active", release: "", fromBlock: Number(network.fromBlock), board: taskBoard, log, executor },
+                briefs: new Map(),
+            }, id);
+            return { findings: report.checks.filter((c) => c.status === "fail" || c.status === "error").map((c) => `${c.name}: ${c.message}`) };
+        };
+        const watch = createWatch({ network, chain: createWatchChain(network, account), verify, veto, log: console.log });
+        if (veto && !network.contracts.gate)
+            throw new UsageError(`${network.name} has no guardian gate yet, so there is nothing to veto through`);
+        console.log(`watching ${network.name} as ${account.address}${veto ? ", vetoing through the guardian gate" : ""}`);
+        if (once) {
+            const { findings } = await watch.round();
+            if (findings > 0)
+                process.exitCode = 1;
+            return;
+        }
+        for (;;) {
+            await watch.round().catch((error) => console.log(`round failed: ${reason(error)}`));
+            await new Promise((resolve) => setTimeout(resolve, 30_000));
+        }
+    }
     if (command === "proposal") {
         const id = positional[0];
         if (id === undefined || !/^\d{1,18}$/.test(id) || id === "0")

package/dist/network.js

@@ -21,12 +21,22 @@ export const TESTNET = {
         faucet: true,
         gas: "Get Robinhood Chain testnet ETH for gas at https://faucet.testnet.chain.robinhood.com",
     },
+    bridge: {
+        chainId: 46630,
+        name: "Robinhood Chain testnet",
+        rpc: "https://rpc.testnet.chain.robinhood.com",
+        inbox: "0xd5B98547aA58db0AbC75C06f5A62a7ACDF9CB977",
+        router: "0x1BBe71Dd3af85309A5c7Ab00B190F38f34Fe3569",
+        gas: "Get Robinhood Chain testnet ETH at https://faucet.testnet.chain.robinhood.com",
+    },
     contracts: {
         taskBoard: "0x0beA77333E26a257983fCc59B8D857730b5B1D2B",
         staking: "0x09468dE253517bD5d91b92115cce45798F300Cf0",
         bonds: "0x34279448dc42b84B479daeF092749020017F001B",
         executor: "0xFFf56B7B194C190152b17C086c36A2a79f050397",
         registry: "0xcE777c32824fd5963a9C31C70e9B1c5D9C4ED16e",
+        log: "0xD7FC002E9FB9ba1D9119cF895936FA720545f6B8",
+        gate: "0x27c519399e178F1Ba5E453F6075b0bb9Ef4d1d5E",
         stakeToken: "0xc717546497343911750768335b649b86d0a6eCcf",
         bountyToken: "0xC4ec72794bF3Ce9ba1DE4B38085464c2eb0cDCf2",
     },
@@ -62,12 +72,22 @@ export const MAINNET = {
         gas: "Send it a little ETH there for gas",
         income: "0xeb1b4168D4b87D3d9F0D64E13B7071251BBB63b7",
     },
+    bridge: {
+        chainId: 4663,
+        name: "Robinhood Chain",
+        rpc: "https://rpc.mainnet.chain.robinhood.com",
+        inbox: "0x139a54F81d6Fdf7135D633CBCfB2373F0edfa2dd",
+        router: "0x03f06a370A59AfB23de029F4EF5EA2F9EB034F96",
+        gas: "Send it a little ETH on Robinhood Chain",
+        tokens: { stake: "0xC80333bf7f4078e14Ce5b6e223aF607aDcA44418", bounty: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168" },
+    },
     contracts: {
         taskBoard: MAINNET_TASK_BOARD,
         staking: MAINNET_WORKER_STAKING,
         bonds: MAINNET_PROPOSAL_BONDS,
         executor: MAINNET_DECISION_EXECUTOR,
         registry: "0x65B71706bE8a92dda39dDfdb6ABA8CEA64A33865",
+        log: "0x5FfED27750E5Ca990aB60751Fc4B25E39358FcD7",
         stakeToken: BRAIN,
         bountyToken: "0x8eBFEce96c0AeF7Fd23425D846a302a552c8c451",
     },
@@ -110,6 +130,14 @@ export function chainOf(network) {
         rpcUrls: { default: { http: [network.rpc] } },
     });
 }
+export function parentChainOf(bridge) {
+    return defineChain({
+        id: bridge.chainId,
+        name: bridge.name,
+        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: [bridge.rpc] } },
+    });
+}
 const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
 export function proofsChainOf(proofs) {
     return defineChain({

package/dist/watch.js

@@ -0,0 +1,183 @@
+import { createPublicClient, createWalletClient, parseAbi } from "viem";
+import { brainchainTransport, executorAbi, reason } from "./chain.js";
+import { chainOf } from "./network.js";
+/**
+ * The constitution's floors, by the function a change calls. A change that
+ * crosses one is what the guardian's veto is for. Values in the units the
+ * contracts take: basis points, seconds, and USDG in 6 decimals.
+ */
+export const FLOORS = {
+    "0x85327a44": {
+        name: "setParameters",
+        check: (w) => [
+            w[0] < 6000n && "the change bar falls below 60%",
+            w[1] < 86400n && "the timelock falls below 24 hours",
+            w[2] > 20n && "more than 20 house tasks a day",
+            w[3] > 10000000n && "a house bounty above 10 USDG",
+            w[4] > 50000000n && "house spend above 50 USDG a day",
+        ].filter((r) => typeof r === "string"),
+    },
+    "0x00dd15f5": {
+        name: "setConfig",
+        check: (w) => [
+            w[0] < 1000n && "the hire bar falls below 10%",
+            w[1] < 6000n && "the grade bar falls below 60%",
+            w[2] < 6000n && "the ruling bar falls below 60%",
+            (w[5] < 3600n || w[6] < 3600n || w[7] < 3600n) && "a grading, dispute or ruling window under an hour",
+            w[8] < 100000n && "a minimum bounty under 0.1 USDG",
+        ].filter((r) => typeof r === "string"),
+    },
+    "0x30f738be": { name: "setFee", check: (w) => (w[0] > 500n ? ["a protocol fee above 5%"] : []) },
+    "0x731022ff": {
+        name: "setModel",
+        check: (w) => [w[1] === 0n && "a house model with no account", w[2] > 5000000n && "a house model priced above 5 USDG"].filter((r) => typeof r === "string"),
+    },
+    "0x16c38b3c": { name: "setPaused", check: () => [] },
+    "0x1f1e4d9f": { name: "setWorkerAllowed", check: () => [] },
+    "0xa9059cbb": { name: "transfer", check: () => [] },
+};
+/** The static words after the selector; a call with dynamic arguments is read as far as its words go. */
+export function argumentsOf(data) {
+    const body = data.slice(10);
+    const words = [];
+    for (let i = 0; i + 64 <= body.length; i += 64)
+        words.push(BigInt(`0x${body.slice(i, i + 64)}`));
+    return words;
+}
+/** What a queued change does to the constitution: nothing, or the floors it crosses. */
+export function judge(data) {
+    const selector = data.slice(0, 10).toLowerCase();
+    const floor = FLOORS[selector];
+    if (!floor)
+        return { name: selector, broken: ["a call the constitution does not list"] };
+    return { name: floor.name, broken: floor.check(argumentsOf(data)) };
+}
+const gateAbi = parseAbi(["function veto(uint256 changeId, string reason)", "function watcher() view returns (address)"]);
+const logAbi = parseAbi(["function count() view returns (uint256)"]);
+export function createWatchChain(network, account) {
+    const transport = brainchainTransport(network);
+    const client = createPublicClient({ chain: chainOf(network), transport, pollingInterval: 1_000 });
+    const wallet = createWalletClient({ account, chain: chainOf(network), transport });
+    const executor = network.contracts.executor;
+    const gate = network.contracts.gate;
+    return {
+        account: account.address,
+        head: () => client.getBlockNumber(),
+        async queued(fromBlock, toBlock) {
+            const logs = await client.getContractEvents({ address: executor, abi: executorAbi, eventName: "Queued", fromBlock, toBlock });
+            return logs.map((log) => ({
+                changeId: log.args.changeId,
+                decisionId: log.args.decisionId,
+                target: log.args.target,
+                data: log.args.data,
+                eta: log.args.eta,
+                block: log.blockNumber,
+            }));
+        },
+        async open(changeId) {
+            const change = await client.readContract({ address: executor, abi: executorAbi, functionName: "getChange", args: [changeId] });
+            return !change.executed && !change.vetoed;
+        },
+        decisions: () => client.readContract({ address: network.contracts.log, abi: logAbi, functionName: "count" }),
+        ...(gate
+            ? {
+                async veto(changeId, why) {
+                    const watcher = await client.readContract({ address: gate, abi: gateAbi, functionName: "watcher" });
+                    if (watcher.toLowerCase() !== account.address.toLowerCase())
+                        throw new Error(`the gate's watcher is ${watcher}, not this worker`);
+                    const hash = await wallet.writeContract({ address: gate, abi: gateAbi, functionName: "veto", args: [changeId, why] });
+                    await client.waitForTransactionReceipt({ hash });
+                    return hash;
+                },
+            }
+            : {}),
+    };
+}
+/**
+ * Watches the chain for the worker: every queued change is judged against the
+ * constitution and, with `veto` on, one that crosses a floor is vetoed through
+ * the guardian gate; every new decision is re-verified. Each round reports
+ * what it found and keeps where it got to.
+ */
+export function createWatch(options) {
+    const { network, chain, verify, log } = options;
+    let nextBlock = options.fromBlock ?? network.fromBlock;
+    let seenDecision;
+    const judged = new Set();
+    let findings = 0;
+    async function changes() {
+        const head = await chain.head();
+        if (head < nextBlock)
+            return;
+        const span = 5000n;
+        for (let from = nextBlock; from <= head; from += span) {
+            const to = from + span - 1n < head ? from + span - 1n : head;
+            for (const change of await chain.queued(from, to)) {
+                const key = change.changeId.toString();
+                if (judged.has(key))
+                    continue;
+                judged.add(key);
+                const { name, broken } = judge(change.data);
+                const runsAt = new Date(Number(change.eta) * 1000).toISOString().replace("T", " ").slice(0, 16);
+                if (broken.length === 0) {
+                    log(`change ${change.changeId}: ${name} on ${change.target}, within the constitution, runs after ${runsAt} UTC`);
+                    continue;
+                }
+                findings += 1;
+                const why = broken.join("; ");
+                log(`change ${change.changeId}: ${name} on ${change.target} breaks the constitution (${why}), runs after ${runsAt} UTC`);
+                if (!options.veto)
+                    continue;
+                if (!(await chain.open(change.changeId))) {
+                    log(`change ${change.changeId} is closed already, nothing to veto`);
+                    continue;
+                }
+                if (!chain.veto) {
+                    log(`cannot veto: ${network.name} has no guardian gate this worker can reach`);
+                    continue;
+                }
+                try {
+                    const hash = await chain.veto(change.changeId, `Breaks the constitution: ${why}`);
+                    log(`vetoed change ${change.changeId} through the guardian gate: ${hash}`);
+                }
+                catch (error) {
+                    log(`veto of change ${change.changeId} failed: ${reason(error)}`);
+                }
+            }
+        }
+        nextBlock = head + 1n;
+    }
+    async function decisions() {
+        if (!verify)
+            return;
+        const count = await chain.decisions();
+        // The first round only notes where the log stands; later ones check what was added.
+        if (seenDecision === undefined) {
+            seenDecision = count;
+            log(`${count} decisions recorded so far; new ones are checked from here`);
+            return;
+        }
+        for (let id = seenDecision + 1n; id <= count; id++) {
+            try {
+                const { findings: wrong } = await verify(id);
+                if (wrong.length === 0)
+                    log(`decision ${id} verified`);
+                else {
+                    findings += 1;
+                    log(`decision ${id} does not verify: ${wrong.join("; ")}`);
+                }
+            }
+            catch (error) {
+                log(`decision ${id} could not be checked: ${reason(error)}`);
+            }
+        }
+        seenDecision = count;
+    }
+    return {
+        async round() {
+            await changes();
+            await decisions();
+            return { findings };
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.5.1",
+  "version": "0.7.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>",
@@ -28,6 +28,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
+    "brainchain-verify": "^0.1.2",
     "viem": "^2.0.0"
   },
   "devDependencies": {