blockyard 0.0.1 → 0.0.9

package/scripts/check.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// CHECK A NODE BEFORE RUNNING AGAINST IT: the RPC server answers, the credentials work, the
+// chain is the one configured, the indexes the explorer needs are there, the block files can be
+// read (the address index is built from them), the node's log is where it should be, and an
+// address index, if configured, is readable, writable and not far behind.
+//
+//   npm run check                 # every node in config/local.json
+//   node scripts/check.js --node <id>
+//
+// Prints one line per check and exits 1 if anything FAILED. `npm run setup` runs the same checks
+// on the answers it is given before it writes config/local.json. The checks are a function
+// (runChecks) so they can be tested against a stub node, with the printing kept out here.
+import { existsSync, statSync, readdirSync, accessSync, readFileSync, realpathSync, constants as FS } from 'node:fs';
+import path from 'node:path';
+import { loadConfig, configProblems, resolveCookie } from '../server/config.js';
+import { RpcClient } from '../server/rpc/client.js';
+import { MAGIC, xorKey, readChainFile, records } from '../server/chain/blockfile.js';
+import { c, checkLine } from './ui.js';
+import { fileURLToPath } from 'node:url';
+
+const QUIET = { info() {}, warn() {}, error() {}, debug() {} };
+
+/** The RPC client a check talks through; setup and the tests pass their own. */
+export function clientFor(node, cfg) {
+  return new RpcClient(node, { ...(cfg?.rpc ?? {}), ...(node.rpc ?? {}) }, { log: QUIET });
+}
+
+const CORE_VERSION_MIN = 250000;   // getblock verbosity 3 (the follower's one call) arrived in 25.0
+
+/**
+ * Every check for one node. `rpc` is anything with batch(calls) -> [{ok, result, error}].
+ * Returns { ok, checks: [{ name, status: 'ok'|'warn'|'fail'|'info', detail }], facts }.
+ */
+export async function runChecks(node, { rpc, fs = { existsSync, statSync, readdirSync, accessSync, readFileSync }, readBlockFile = readChainFile } = {}) {
+  const checks = [];
+  const facts = {};
+  const add = (name, status, detail) => { checks.push({ name, status, detail }); return status; };
+
+  // credentials
+  const cred = resolveCookie(node);
+  if (!cred) add('credentials', 'fail', `no cookie file found under ${node.datadir ?? '(no datadir)'} and no rpcUser/rpcPassword`);
+  else add('credentials', 'ok', cred.source === 'config' ? `rpcUser "${cred.user}" from the config` : `cookie ${cred.source}`);
+
+  // the RPC server
+  // every call is timed: how fast the node answers is half of what an install needs to know
+  const ms = (t0) => `${Date.now() - t0 >= 1000 ? `${((Date.now() - t0) / 1000).toFixed(1)} s` : `${Date.now() - t0} ms`}`;
+  const one = async (method, params = [], timeoutMs = 20000) => {
+    const t0 = Date.now();
+    try { const [r] = await rpc.batch([{ method, params }], { timeoutMs }); r.ms = ms(t0); return r; }
+    catch (err) { return { ok: false, ms: ms(t0), error: { message: err.message, kind: err.kind } }; }
+  };
+  const info = await one('getblockchaininfo');
+  if (!info.ok) {
+    add('rpc', 'fail', `${node.rpcUrl}: ${info.error.message}`);
+    return { ok: false, checks, facts };
+  }
+  const chain = info.result.chain;
+  facts.chain = chain; facts.blocks = info.result.blocks; facts.headers = info.result.headers;
+  add('rpc', 'ok', `${node.rpcUrl} answers in ${info.ms}: chain ${chain}, block ${info.result.blocks.toLocaleString()} of ${info.result.headers.toLocaleString()} headers${info.result.initialblockdownload ? ', still in initial block download' : ''}${info.result.pruned ? ', PRUNED' : ''}`);
+  if (node.chainHint && node.chainHint !== chain) add('chain', 'fail', `config says chainHint "${node.chainHint}" but the node is on "${chain}"`);
+  if (info.result.pruned) add('pruned', 'fail', 'a pruned node has discarded old block files; the address index needs every one of them');
+
+  const net = await one('getnetworkinfo');
+  if (net.ok) {
+    facts.version = net.result.version; facts.subversion = net.result.subversion;
+    const v = net.result.version;
+    add('version', v >= CORE_VERSION_MIN ? 'ok' : 'fail', `${net.result.subversion} (${v})${v < CORE_VERSION_MIN ? ` -- the address index follower needs getblock verbosity 3, Bitcoin Core 25.0 or later` : ''}`);
+  } else add('version', 'warn', `getnetworkinfo: ${net.error.message}`);
+
+  const idx = await one('getindexinfo');
+  if (idx.ok) {
+    const tx = idx.result.txindex;
+    if (!tx) add('txindex', 'fail', 'txindex is off: the explorer cannot look a confirmed transaction up by id (set txindex=1 in bitcoin.conf)');
+    else add('txindex', tx.synced ? 'ok' : 'warn', tx.synced ? `synced to ${tx.best_block_height.toLocaleString()}` : `still building (${tx.best_block_height.toLocaleString()} of ${info.result.blocks.toLocaleString()})`);
+    const cs = idx.result.coinstatsindex;
+    add('coinstatsindex', cs ? (cs.synced ? 'ok' : 'warn') : 'info', cs ? (cs.synced ? 'synced: the Chain page has UTXO figures' : 'still building') : 'off: the Chain page marks UTXO figures unindexed (optional)');
+  } else add('txindex', 'warn', `getindexinfo: ${idx.error.message}`);
+
+  // the explorer's one heavy need from the node: a block with every input's prevout
+  const best = await one('getbestblockhash');
+  if (best.ok) {
+    const blk = await one('getblock', [best.result, 3], 120_000);
+    if (blk.ok) {
+      const withPrevout = blk.result.tx.slice(1, 4).every((t) => t.vin.every((v) => v.prevout));
+      const slow = blk.ms.endsWith(' s') && parseFloat(blk.ms) >= 5;
+      add('getblock 3', withPrevout ? (slow ? 'warn' : 'ok') : 'fail', withPrevout ? `the tip block decodes with prevouts (${blk.result.tx.length.toLocaleString()} transactions) in ${blk.ms}${slow ? ' -- slow: the block files are on a slow disk, or the node is busy' : ''}` : 'the node answered verbosity 3 without prevouts');
+    } else add('getblock 3', 'fail', `getblock <tip> 3: ${blk.error.message} -- the address index follower cannot run`);
+  }
+  // the mempool, verbose: the monitor's heaviest regular read, every 20 s; how long the node takes
+  // over it is what decides whether the block-space board fills
+  const mp = await one('getrawmempool', [true], 120_000);
+  if (mp.ok) {
+    const n = Object.keys(mp.result).length;
+    const slow = mp.ms.endsWith(' s') && parseFloat(mp.ms) >= 10;
+    add('mempool', slow ? 'warn' : 'ok', `${n.toLocaleString()} transactions, verbose, in ${mp.ms}${slow ? ' -- slow: the board and the block being built will lag behind this' : ''}`);
+  } else add('mempool', 'warn', `getrawmempool verbose: ${mp.error.message} after ${mp.ms}`);
+  const addr = await one('getaddresstxids', [{ addresses: [] }]);
+  add('address index rpc', 'info', addr.ok ? 'the node has insight-style address RPCs (unused: BlockYard keeps its own index)' : 'the node has no address index, as expected of Bitcoin Core; BlockYard builds its own');
+
+  // the data directory: block files and the log
+  if (!node.datadir) add('datadir', 'fail', 'no datadir configured: the address index is built from the node\'s block files');
+  else if (!fs.existsSync(node.datadir)) add('datadir', 'fail', `${node.datadir} does not exist on this machine`);
+  else {
+    const blocksDir = path.join(node.datadir, 'blocks');
+    let names = null;
+    try { names = fs.readdirSync(blocksDir); } catch (err) { add('block files', 'fail', `${blocksDir}: ${err.message}`); }
+    if (names) {
+      const blk = names.filter((f) => /^blk\d{5}\.dat$/.test(f)).sort();
+      const rev = names.filter((f) => /^rev\d{5}\.dat$/.test(f)).sort();
+      const xor = names.includes('xor.dat');
+      facts.blockFiles = blk.length; facts.undoFiles = rev.length;
+      if (!blk.length) add('block files', 'fail', `${blocksDir} holds no blk*.dat`);
+      else {
+        let bytes = 0;
+        for (const f of [...blk, ...rev]) { try { bytes += fs.statSync(path.join(blocksDir, f)).size; } catch { /* counted as far as readable */ } }
+        facts.blockBytes = bytes;
+        add('block files', rev.length === blk.length ? 'ok' : 'warn', `${blk.length} block files and ${rev.length} undo files, ${(bytes / 1e9).toFixed(1)} GB${xor ? ', XOR-obfuscated (xor.dat present)' : ''}${rev.length !== blk.length ? ' -- every block file needs its undo file' : ''}`);
+        // prove they can be read: the first file's first record is the genesis block
+        try {
+          const key = xorKey(blocksDir);
+          const buf = readBlockFile(path.join(blocksDir, blk[0]), key);
+          const first = records(buf, MAGIC[chain] ?? MAGIC.main, 0, key).next().value;
+          const genesis = first && first.body.subarray(4, 36).every((b) => b === 0);
+          add('read a block', genesis ? 'ok' : 'fail', genesis ? `${blk[0]} opens and its first record is the genesis block` : `${blk[0]} opens but its first record is not a ${chain} genesis block: wrong chain, or a key this reader does not know`);
+        } catch (err) { add('read a block', 'fail', `${blk[0]}: ${err.message}`); }
+      }
+    }
+    const logs = [path.join(node.datadir, chain === 'main' ? '' : ({ test: 'testnet3', testnet4: 'testnet4', signet: 'signet', regtest: 'regtest' }[chain] ?? chain), 'debug.log')];
+    const log = logs.find((f) => fs.existsSync(f));
+    if (log) { const st = fs.statSync(log); facts.logFile = log; add('node log', 'info', `${log} (${(st.size / 1e6).toFixed(1)} MB) -- found; not parsed on Bitcoin Core, and not needed`); }
+    else add('node log', 'info', `no debug.log under ${node.datadir} -- not needed`);
+  }
+
+  // an address index, if there is one
+  if (node.addressIndex) {
+    const dir = node.addressIndex;
+    const manifest = path.join(dir, 'manifest.json');
+    if (!fs.existsSync(manifest)) add('address index', node.addressIndexBuild === 'manual' ? 'warn' : 'info', `${dir}: not built yet${node.addressIndexBuild === 'manual' ? ` (node scripts/index-build.js --out ${dir})` : ' -- BlockYard builds it when it starts'}`);
+    else {
+      try {
+        const m = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+        const behind = info.result.blocks - m.tip.height;
+        facts.indexTip = m.tip.height;
+        add('address index', behind > 200 ? 'warn' : 'ok', `${dir}: built at ${m.builtAt ?? '?'} to block ${m.tip.height.toLocaleString()}, ${behind.toLocaleString()} behind the node${behind > 200 ? ' (the follower catches up 50 blocks a poll)' : ''}`);
+      } catch (err) { add('address index', 'fail', `${manifest}: ${err.message}`); }
+      try { fs.accessSync(dir, FS.W_OK); add('index writable', 'ok', 'the follower can write live.log and layers/ there'); }
+      catch { add('index writable', 'fail', `${dir} is not writable by this user; the follower writes live.log and layers/ inside it`); }
+    }
+  }
+
+  return { ok: !checks.some((c) => c.status === 'fail'), checks, facts };
+}
+
+export function printChecks(label, { ok, checks }) {
+  console.log(`\n  ${c.bold(label)}`);
+  for (const ch of checks) console.log(checkLine(ch.status, ch.name, ch.detail));
+  console.log(ok ? `    ${c.ok(c.bold('everything this needs is there'))}` : `    ${c.bad(c.bold('something this needs is missing'))}${c.dim(' (the ✗ lines say what)')}`);
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === realpathSync(process.argv[1])) {
+  const arg = (name) => { const i = process.argv.indexOf(`--${name}`); return i > 0 ? process.argv[i + 1] : null; };
+  const cfg = loadConfig();
+  for (const p of configProblems()) console.log(checkLine('fail', 'config', p));
+  const nodes = arg('node') ? cfg.nodes.filter((n) => n.id === arg('node')) : cfg.nodes;
+  if (!nodes.length) { console.log(`no node ${arg('node') ?? ''} in ${cfg.__configFile ?? 'the configuration'}`); process.exit(2); }
+  let allOk = configProblems().length === 0;
+  for (const node of nodes) {
+    const r = await runChecks(node, { rpc: clientFor(node, cfg) });
+    printChecks(`node "${node.id}" (${node.label ?? ''})`, r);
+    allOk &&= r.ok;
+  }
+  process.exit(allOk ? 0 : 1);
+}

