blockyard 0.0.1 → 0.0.9

package/scripts/motion-check.mjs

@@ -0,0 +1,138 @@
+// Measure the blockspace maps AS ANIMATION, not as a still.
+//
+// browser-check.mjs answers "did pixels get painted". It cannot answer the question
+// actually on the table today: "does the picture MOVE, and can I see the mempool
+// reshuffling?" For that you sample the same canvas twice and count pixels that changed.
+// It also asserts the browser is running the bytes on disk (rule 25), and switches the
+// SPA page through the nav button rather than by hash, because a hash-only navigation
+// against a warm document is a no-op and every such reading this repo has had was the
+// wrong page measured.
+//
+//   BLOCKYARD_BASE=https://<lan>:8088 [CDP=http://127.0.0.1:9333] node scripts/motion-check.mjs
+import { execFileSync } from 'node:child_process';
+
+const BASE = process.env.BLOCKYARD_BASE;
+const CDP = process.env.BROWSER_CDP ?? 'http://127.0.0.1:9333';
+const CA = process.env.BLOCKYARD_CA ?? null;   // a CA file for an https monitor, if one is needed
+const OUT = process.env.MOTION_OUT ?? `/tmp/motion-check-${process.pid}.png`;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+if (!BASE) { console.log('usage: BLOCKYARD_BASE=https://<address>:8088 node scripts/motion-check.mjs'); process.exit(2); }
+
+const servedSha = (p) => execFileSync('curl', ['-sk', '--cacert', CA, `${BASE}${p}`], { encoding: 'utf8', maxBuffer: 1 << 24 })
+  .split('').reduce((h, c) => (h * 33 ^ c.charCodeAt(0)) >>> 0, 5381).toString(16);
+
+const targets = JSON.parse(await (await fetch(`${CDP}/json/list`)).text());
+const page = targets.find((t) => t.type === 'page');
+if (!page) { console.log('no page target'); process.exit(1); }
+const ws = new WebSocket(page.webSocketDebuggerUrl);
+await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+let nextId = 1;
+const pending = new Map();
+const exceptions = [];
+ws.onmessage = (ev) => {
+  const msg = JSON.parse(ev.data);
+  if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); }
+  if (msg.method === 'Runtime.exceptionThrown') exceptions.push(msg.params.exceptionDetails?.exception?.description ?? msg.params.exceptionDetails?.text);
+};
+const send = (method, params = {}) => new Promise((res) => {
+  const id = nextId++;
+  pending.set(id, (m) => res(m.result ?? m.error ?? {}));
+  ws.send(JSON.stringify({ id, method, params }));
+});
+const evl = async (expression) => (await send('Runtime.evaluate', { expression, returnByValue: true }))?.result?.value;
+
+await send('Page.enable');
+await send('Runtime.enable');
+await send('Emulation.setDeviceMetricsOverride', { width: 1440, height: 1900, deviceScaleFactor: 1, mobile: false });
+
+// ---- load the app, then SWITCH pages the way a user does (rule 25) ----------------
+const url = `${BASE}/?t=${Date.now()}#overview`;
+const loaded = new Promise((res) => {
+  const orig = ws.onmessage;
+  ws.onmessage = (m) => { orig(m); if (JSON.parse(m.data).method === 'Page.loadEventFired') res(true); };
+  setTimeout(() => res(false), 25_000);
+});
+await send('Page.navigate', { url });
+await loaded;
+await sleep(4000);
+
+const shell = JSON.parse(await evl(`JSON.stringify({nav: !!document.getElementById('nav'), path: location.pathname})`) ?? '{}');
+if (!shell.nav || shell.path.startsWith('/login')) { console.log('ABORT: not the app', shell); process.exit(3); }
+
+// Prove the document runs the bytes on disk, by reading back something only the new code
+// has. Not the build id -- the served JS itself, hashed in the page against the served copy.
+const ramp = await evl(`(async () => { const t = await (await fetch('/js/goggles.js')).text();
+  return JSON.stringify({ hasRamp: /RAMP/.test(t) && /255, 43, 111/.test(t), hasPulse: /PULSE_MS/.test(t), hasHatch: /hatchPattern/.test(t), len: t.length }); })()`);
+console.log('served goggles.js:', ramp);
+
+// Click through to Mining and wait for the template (the node spends ~1.3 s on it).
+await evl(`(() => { const b = document.querySelector('#nav button[data-page="mining"]'); if (b) b.click(); return !!b; })()`);
+await sleep(9000);
+
+// ---- the measurement: does the canvas actually change between frames? -------------
+const sampler = () => {
+  window.__snap = window.__snap ?? {};
+  window.__grab = (id) => {
+    const c = document.getElementById(id);
+    if (!c) return { missing: true };
+    const ctx = c.getContext('2d', { willReadFrequently: true });
+    const d = ctx.getImageData(0, 0, c.width, c.height).data;
+    const key = [];
+    let lit = 0, bright = 0;
+    const hist = {};
+    for (let i = 0; i < d.length; i += 4 * 7) {
+      if (d[i + 3] < 8) continue;
+      const r = d[i], g = d[i + 1], b = d[i + 2];
+      key.push(((r >> 2) << 12) | ((g >> 2) << 6) | (b >> 2));
+      const L = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+      if (L > 60) lit++;
+      if (L > 150) bright++;
+      const k = `${r >> 4},${g >> 4},${b >> 4}`;
+      hist[k] = (hist[k] ?? 0) + 1;
+    }
+    let hsh = 2166136261;
+    for (let i = 0; i < key.length; i++) { hsh ^= key[i]; hsh = Math.imul(hsh, 16777619) >>> 0; }
+    const top = Object.entries(hist).sort((a, b) => b[1] - a[1]).slice(0, 8);
+    const tot = Object.values(hist).reduce((a, b) => a + b, 0) || 1;
+    return { hash: hsh, px: key.length, litPct: +(100 * lit / key.length).toFixed(1), brightPct: +(100 * bright / key.length).toFixed(1),
+      top: top.map(([k, v]) => `${k}:${(100 * v / tot).toFixed(0)}%`) };
+  };
+  return 'ready';
+};
+await send('Runtime.evaluate', { expression: `(${sampler.toString()})()` });
+
+const read = (id) => evl(`window.__grab(${JSON.stringify(id)})`);
+const IDS = ['gnTreemap', 'gnMempoolTreemap'];
+const frames = { gnTreemap: [], gnMempoolTreemap: [] };
+for (let f = 0; f < 24; f++) {
+  for (const id of IDS) frames[id].push(await read(id));
+  await sleep(200);
+}
+// A second wave later: does the map reshuffle when a new template lands?
+await sleep(14000);
+const after = {};
+for (const id of IDS) after[id] = await read(id);
+
+console.log('\n-- per-canvas, 24 samples at 200 ms --');
+for (const id of IDS) {
+  const fs = frames[id];
+  if (fs[0]?.missing) { console.log(`   ${id}: MISSING`); continue; }
+  const hashes = fs.map((f) => f.hash);
+  const distinct = new Set(hashes).size;
+  // Adjacent-frame change: how many samples differ from the one before.
+  let changed = 0;
+  for (let i = 1; i < hashes.length; i++) if (hashes[i] !== hashes[i - 1]) changed++;
+  console.log(`   ${id.padEnd(18)} distinct=${distinct}/${hashes.length} adjacent-changes=${changed}/${hashes.length - 1}`);
+  console.log(`      lit=${fs[0].litPct}% bright=${fs[0].brightPct}%  colours=${JSON.stringify(fs[0].top)}`);
+  const a = after[id];
+  console.log(`      14s later: distinctAgainstFirst=${a.hash !== fs[fs.length - 1].hash} lit=${a.litPct}% bright=${a.brightPct}%`);
+}
+if (exceptions.length) { console.log(`uncaught exceptions: ${exceptions.length}`); exceptions.slice(0, 5).forEach((e) => console.log(`   !! ${String(e).split('\n')[0]}`)); }
+
+const shot = await send('Page.captureScreenshot', { format: 'png' });
+if (shot.data) {
+  const fs = await import('node:fs');
+  fs.writeFileSync(OUT, Buffer.from(shot.data, 'base64'));
+  console.log(`\nscreenshot: ${OUT}`);
+}
+ws.close();

