Wire SwiftSync into the running node (node.html)

node-worker.js gains a 'swiftsync' command: a 32-byte accumulator runs the
set-consistency check (add created, subtract spent; closed against start/terminal
snapshots -> zero) alongside script validation, in the worker. node.html shows a
'set consistency' card. Honest copy: for the bounded range it's a demonstration;
its load-bearing value is at scale (it removes the ~25 GB UTXO-set requirement).

Verified in-browser: set consistency ✓ reconciled, 32-byte state, in the running node.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Melvin Carvalho

node-worker.js

@@ -7,6 +7,9 @@ import { loadEngine, coinviewOf } from './validate-forward.js';
 import { ShardedUtxo } from './sharded-utxo-browser.js';
 import { followChain } from './follow-chain.js';
 import { setVerifyBackend } from './engine/codec/secp256k1.js';
+import { sha256 } from './engine/codec/hash.js';
+import { Accumulator } from './swiftsync/accumulator.js';
+import { encodeOutpoint } from './swiftsync/outpoint.js';
 
 let codec, be;
 let snap = null;             // the worker's RAM-resident coin view
@@ -35,6 +38,31 @@ async function followRange() {
   return { validated: r.validated, total: r.total, utxoStart: start, utxoEnd: snap.size, start: range.start, end: range.end, ms: performance.now() - t0 };
 }
 