package/scripts/decode-check.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// Replay whole blocks from a live node through server/chain/tx.js and compare every field against the
+// node's own verbose decoding. A decoder is only as good as the last time it was checked against Core.
+//
+//   node scripts/decode-check.js [--node <id>] [--blocks N] [--from <height>] [--heights h1,h2,...]
+//
+// Fetches each block twice, as raw bytes (getblock <hash> 0) and as Core's JSON (getblock <hash> 2),
+// decodes the bytes, and reports every disagreement plus the count of each script type seen. Read-only
+// RPC, through the same client and lane the monitor uses.
+import { loadConfig } from '../server/config.js';
+import { RpcClient } from '../server/rpc/client.js';
+import { decodeBlock } from '../server/chain/tx.js';
+
+const arg = (name, def) => { const i = process.argv.indexOf(`--${name}`); return i > 0 ? process.argv[i + 1] : def; };
+const cfg = loadConfig();
+const node = cfg.nodes.find((n) => n.id === arg('node', null)) ?? cfg.nodes[0];
+const quiet = { info() {}, warn() {}, error() {}, debug() {} };
+const rpc = new RpcClient(node, { ...(cfg.rpc ?? {}), ...(node.rpc ?? {}) }, { log: quiet });
+const call = async (method, params, timeoutMs = 120_000) => {
+  const [r] = await rpc.batch([{ method, params }], { key: `decode-check:${method}:${params[0]}`, priority: 5, maxWaitMs: 120_000, timeoutMs });
+  if (!r.ok) throw new Error(`${method}: ${r.error?.message}`);
+  return r.result;
+};
+
+const info = await call('getblockchaininfo', []);
+const count = Math.max(1, Number(arg('blocks', 3)));
+const from = Number(arg('from', info.blocks - count + 1));
+const sat = (btc) => Math.round(btc * 1e8);
+const mismatches = [];
+const types = {};
+let txs = 0, inputs = 0, outputs = 0, bytes = 0, decodeMs = 0;
+const differ = (where, got, want) => { if (got !== want && mismatches.length < 50) mismatches.push(`${where}: decoded ${JSON.stringify(got)}, node ${JSON.stringify(want)}`); return got !== want; };
+
+const heights = arg('heights', null) ? arg('heights').split(',').map(Number) : Array.from({ length: count }, (_, i) => from + i);
+for (const h of heights) {
+  const hash = await call('getblockhash', [h]);
+  const raw = await call('getblock', [hash, 0]);
+  const want = await call('getblock', [hash, 2], 300_000);
+  const buf = Buffer.from(raw, 'hex');
+  const t0 = performance.now();
+  const got = decodeBlock(buf, info.chain);
+  decodeMs += performance.now() - t0;
+  bytes += buf.length;
+  for (const k of ['hash', 'version', 'previousblockhash', 'merkleroot', 'time', 'bits', 'nonce', 'size', 'nTx']) differ(`block ${h} ${k}`, got[k], want[k]);
+  want.tx.forEach((w, i) => {
+    const g = got.tx[i];
+    const at = `block ${h} tx ${i} (${w.txid.slice(0, 12)})`;
+    txs++;
+    for (const k of ['txid', 'hash', 'version', 'size', 'vsize', 'weight', 'locktime']) differ(`${at} ${k}`, g[k], w[k]);
+    differ(`${at} vin count`, g.vin.length, w.vin.length);
+    w.vin.forEach((wi, j) => {
+      const gi = g.vin[j] ?? {};
+      inputs++;
+      if (wi.coinbase != null) differ(`${at} vin ${j} coinbase`, gi.coinbase, wi.coinbase);
+      else {
+        differ(`${at} vin ${j} txid`, gi.txid, wi.txid);
+        differ(`${at} vin ${j} vout`, gi.vout, wi.vout);
+        differ(`${at} vin ${j} scriptSig`, gi.scriptSig?.hex, wi.scriptSig?.hex);
+      }
+      differ(`${at} vin ${j} sequence`, gi.sequence, wi.sequence);
+      differ(`${at} vin ${j} witness`, JSON.stringify(gi.txinwitness ?? null), JSON.stringify(wi.txinwitness ?? null));
+    });
+    differ(`${at} vout count`, g.vout.length, w.vout.length);
+    w.vout.forEach((wo, j) => {
+      const go = g.vout[j] ?? { scriptPubKey: {} };
+      outputs++;
+      types[wo.scriptPubKey.type] = (types[wo.scriptPubKey.type] ?? 0) + 1;
+      differ(`${at} vout ${j} value`, go.value_sat, sat(wo.value));
+      differ(`${at} vout ${j} n`, go.n, wo.n);
+      differ(`${at} vout ${j} hex`, go.scriptPubKey.hex, wo.scriptPubKey.hex);
+      differ(`${at} vout ${j} type`, go.scriptPubKey.type, wo.scriptPubKey.type);
+      differ(`${at} vout ${j} address`, go.scriptPubKey.address ?? null, wo.scriptPubKey.address ?? null);
+    });
+  });
+}
+
+console.log(`${node.id} (${info.chain}): ${heights.length} blocks (${heights[0]}..${heights[heights.length - 1]}), ${txs} transactions, ${inputs} inputs, ${outputs} outputs, ${(bytes / 1e6).toFixed(1)} MB`);
+console.log(`decoded in ${decodeMs.toFixed(0)} ms (${(bytes / 1e6 / (decodeMs / 1000)).toFixed(1)} MB/s, ${(txs / (decodeMs / 1000)).toFixed(0)} tx/s)`);
+console.log('script types:', JSON.stringify(types));
+console.log(mismatches.length ? `MISMATCHES (${mismatches.length}${mismatches.length >= 50 ? '+' : ''}):\n  ${mismatches.join('\n  ')}` : 'every field matches the node');
+process.exit(mismatches.length ? 1 : 0);