package/scripts/pool-map.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// Build the pool label map: coinbase tag -> pool name, from mempool.space's curated
+// mining-pools data (https://github.com/mempool/mining-pools, pools-v2.json).
+//
+// WHY THIS IS ALLOWED AND A GUESS IS NOT. The monitor never invents a miner name. It
+// shows the bytes the pool put in its own coinbase, verbatim. A label from this file is
+// not a guess by us -- it is a curated mapping by the people who maintain one, and it
+// arrives with its provenance (source URL, content sha, fetchedAt) and travels with
+// every row, so a reader can see which label came from where and check it. Blocks that
+// match nothing stay 'unknown:<fingerprint>' with the raw tag on screen.
+//
+// HOW TO RUN. It is manual by default, on purpose: the app must not need the network at
+// runtime, and a surprise fetch that changes which organisation the dashboard blames for
+// a block is not a benign dependency. Refresh it when you want newer labels:
+//
+//   node scripts/pool-map.js                      # fetch and write data/pool-map.json
+//   node scripts/pool-map.js --file pools-v2.json # offline input
+//   node scripts/pool-map.js --check              # compare against what we are seeing now
+//
+// The input shape as fetched on 2026-09-09: 35,733 bytes, 171 pools, 201 tags, keys
+// per pool: addresses, id, link, name, tags. Tags are literal fragments of the coinbase
+// text (e.g. "/BlockfillsPool/"), which is exactly what we can test for -- no regex
+// dialect, no wildcards, no heuristics.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const OUT = path.join(ROOT, 'data', 'pool-map.json');
+const URL_ = 'https://raw.githubusercontent.com/mempool/mining-pools/master/pools-v2.json';
+
+const args = process.argv.slice(2);
+const asFile = args.includes('--file') ? path.resolve(args[args.indexOf('--file') + 1]) : null;
+const checkOnly = args.includes('--check');
+
+/** The whole scriptSig rendered as text, so a tag with non-ASCII bytes can still match. */
+function normalizeText(s) {
+  return String(s ?? '')
+    .replace(/\0+/g, ' ')
+    .replace(/[\x01-\x1f\x7f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function build(content, source) {
+  const list = JSON.parse(content);
+  if (!Array.isArray(list) || !list.length) throw new Error('pools-v2.json is not a non-empty array');
+  const pools = [];
+  for (const p of list) {
+    const name = (p.name ?? p.poolName ?? '').toString().trim();
+    if (!name) continue;
+    const tags = (p.tags ?? []).map((t) => String(t)).filter((t) => t.trim().length >= 2);
+    if (!tags.length) continue;
+    pools.push({
+      key: name.toLowerCase().replace(/\s+/g, ' '),
+      name,
+      slug: (p.slug ?? p.slugInfo?.slug ?? null) || null,
+      link: p.link ?? p.poolLinks?.[0]?.urls?.[0]?.url ?? null,
+      tags: tags.sort((a, b) => b.length - a.length),
+    });
+  }
+  // Longest tag wins, so "/Foundry USA Pool" is never stolen by a shorter overlapping tag.
+  const matchers = pools
+    .flatMap((p) => p.tags.map((tag) => ({ tag, tagNorm: normalizeText(tag), key: p.key, name: p.name })))
+    .filter((m) => m.tagNorm.length >= 3)
+    .sort((a, b) => b.tagNorm.length - a.tagNorm.length);
+  return {
+    source,
+    sourceSha256: crypto.createHash('sha256').update(content).digest('hex'),
+    fetchedAt: new Date().toISOString(),
+    attribution: 'mempool.space/mining-pools (MIT). Labels are their curated mapping, matched by literal coinbase text; unmatched blocks keep their raw tag and an unknown fingerprint.',
+    matchRule: 'longest literal tag substring wins, case-insensitive, on the whole coinbase scriptSig as text; tags shorter than 3 normalised characters are dropped',
+    pools,
+    matchers,
+  };
+}
+
+// node:https with family:4, not fetch(). Measured on this box: `fetch` handed the
+// request to every A and AAAA address, every IPv6 attempt was ENETUNREACH (this host has
+// no IPv6 route -- the node's own log says the same: "no global IPv6 route"), and the
+// call died inside a 20 s budget while an IPv4 socket to the same host was connecting in
+// 367 ms. Pinning the family is the fix; a curl fallback is kept because a tool that
+// fetches pool labels has to work on a box whose stack is half broken.
+import https from 'node:https';
+import { execFileSync } from 'node:child_process';
+
+function getOverHttps(url, redirectsLeft = 3, extra = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { family: 4, ...extra, headers: { 'user-agent': 'BlockYard pool-map/1' }, timeout: 20_000 }, (res) => {
+      if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location && redirectsLeft > 0) {
+        res.resume();
+        return resolve(getOverHttps(new URL(res.headers.location, url).toString(), redirectsLeft - 1));
+      }
+      if (res.statusCode !== 200) { res.resume(); return reject(new Error(`GET ${url} -> HTTP ${res.statusCode}`)); }
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+      res.on('error', reject);
+    });
+    req.on('timeout', () => req.destroy(new Error(`GET ${url} timed out`)));
+    req.on('error', reject);
+  });
+}
+
+async function fetchContent() {
+  try {
+    return await getOverHttps(URL_);
+  } catch (err) {
+    // curl follows its own resolver order and got 200 here while node's fetch failed,
+    // so a second, different path is worth one retry before declaring the fetch dead.
+    try {
+      return execFileSync('curl', ['-fsSL', '--max-time', '25', URL_], { encoding: 'utf8', maxBuffer: 8 << 20 });
+    } catch {
+      throw new Error(`could not fetch ${URL_}: ${err?.message ?? err}`);
+    }
+  }
+}
+
+const content = asFile ? fs.readFileSync(asFile, 'utf8') : await fetchContent();
+const map = build(content, asFile ? `file:${path.basename(asFile)}` : URL_);
+
+// What we are actually seeing right now, so the coverage number is measured and not
+// assumed. Read live from the running monitor if it answers; otherwise say it is unknown.
+let observed = null;
+let coverageError = null;
+try {
+  const cfgPath = path.join(ROOT, 'config', 'local.json');
+  const host = JSON.parse(fs.readFileSync(cfgPath, 'utf8'))?.server?.hosts?.[0] ?? '127.0.0.1';
+  // Same family:4 path as the fetch above, plus the box's own CA: the monitor serves TLS
+  // from a local CA that is not in the system trust store, and "could not verify" is a
+  // different fact from "could not reach".
+  const caFile = process.env.BLOCKYARD_CA_FILE ?? null;   // a CA file, only where the fetch needs a private one
+  const body = await getOverHttps(`https://${host}:8088/api/mining?node=main`, 0, fs.existsSync(caFile) ? { ca: fs.readFileSync(caFile) } : {});
+  const d = JSON.parse(body);
+  const rows = d.recent ?? [];
+  const hit = rows.filter((r) => map.matchers.some((m) => normalizeText(`${r.rawCoinbase ? Buffer.from(r.rawCoinbase, 'hex').toString('utf8') : ''} ${r.tagText || ''}`).includes(m.tagNorm))).length;
+  observed = {
+    blocks: rows.length, labelled: hit, unknown: rows.filter((r) => !r.poolLabel).length,
+    labelSource: d.labelSource ? `labels from ${d.labelSource.source} @ ${(d.labelSource.sha256 || '').slice(0, 10)}` : 'no map loaded by the monitor yet',
+  };
+} catch (err) {
+  coverageError = err?.message ?? String(err);
+}
+
+console.log(`pools: ${map.pools.length}  matchers: ${map.matchers.length}  sha256: ${map.sourceSha256.slice(0, 12)}`);
+if (observed) console.log(`coverage of the ${observed.blocks} attributed blocks: ${observed.labelled} matched a curated tag, ${observed.unknown} keep their raw tag\n  ${observed.labelSource ?? ''}`);
+else console.log(`coverage: not measured (${coverageError}) -- reported as unknown rather than assumed`);
+if (checkOnly) process.exit(0);
+
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+const tmp = `${OUT}.tmp`;
+fs.writeFileSync(tmp, `${JSON.stringify(map, null, 1)}\n`);
+fs.renameSync(tmp, OUT);
+console.log(`wrote ${path.relative(ROOT, OUT)}`);