Move WASM prover to Web Worker to prevent UI freezing

The Groth16 proof generation blocks the main thread for several seconds,
causing "page unresponsive" dialogs. Fix: run the WASM prover in a
dedicated Web Worker via prover-worker.js.

- prover.js: dispatches prove/verify/loadKeys to worker via postMessage
- prover-worker.js: loads Go WASM runtime, handles messages
- Falls back to main-thread execution if Workers unavailable
- poll.js: imports from prover.js module instead of window.bitwrapProver

Note: voteCast witness size mismatch (48 vs 46) is a pre-existing
circuit key issue on the server, not related to this change.

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

Author: stackdump

public/poll.js

@@ -3,6 +3,7 @@
 import { mimcHash } from './mimc.js';
 import { MerkleTree } from './merkle.js';
 import { buildVoteCastWitness } from './witness-builder.js';
+import { prove as workerProve, loadKeys, initProver } from './prover.js';
 
 // Current poll context
 window.currentPollId = null;
@@ -317,16 +318,15 @@ window.castVote = async function() {
 
         btn.innerHTML = '<span class="spinner"></span>Generating proof...';
 
-        // Try WASM prover first (privacy-preserving), fall back to server
+        // Try WASM prover in Web Worker first (non-blocking), fall back to server
         let proofData;
         let clientSideProved = false;
-        if (window.bitwrapProver && window.bitwrapProver.prove) {
-            try {
-                proofData = await window.bitwrapProver.prove(witnessResult.circuit, witnessResult.witness);
-                clientSideProved = true;
-            } catch (e) {
-                console.warn('Client-side proving failed, falling back to server:', e);
-            }
+        try {
+            await initProver();
+            proofData = await workerProve(witnessResult.circuit, witnessResult.witness);
+            clientSideProved = true;
+        } catch (e) {
+            console.warn('Client-side proving failed, falling back to server:', e);
         }
         if (!clientSideProved) {
             const resp = await fetch('/api/prove', {

public/prover-worker.js

@@ -0,0 +1,84 @@
+// Web Worker for WASM Groth16 prover — runs off the main thread.
+// The main thread communicates via postMessage.
+
+let proverReady = false;
+
+// Load Go WASM runtime inside the worker
+importScripts('./wasm_exec.js');
+
+async function initWasm() {
+  const go = new Go();
+  const result = await WebAssembly.instantiateStreaming(fetch('./prover.wasm'), go.importObject);
+  go.run(result.instance);
+
+  // Wait for bitwrapProver global
+  for (let i = 0; i < 100; i++) {
+    if (typeof bitwrapProver !== 'undefined') {
+      proverReady = true;
+      return;
+    }
+    await new Promise(r => setTimeout(r, 50));
+  }
+  throw new Error('WASM prover did not initialize');
+}
+
+const initPromise = initWasm().catch(e => {
+  postMessage({ type: 'error', error: `WASM init failed: ${e.message}` });
+});
+
+onmessage = async function(e) {
+  const { id, type, payload } = e.data;
+
+  try {
+    await initPromise;
+    if (!proverReady) throw new Error('Prover not ready');
+
+    let result;
+    switch (type) {
+      case 'loadKeys': {
+        const { name, csBytes, pkBytes, vkBytes } = payload;
+        result = bitwrapProver.loadKeys(name, csBytes, pkBytes, vkBytes);
+        if (result.error) throw new Error(result.error);
+        postMessage({ id, type: 'loadKeys', result });
+        break;
+      }
+
+      case 'prove': {
+        const { circuit, witness } = payload;
+        result = bitwrapProver.prove(circuit, JSON.stringify(witness));
+        if (result.error) throw new Error(result.error);
+        postMessage({ id, type: 'prove', result: {
+          proof: result.proof,
+          publicWitness: result.publicWitness,
+        }});
+        break;
+      }
+
+      case 'verify': {
+        const { circuit, proof, publicWitness } = payload;
+        result = bitwrapProver.verify(circuit, proof, publicWitness);
+        postMessage({ id, type: 'verify', result });
+        break;
+      }
+
+      case 'mimcHash': {
+        const { args } = payload;
+        result = bitwrapProver.mimcHash(...args.map(String));
+        if (typeof result === 'object' && result.error) throw new Error(result.error);
+        postMessage({ id, type: 'mimcHash', result: String(result) });
+        break;
+      }
+
+      case 'listCircuits': {
+        result = bitwrapProver.listCircuits();
+        postMessage({ id, type: 'listCircuits', result });
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  } catch (err) {
+    postMessage({ id, type: 'error', error: err.message });
+  }
+};

public/prover.js

@@ -1,54 +1,89 @@
-// bitwrap WASM prover — client-side Groth16 proving
-// Loads prover.wasm and exposes async API over bitwrapProver global
+// bitwrap WASM prover — runs Groth16 proving in a Web Worker to avoid blocking UI.
+// Falls back to main-thread execution if Workers are unavailable.
 
-let _ready = null;
+let _worker = null;
+let _pending = {};
+let _msgId = 0;
 let _keyCache = {};
+let _initPromise = null;
+
+function sendWorkerMessage(type, payload) {
+  return new Promise((resolve, reject) => {
+    const id = ++_msgId;
+    _pending[id] = { resolve, reject };
+    _worker.postMessage({ id, type, payload });
+  });
+}
 
-// Initialize the WASM prover. Call once, awaits loading.
-export async function initProver(wasmUrl = './prover.wasm', execUrl = './wasm_exec.js') {
-  if (_ready) return _ready;
+// Initialize the prover (Web Worker with WASM).
+export async function initProver() {
+  if (_initPromise) return _initPromise;
+
+  _initPromise = (async () => {
+    if (typeof Worker !== 'undefined') {
+      try {
+        _worker = new Worker('./prover-worker.js');
+        _worker.onmessage = (e) => {
+          const { id, type, result, error } = e.data;
+          if (id && _pending[id]) {
+            if (type === 'error') {
+              _pending[id].reject(new Error(error));
+            } else {
+              _pending[id].resolve(result);
+            }
+            delete _pending[id];
+          }
+        };
+        _worker.onerror = (e) => {
+          console.warn('Prover worker error, falling back to main thread:', e.message);
+          _worker = null;
+        };
+        // Give the worker a moment to initialize
+        await new Promise(r => setTimeout(r, 100));
+        return;
+      } catch (e) {
+        console.warn('Worker creation failed, falling back to main thread:', e);
+        _worker = null;
+      }
+    }
 
-  _ready = (async () => {
-    // Load wasm_exec.js if Go runtime not present
+    // Fallback: load on main thread (blocks UI during prove)
     if (typeof Go === 'undefined') {
       await new Promise((resolve, reject) => {
         const script = document.createElement('script');
-        script.src = execUrl;
+        script.src = './wasm_exec.js';
         script.onload = resolve;
         script.onerror = () => reject(new Error('Failed to load wasm_exec.js'));
         document.head.appendChild(script);
       });
     }
 
     const go = new Go();
-    const result = await WebAssembly.instantiateStreaming(fetch(wasmUrl), go.importObject);
-    go.run(result.instance); // starts the Go main() goroutine
+    const result = await WebAssembly.instantiateStreaming(fetch('./prover.wasm'), go.importObject);
+    go.run(result.instance);
 
-    // Wait for bitwrapProver to be set
     for (let i = 0; i < 100; i++) {
       if (typeof bitwrapProver !== 'undefined') return;
       await new Promise(r => setTimeout(r, 50));
     }
     throw new Error('WASM prover did not initialize');
   })();
 
-  return _ready;
+  return _initPromise;
 }
 
-// Compile a circuit from scratch (slow — runs trusted setup in WASM).
-// Returns { constraints, publicVars, privateVars } or throws.
 export async function compileCircuit(name) {
   await initProver();
+  if (_worker) {
+    return sendWorkerMessage('compileCircuit', { name });
+  }
   const result = bitwrapProver.compileCircuit(name);
   if (result.error) throw new Error(result.error);
   return result;
 }
 
-// Load pre-compiled keys from the server (fast — skips compilation).
-// Fetches .cs, .pk, .vk from keyUrl/{name}.cs etc.
 export async function loadKeys(name, keyUrl) {
   await initProver();
-
   if (_keyCache[name]) return _keyCache[name];
 
   const [csResp, pkResp, vkResp] = await Promise.all([
@@ -67,40 +102,53 @@ export async function loadKeys(name, keyUrl) {
     vkResp.arrayBuffer().then(b => new Uint8Array(b)),
   ]);
 
+  if (_worker) {
+    const result = await sendWorkerMessage('loadKeys', { name, csBytes, pkBytes, vkBytes });
+    _keyCache[name] = result;
+    return result;
+  }
+
   const result = bitwrapProver.loadKeys(name, csBytes, pkBytes, vkBytes);
   if (result.error) throw new Error(result.error);
   _keyCache[name] = result;
   return result;
 }
 
-// Generate a Groth16 proof. Returns { proof: Uint8Array, publicWitness: Uint8Array }.
-// witness is an object with string keys and string values (decimal field elements).
+// Generate a Groth16 proof — runs in Web Worker (non-blocking).
 export async function prove(circuitName, witness) {
   await initProver();
+  if (_worker) {
+    return sendWorkerMessage('prove', { circuit: circuitName, witness });
+  }
+  // Fallback: main thread (will block UI)
   const result = bitwrapProver.prove(circuitName, JSON.stringify(witness));
   if (result.error) throw new Error(result.error);
-  return {
-    proof: result.proof,
-    publicWitness: result.publicWitness,
-  };
+  return { proof: result.proof, publicWitness: result.publicWitness };
 }
 
-// Verify a proof. Returns { valid: boolean, error?: string }.
 export async function verify(circuitName, proof, publicWitness) {
   await initProver();
+  if (_worker) {
+    return sendWorkerMessage('verify', { circuit: circuitName, proof, publicWitness });
+  }
   return bitwrapProver.verify(circuitName, proof, publicWitness);
 }
 
-// Compute MiMC hash (convenience — also available in mimc.js without WASM).
 export async function mimcHash(...args) {
   await initProver();
+  if (_worker) {
+    const result = await sendWorkerMessage('mimcHash', { args: args.map(String) });
+    return BigInt(result);
+  }
   const result = bitwrapProver.mimcHash(...args.map(String));
   if (typeof result === 'object' && result.error) throw new Error(result.error);
   return BigInt(result);
 }
 
-// List loaded circuits.
 export async function listCircuits() {
   await initProver();
+  if (_worker) {
+    return sendWorkerMessage('listCircuits', {});
+  }
   return bitwrapProver.listCircuits();
 }