package/scripts/doc-counts.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// One source of truth for the test count the docs quote.
+//
+// Why this exists as a script rather than as a grep in a test: the documented
+// count drifted out of sync three times on 2026-09-08, and each time the fix was
+// a sed against a string a previous sed had already rewritten, so the replacement
+// matched nothing and the docs went on asserting a stale number. The previous
+// guard compared README against AGENTS.md, which only proves two documents are
+// wrong *together* — it never looked at the suite. 183 vs 180 is exactly that
+// failure, found by hand on 2026-09-09.
+//
+// So: count what the suite declares, and make the docs match it.
+//
+// How the count is derived, and why it is the same number `node --test` prints:
+// every test in this repo is declared at module top level with `test('name', …)`.
+// A nested declaration (`t.test(…)`, or an indented `test(`) would make the two
+// numbers disagree, so the scanner reports nested declarations separately and
+// test/doc-counts.test.js fails loudly if any appear — a scanner that silently
+// undercounts is the same class of bug as the sed that matched nothing.
+//
+//   node scripts/doc-counts.js          # print the number
+//   node scripts/doc-counts.js --check  # exit 1 if the docs disagree
+//   node scripts/doc-counts.js --fix    # rewrite the docs' number
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const DECL = /^(?:test|test\.skip|test\.todo|test\.only)\s*\(/;
+
+/** Test declarations per file: top-level (counted) and nested (a scanner gap). */
+export function scanTests({ root = ROOT, dir = 'test' } = {}) {
+  const base = path.join(root, dir);
+  const rel = (f) => path.relative(root, f).split(path.sep).join('/');   // keyed with '/', on every platform
+  const files = fs.readdirSync(base, { recursive: true, withFileTypes: true })
+    .filter((e) => e.isFile() && e.name.endsWith('.test.js'))
+    .map((e) => path.join(e.parentPath ?? e.path, e.name))
+    .sort();
+  const out = { total: 0, nested: [], perFile: {}, files: files.length };
+  for (const f of files) {
+    let top = 0;
+    for (const line of fs.readFileSync(f, 'utf8').split('\n')) {
+      const trimmed = line.trimStart();
+      if (!DECL.test(trimmed)) continue;
+      // Indented means it sits inside another test's body or a helper: a subtest.
+      if (/^\s/.test(line)) out.nested.push(`${rel(f)}: ${trimmed.slice(0, 60)}`);
+      else top += 1;
+    }
+    out.perFile[rel(f)] = top;
+    out.total += top;
+  }
+  return out;
+}
+
+// Every place the docs quote a test count. Deliberately narrow ("N tests" /
+// "N unit tests") so a measurement like "1 test failed" in prose is not edited.
+export const DOC_FILES = ['README.md', 'AGENTS.md'];
+
+export function docCounts({ root = ROOT } = {}) {
+  const found = [];
+  for (const rel of DOC_FILES) {
+    const text = fs.readFileSync(path.join(root, rel), 'utf8');
+    for (const m of text.matchAll(/(\d+)\s+(unit tests|tests)\b/g)) {
+      found.push({ file: rel, count: Number(m[1]), match: m[0], index: m.index });
+    }
+  }
+  return found;
+}
+
+export function rewriteDocs(count, { root = ROOT, dry = false } = {}) {
+  const changes = [];
+  for (const rel of DOC_FILES) {
+    const file = path.join(root, rel);
+    const text = fs.readFileSync(file, 'utf8');
+    const next = text.replace(/(\d+)(\s+(?:unit tests|tests)\b)/g, `${count}$2`);
+    if (next !== text) {
+      changes.push(rel);
+      if (!dry) fs.writeFileSync(file, next);
+    }
+  }
+  return changes;
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === fs.realpathSync(process.argv[1]);
+if (isMain) {
+  const scan = scanTests();
+  const mode = process.argv.includes('--check') ? 'check' : process.argv.includes('--fix') ? 'fix' : 'print';
+  if (mode === 'print') {
+    process.stdout.write(`${scan.total}\n`);
+    if (scan.nested.length) process.stderr.write(`warning: ${scan.nested.length} nested test declaration(s) the count cannot see:\n  ${scan.nested.join('\n  ')}\n`);
+  } else {
+    const docs = docCounts();
+    const wrong = docs.filter((d) => d.count !== scan.total);
+    if (mode === 'fix') {
+      const touched = rewriteDocs(scan.total);
+      process.stdout.write(`${scan.total} declared tests; ${touched.length ? `rewrote ${touched.join(', ')}` : 'docs already correct'}\n`);
+    } else if (wrong.length) {
+      process.stderr.write(
+        `documented test count is wrong. The suite declares ${scan.total} tests; the docs say `
+        + `${wrong.map((w) => `${w.file}: "${w.match}"`).join(', ')}.\n`
+        + 'Fix it with: node scripts/doc-counts.js --fix\n',
+      );
+      process.exitCode = 1;
+    } else {
+      process.stdout.write(`docs agree with the suite at ${scan.total}\n`);
+    }
+  }
+}

package/scripts/donate-qr.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# Regenerate the donation QR in public/index.html (the <svg class="abqr">) from the address below,
+# with OpenCV's encoder, and check the modules written decode back to the address. Run by hand when
+# the address changes; the SVG is committed, so nothing is generated at run time or in the browser.
+import cv2, numpy as np, re, sys
+ADDR = 'bc1q249cv27lc2q7y0x53vkczgfvvgsjzhwxwv42gc'
+img = cv2.QRCodeEncoder.create().encode(ADDR)
+n = img.shape[0]; size = n + 8
+d = ''.join(f'M{x+4} {y+4}h1v1h-1z' for y in range(n) for x in range(n) if img[y, x] == 0)
+m = np.full((size * 8, size * 8), 255, np.uint8)
+for mm in re.finditer(r'M(\d+) (\d+)h1v1h-1z', d):
+    x, y = int(mm.group(1)), int(mm.group(2)); m[y*8:(y+1)*8, x*8:(x+1)*8] = 0
+data, _, _ = cv2.QRCodeDetector().detectAndDecode(m)
+if data != ADDR: sys.exit(f'the QR does not decode to the address: {data!r}')
+svg = f'<svg class="abqr" viewBox="0 0 {size} {size}" width="132" height="132" role="img" aria-label="QR code of the donation address" shape-rendering="crispEdges"><rect width="{size}" height="{size}" fill="#fff"/><path fill="#000" d="{d}"/></svg>'
+p = 'public/index.html'; s = open(p).read()
+s2 = re.sub(r'<svg class="abqr".*?</svg>', svg, s, count=1, flags=re.S)
+if s2 == s and svg not in s: sys.exit('no <svg class="abqr"> in public/index.html to replace')
+open(p, 'w').write(s2)
+print(f'{n}x{n} modules, decodes to {data}')