+// SwiftSync set-consistency over the same range: a constant 32-byte accumulator
+// (add created outputs, subtract spent inputs) replaces holding the UTXO set for
+// double-spend / fabrication checks. Closed against the start (seed) + terminal
+// (survivors) snapshots, a valid range cancels to zero.
+async function swiftsync() {
+  const NULL = '00'.repeat(32);
+  const acc = new Accumulator({ sha256 });
+  const seed = await (await fetch('data/range-seed.ndjson')).text();
+  let first = true, seedN = 0;
+  for (const l of seed.split('\n')) { if (!l) continue; if (first) { first = false; continue; } const [k] = JSON.parse(l); const i = k.lastIndexOf(':'); acc.add(encodeOutpoint({ txid: k.slice(0, i), vout: +k.slice(i + 1) })); seedN++; }
+  const range = await (await fetch('data/range.json')).json();
+  const survivors = new Set();
+  let created = 0, spent = 0; const t0 = performance.now();
+  for (const hex of range.blocks) {
+    const block = codec.decode('Block', hex);
+    for (const tx of block.transactions) {
+      const txid = codec.txid(tx);
+      for (const inp of tx.inputs) { if (inp.prevout.txid === NULL) continue; acc.spend(encodeOutpoint({ txid: inp.prevout.txid, vout: inp.prevout.vout })); spent++; survivors.delete(`${inp.prevout.txid}:${inp.prevout.vout}`); }
+      for (let v = 0; v < tx.outputs.length; v++) { const s = tx.outputs[v].scriptPubKey; if (typeof s === 'string' && s.startsWith('6a')) continue; acc.add(encodeOutpoint({ txid, vout: v })); created++; survivors.add(`${txid}:${v}`); }
+    }
+  }
+  for (const k of survivors) { const i = k.lastIndexOf(':'); acc.spend(encodeOutpoint({ txid: k.slice(0, i), vout: +k.slice(i + 1) })); }
+  return { zero: acc.isZero(), seedN, created, spent, terminal: survivors.size, stateBytes: 32, ms: performance.now() - t0 };
+}
+
 // Checkpoint the coin view via an OPFS *synchronous access handle* (Worker-only).
 async function checkpoint() {
   if (!snap) throw new Error('no coin view — run followRange first');
@@ -64,7 +92,7 @@ async function resume() {
   return { coins: snap.size };
 }
 
-const handlers = { init, followRange, checkpoint, resume };
+const handlers = { init, followRange, checkpoint, resume, swiftsync };
 self.onmessage = async (e) => {
   const { id, cmd } = e.data;
   try { self.postMessage({ id, ok: true, result: await handlers[cmd]() }); }

node.html

@@ -26,7 +26,8 @@
 <h1>bitcoin-kernel / browser-node — running node <span class="dim">(testnet4)</span></h1>
 <p class="dim">The capstone: one continuous pipeline. Headers stream from a real peer over the bridge; the UTXO set is
 bootstrapped from a snapshot; blocks are validated forward and applied — the engine, WASM secp, UTXO set and OPFS
-persistence all run in a <b>Web Worker</b>. <a href="index.html">← the eleven acts, explained</a></p>
+persistence all run in a <b>Web Worker</b>, and set-consistency is checked with a <b>SwiftSync 32-byte accumulator</b>
+(not the full UTXO set). <a href="index.html">← the eleven acts, explained</a></p>
 
 <p><button id="start">▶ Start node</button> <span id="status" class="dim">idle</span></p>
 
@@ -37,16 +38,19 @@ <h1>bitcoin-kernel / browser-node — running node <span class="dim">(testnet4)<
   <div class="card"><div class="k">UTXO set</div><div class="v" id="utxo">—</div><div class="s">RAM, checkpointed to OPFS</div></div>
   <div class="card"><div class="k">blocks validated</div><div class="v" id="nblocks">0</div><div class="s" id="bps"></div></div>
   <div class="card"><div class="k">persistence</div><div class="v" id="ckpt">—</div><div class="s">OPFS sync access handle</div></div>
+  <div class="card"><div class="k">set consistency</div><div class="v" id="swift">—</div><div class="s" id="swiftsub">SwiftSync · 32-byte accumulator</div></div>
 </div>
 <div id="log"></div>
 
 <p class="dim" style="margin-top:14px; border-top:1px solid var(--bd); padding-top:10px">
 Honest scope: this runs the node's real loop over a bounded range of real testnet4 blocks. Reaching the live tip
 with the <b>full</b> UTXO set hits a memory wall — the whole 14.1M-coin set is ~25 GB, over a tab's limit.
 <a href="index.html#">SwiftSync (act ⑪)</a> removes it: validate set-consistency with a <b>32-byte accumulator</b> instead of
-the set. Wiring SwiftSync into this worker loop (with a WebTorrent hints file) is the next step;
-<code>tools/reach-tip.mjs</code> already reaches the live tip today by keeping only the coins the forward blocks
-spend. Header sync needs the local bridge (<code>node bridge.mjs</code> + a testnet4 node); without it the
+the set — <b>now wired into this loop</b> (the "set consistency" card above). What remains is applying it at
+<i>scale</i>: a large range / full IBD with a WebTorrent hints file + streamed prevout data for scripts, so the node
+validates to the live tip holding nothing but the accumulator. <code>tools/reach-tip.mjs</code> already reaches the
+live tip today by keeping only the coins the forward blocks spend. Header sync needs the local bridge
+(<code>node bridge.mjs</code> + a testnet4 node); without it the
 validation pipeline still runs.</p>
 
 <script type="module">
@@ -119,6 +123,12 @@ <h1>bitcoin-kernel / browser-node — running node <span class="dim">(testnet4)<
     $('ckpt').textContent = (ck.bytes/1048576).toFixed(2) + ' MB';
     log(`UTXO set checkpointed to OPFS (${(ck.bytes/1048576).toFixed(2)} MB, sync access handle)`, 'ok');
 
+    // SwiftSync set-consistency check in the worker — 32-byte state, no UTXO set
+    const ss = await wcall('swiftsync');
+    $('swift').innerHTML = ss.zero ? '<span class="ok">✓ reconciled</span>' : '<span class="err">✗ non-zero</span>';
+    $('swiftsub').textContent = `SwiftSync · ${ss.stateBytes} bytes · ${fmt(ss.created)}+ ${fmt(ss.spent)}− · ${ss.ms.toFixed(0)}ms`;
+    log(`SwiftSync set-consistency: ${ss.zero ? 'reconciles to ZERO' : 'NON-ZERO'} with ${ss.stateBytes} bytes — no UTXO set held for double-spend checks (the path past the 25 GB ceiling at scale)`, ss.zero ? 'ok' : 'err');
+
     setStatus(`● running — fully validated to #${fmt(r.end)}; watching the tip`, 'ok');
     log('node running. Headers live from the network; UTXO bootstrapped + validated forward in the worker.', 'ok');
   } catch (e) { setStatus('error: ' + e.message, 'err'); log('node error: ' + e.message, 'err'); console.error(e); $('start').disabled = false; }