@zktable/prover-web 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zkTable contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,196 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TREE_DEPTH: () => TREE_DEPTH,
+  buildEdgeTree: () => buildEdgeTree,
+  bytesToHex: () => bytesToHex,
+  canonicalEdges: () => canonicalEdges,
+  createWebProver: () => createWebProver,
+  initPoseidon: () => initPoseidon,
+  merklePath: () => merklePath,
+  poseidon2: () => poseidon2,
+  toBe32Blob: () => toBe32Blob,
+  toBe32Hex: () => toBe32Hex
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/prover.ts
+var import_bb2 = require("@aztec/bb.js");
+var import_noir_js = require("@noir-lang/noir_js");
+
+// src/fields.ts
+var import_bb = require("@aztec/bb.js");
+var sync = null;
+async function initPoseidon() {
+  if (sync) return;
+  sync = await import_bb.BarretenbergSync.initSingleton();
+}
+function toFr(value) {
+  return new import_bb.Fr(value);
+}
+function frToBigInt(fr) {
+  return BigInt(fr.toString());
+}
+function poseidon2(a, b) {
+  if (!sync) throw new Error("poseidon2: call initPoseidon() first");
+  return frToBigInt(sync.poseidon2Hash([toFr(a), toFr(b)]));
+}
+function bytesToHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function toBe32Hex(value) {
+  if (value < 0n) throw new Error("toBe32Hex: value must be non-negative");
+  const hex = value.toString(16);
+  if (hex.length > 64) throw new Error("toBe32Hex: value does not fit in 32 bytes");
+  return hex.padStart(64, "0");
+}
+function toBe32Blob(values) {
+  const out = new Uint8Array(values.length * 32);
+  values.forEach((v, i) => {
+    const hex = toBe32Hex(v);
+    for (let j = 0; j < 32; j++) {
+      out[i * 32 + j] = parseInt(hex.slice(j * 2, j * 2 + 2), 16);
+    }
+  });
+  return out;
+}
+
+// src/graph.ts
+var TREE_DEPTH = 10;
+var N_LEAVES = 1 << TREE_DEPTH;
+function canonicalEdges(graph) {
+  const set = [];
+  const bidirectional = graph.bidirectional ?? true;
+  for (const e of graph.edges) {
+    set.push([e.from, e.to, e.ticket]);
+    if (bidirectional) set.push([e.to, e.from, e.ticket]);
+  }
+  set.sort((a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2]);
+  return set.filter((e, i) => i === 0 || e[0] !== set[i - 1][0] || e[1] !== set[i - 1][1] || e[2] !== set[i - 1][2]);
+}
+function edgeLeaf(from, to, ticket) {
+  return poseidon2(poseidon2(from, to), ticket);
+}
+function edgeKey(e) {
+  return `${e[0]},${e[1]},${e[2]}`;
+}
+function buildEdgeTree(graph) {
+  const edges = canonicalEdges(graph);
+  if (edges.length > N_LEAVES) throw new Error("too many edges for TREE_DEPTH");
+  const indexByEdge = /* @__PURE__ */ new Map();
+  const leaves = [];
+  edges.forEach((e, i) => {
+    indexByEdge.set(edgeKey(e), i);
+    leaves.push(edgeLeaf(BigInt(e[0]), BigInt(e[1]), BigInt(e[2])));
+  });
+  while (leaves.length < N_LEAVES) leaves.push(0n);
+  const levels = [leaves];
+  for (let d = 0; d < TREE_DEPTH; d++) {
+    const prev = levels[d];
+    const next = [];
+    for (let i = 0; i < prev.length; i += 2) {
+      next.push(poseidon2(prev[i], prev[i + 1]));
+    }
+    levels.push(next);
+  }
+  return { levels, indexByEdge, root: levels[TREE_DEPTH][0] };
+}
+function merklePath(tree, edge) {
+  const idx = tree.indexByEdge.get(edgeKey(edge));
+  if (idx === void 0) {
+    throw new Error(`edge (${edge[0]},${edge[1]},ticket=${edge[2]}) not in graph`);
+  }
+  const siblings = [];
+  const bits = [];
+  let pos = idx;
+  for (let d = 0; d < TREE_DEPTH; d++) {
+    const bit = pos & 1;
+    const sib = bit === 0 ? pos + 1 : pos - 1;
+    siblings.push(tree.levels[d][sib]);
+    bits.push(bit);
+    pos >>= 1;
+  }
+  return { siblings, bits };
+}
+
+// src/prover.ts
+async function createWebProver(artifacts) {
+  await initPoseidon();
+  const tree = buildEdgeTree(artifacts.graph);
+  const noir = new import_noir_js.Noir(artifacts.circuit);
+  const backend = new import_bb2.UltraHonkBackend(artifacts.circuit.bytecode);
+  return {
+    commit(node, salt) {
+      return toBe32Hex(poseidon2(BigInt(node), salt));
+    },
+    root() {
+      return toBe32Hex(tree.root);
+    },
+    async prove(move) {
+      const cOld = poseidon2(BigInt(move.from), move.saltOld);
+      const cNew = poseidon2(BigInt(move.to), move.saltNew);
+      const { siblings, bits } = merklePath(tree, [move.from, move.to, move.ticket]);
+      const { witness } = await noir.execute({
+        c_old: cOld.toString(),
+        c_new: cNew.toString(),
+        ticket: String(move.ticket),
+        root: tree.root.toString(),
+        from: String(move.from),
+        salt_old: move.saltOld.toString(),
+        to: String(move.to),
+        salt_new: move.saltNew.toString(),
+        path_siblings: siblings.map((s) => s.toString()),
+        path_bits: bits.map((b) => String(b))
+      });
+      const { proof } = await backend.generateProof(witness, { keccak: true });
+      return {
+        proof,
+        publicInputs: toBe32Blob([cOld, cNew, BigInt(move.ticket), tree.root]),
+        cOldHex: toBe32Hex(cOld),
+        cNewHex: toBe32Hex(cNew),
+        rootHex: toBe32Hex(tree.root),
+        ticket: move.ticket
+      };
+    },
+    async verifyLocally(p) {
+      const publicInputs = [p.cOldHex, p.cNewHex, toBe32Hex(BigInt(p.ticket)), p.rootHex].map(
+        (word) => `0x${word}`
+      );
+      return backend.verifyProof({ proof: p.proof, publicInputs }, { keccak: true });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TREE_DEPTH,
+  buildEdgeTree,
+  bytesToHex,
+  canonicalEdges,
+  createWebProver,
+  initPoseidon,
+  merklePath,
+  poseidon2,
+  toBe32Blob,
+  toBe32Hex
+});

package/dist/index.d.cts

@@ -0,0 +1,80 @@
+import { CompiledCircuit } from '@noir-lang/noir_js';
+
+declare const TREE_DEPTH = 10;
+type GraphData = {
+    nodes?: number[];
+    edges: Array<{
+        from: number;
+        to: number;
+        ticket: number;
+    }>;
+    /** If true (default), each listed edge is expanded to both directions. */
+    bidirectional?: boolean;
+};
+type Edge = [from: number, to: number, ticket: number];
+/** Canonical directed edge list: expand bidirectional, dedupe, sort. */
+declare function canonicalEdges(graph: GraphData): Edge[];
+type EdgeTree = {
+    levels: bigint[][];
+    indexByEdge: Map<string, number>;
+    root: bigint;
+};
+/** Full depth-10 tree; levels[0] = leaves (zero-padded), levels[10] = [root]. */
+declare function buildEdgeTree(graph: GraphData): EdgeTree;
+type MerklePath = {
+    siblings: bigint[];
+    bits: number[];
+};
+/** Authentication path for the edge (from, to, ticket). bit=0 -> node is left. */
+declare function merklePath(tree: EdgeTree, edge: Edge): MerklePath;
+
+type WebBoardProof = {
+    /** UltraHonk proof bytes (14592) — hex these into `submit_hidden_move`. */
+    proof: Uint8Array;
+    /** c_old | c_new | ticket | root (128 bytes) — the verifier's public-inputs blob. */
+    publicInputs: Uint8Array;
+    cOldHex: string;
+    cNewHex: string;
+    rootHex: string;
+    ticket: number;
+};
+type WebProverArtifacts = {
+    /** The compiled `move_along` ACIR artifact (target/move_along.json, parsed). */
+    circuit: CompiledCircuit;
+    /** The public city graph (same JSON `zktable-graph` consumes). */
+    graph: GraphData;
+};
+type WebBoardProver = {
+    /** Poseidon2(node, salt) as 32-byte hex — hidden-position commitments. */
+    commit(node: number, salt: bigint): string;
+    /** The edge-tree root as 32-byte hex (per-map public constant). */
+    root(): string;
+    /** Prove one hidden move. The secret (from/to/salts) never leaves the caller. */
+    prove(move: {
+        from: number;
+        to: number;
+        ticket: 0 | 1 | 2;
+        saltOld: bigint;
+        saltNew: bigint;
+    }): Promise<WebBoardProof>;
+    /** Local verification against the circuit's own (keccak) verification key. */
+    verifyLocally(proof: WebBoardProof): Promise<boolean>;
+};
+/**
+ * Builds a browser prover: initializes the Poseidon2 WASM, precomputes the
+ * public edge tree, and holds a lazily-created UltraHonk backend.
+ */
+declare function createWebProver(artifacts: WebProverArtifacts): Promise<WebBoardProver>;
+
+/** One-time WASM init (idempotent). Call before any `poseidon2` use. */
+declare function initPoseidon(): Promise<void>;
+/** Poseidon2 over exactly two field elements — zkTable's universal `hash2`. */
+declare function poseidon2(a: bigint, b: bigint): bigint;
+/** Lowercase hex (no 0x prefix) for arbitrary bytes — proofs, salts, blobs. */
+declare function bytesToHex(bytes: Uint8Array): string;
+/** 32-byte big-endian hex (no 0x prefix) — the CLI/contract Bytes encoding. */
+declare function toBe32Hex(value: bigint): string;
+/** Concatenate values as 32-byte big-endian words (the public-inputs blob shape). */
+declare function toBe32Blob(values: bigint[]): Uint8Array;
+
+export { type Edge, type EdgeTree, type GraphData, type MerklePath, TREE_DEPTH, type WebBoardProof, type WebBoardProver, type WebProverArtifacts, buildEdgeTree, bytesToHex, canonicalEdges, createWebProver, initPoseidon, merklePath, poseidon2, toBe32Blob, toBe32Hex };

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+import { CompiledCircuit } from '@noir-lang/noir_js';
+
+declare const TREE_DEPTH = 10;
+type GraphData = {
+    nodes?: number[];
+    edges: Array<{
+        from: number;
+        to: number;
+        ticket: number;
+    }>;
+    /** If true (default), each listed edge is expanded to both directions. */
+    bidirectional?: boolean;
+};
+type Edge = [from: number, to: number, ticket: number];
+/** Canonical directed edge list: expand bidirectional, dedupe, sort. */
+declare function canonicalEdges(graph: GraphData): Edge[];
+type EdgeTree = {
+    levels: bigint[][];
+    indexByEdge: Map<string, number>;
+    root: bigint;
+};
+/** Full depth-10 tree; levels[0] = leaves (zero-padded), levels[10] = [root]. */
+declare function buildEdgeTree(graph: GraphData): EdgeTree;
+type MerklePath = {
+    siblings: bigint[];
+    bits: number[];
+};
+/** Authentication path for the edge (from, to, ticket). bit=0 -> node is left. */
+declare function merklePath(tree: EdgeTree, edge: Edge): MerklePath;
+
+type WebBoardProof = {
+    /** UltraHonk proof bytes (14592) — hex these into `submit_hidden_move`. */
+    proof: Uint8Array;
+    /** c_old | c_new | ticket | root (128 bytes) — the verifier's public-inputs blob. */
+    publicInputs: Uint8Array;
+    cOldHex: string;
+    cNewHex: string;
+    rootHex: string;
+    ticket: number;
+};
+type WebProverArtifacts = {
+    /** The compiled `move_along` ACIR artifact (target/move_along.json, parsed). */
+    circuit: CompiledCircuit;
+    /** The public city graph (same JSON `zktable-graph` consumes). */
+    graph: GraphData;
+};
+type WebBoardProver = {
+    /** Poseidon2(node, salt) as 32-byte hex — hidden-position commitments. */
+    commit(node: number, salt: bigint): string;
+    /** The edge-tree root as 32-byte hex (per-map public constant). */
+    root(): string;
+    /** Prove one hidden move. The secret (from/to/salts) never leaves the caller. */
+    prove(move: {
+        from: number;
+        to: number;
+        ticket: 0 | 1 | 2;
+        saltOld: bigint;
+        saltNew: bigint;
+    }): Promise<WebBoardProof>;
+    /** Local verification against the circuit's own (keccak) verification key. */
+    verifyLocally(proof: WebBoardProof): Promise<boolean>;
+};
+/**
+ * Builds a browser prover: initializes the Poseidon2 WASM, precomputes the
+ * public edge tree, and holds a lazily-created UltraHonk backend.
+ */
+declare function createWebProver(artifacts: WebProverArtifacts): Promise<WebBoardProver>;
+
+/** One-time WASM init (idempotent). Call before any `poseidon2` use. */
+declare function initPoseidon(): Promise<void>;
+/** Poseidon2 over exactly two field elements — zkTable's universal `hash2`. */
+declare function poseidon2(a: bigint, b: bigint): bigint;
+/** Lowercase hex (no 0x prefix) for arbitrary bytes — proofs, salts, blobs. */
+declare function bytesToHex(bytes: Uint8Array): string;
+/** 32-byte big-endian hex (no 0x prefix) — the CLI/contract Bytes encoding. */
+declare function toBe32Hex(value: bigint): string;
+/** Concatenate values as 32-byte big-endian words (the public-inputs blob shape). */
+declare function toBe32Blob(values: bigint[]): Uint8Array;
+
+export { type Edge, type EdgeTree, type GraphData, type MerklePath, TREE_DEPTH, type WebBoardProof, type WebBoardProver, type WebProverArtifacts, buildEdgeTree, bytesToHex, canonicalEdges, createWebProver, initPoseidon, merklePath, poseidon2, toBe32Blob, toBe32Hex };

package/dist/index.js

@@ -0,0 +1,160 @@
+// src/prover.ts
+import { UltraHonkBackend } from "@aztec/bb.js";
+import { Noir } from "@noir-lang/noir_js";
+
+// src/fields.ts
+import { BarretenbergSync, Fr } from "@aztec/bb.js";
+var sync = null;
+async function initPoseidon() {
+  if (sync) return;
+  sync = await BarretenbergSync.initSingleton();
+}
+function toFr(value) {
+  return new Fr(value);
+}
+function frToBigInt(fr) {
+  return BigInt(fr.toString());
+}
+function poseidon2(a, b) {
+  if (!sync) throw new Error("poseidon2: call initPoseidon() first");
+  return frToBigInt(sync.poseidon2Hash([toFr(a), toFr(b)]));
+}
+function bytesToHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function toBe32Hex(value) {
+  if (value < 0n) throw new Error("toBe32Hex: value must be non-negative");
+  const hex = value.toString(16);
+  if (hex.length > 64) throw new Error("toBe32Hex: value does not fit in 32 bytes");
+  return hex.padStart(64, "0");
+}
+function toBe32Blob(values) {
+  const out = new Uint8Array(values.length * 32);
+  values.forEach((v, i) => {
+    const hex = toBe32Hex(v);
+    for (let j = 0; j < 32; j++) {
+      out[i * 32 + j] = parseInt(hex.slice(j * 2, j * 2 + 2), 16);
+    }
+  });
+  return out;
+}
+
+// src/graph.ts
+var TREE_DEPTH = 10;
+var N_LEAVES = 1 << TREE_DEPTH;
+function canonicalEdges(graph) {
+  const set = [];
+  const bidirectional = graph.bidirectional ?? true;
+  for (const e of graph.edges) {
+    set.push([e.from, e.to, e.ticket]);
+    if (bidirectional) set.push([e.to, e.from, e.ticket]);
+  }
+  set.sort((a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2]);
+  return set.filter((e, i) => i === 0 || e[0] !== set[i - 1][0] || e[1] !== set[i - 1][1] || e[2] !== set[i - 1][2]);
+}
+function edgeLeaf(from, to, ticket) {
+  return poseidon2(poseidon2(from, to), ticket);
+}
+function edgeKey(e) {
+  return `${e[0]},${e[1]},${e[2]}`;
+}
+function buildEdgeTree(graph) {
+  const edges = canonicalEdges(graph);
+  if (edges.length > N_LEAVES) throw new Error("too many edges for TREE_DEPTH");
+  const indexByEdge = /* @__PURE__ */ new Map();
+  const leaves = [];
+  edges.forEach((e, i) => {
+    indexByEdge.set(edgeKey(e), i);
+    leaves.push(edgeLeaf(BigInt(e[0]), BigInt(e[1]), BigInt(e[2])));
+  });
+  while (leaves.length < N_LEAVES) leaves.push(0n);
+  const levels = [leaves];
+  for (let d = 0; d < TREE_DEPTH; d++) {
+    const prev = levels[d];
+    const next = [];
+    for (let i = 0; i < prev.length; i += 2) {
+      next.push(poseidon2(prev[i], prev[i + 1]));
+    }
+    levels.push(next);
+  }
+  return { levels, indexByEdge, root: levels[TREE_DEPTH][0] };
+}
+function merklePath(tree, edge) {
+  const idx = tree.indexByEdge.get(edgeKey(edge));
+  if (idx === void 0) {
+    throw new Error(`edge (${edge[0]},${edge[1]},ticket=${edge[2]}) not in graph`);
+  }
+  const siblings = [];
+  const bits = [];
+  let pos = idx;
+  for (let d = 0; d < TREE_DEPTH; d++) {
+    const bit = pos & 1;
+    const sib = bit === 0 ? pos + 1 : pos - 1;
+    siblings.push(tree.levels[d][sib]);
+    bits.push(bit);
+    pos >>= 1;
+  }
+  return { siblings, bits };
+}
+
+// src/prover.ts
+async function createWebProver(artifacts) {
+  await initPoseidon();
+  const tree = buildEdgeTree(artifacts.graph);
+  const noir = new Noir(artifacts.circuit);
+  const backend = new UltraHonkBackend(artifacts.circuit.bytecode);
+  return {
+    commit(node, salt) {
+      return toBe32Hex(poseidon2(BigInt(node), salt));
+    },
+    root() {
+      return toBe32Hex(tree.root);
+    },
+    async prove(move) {
+      const cOld = poseidon2(BigInt(move.from), move.saltOld);
+      const cNew = poseidon2(BigInt(move.to), move.saltNew);
+      const { siblings, bits } = merklePath(tree, [move.from, move.to, move.ticket]);
+      const { witness } = await noir.execute({
+        c_old: cOld.toString(),
+        c_new: cNew.toString(),
+        ticket: String(move.ticket),
+        root: tree.root.toString(),
+        from: String(move.from),
+        salt_old: move.saltOld.toString(),
+        to: String(move.to),
+        salt_new: move.saltNew.toString(),
+        path_siblings: siblings.map((s) => s.toString()),
+        path_bits: bits.map((b) => String(b))
+      });
+      const { proof } = await backend.generateProof(witness, { keccak: true });
+      return {
+        proof,
+        publicInputs: toBe32Blob([cOld, cNew, BigInt(move.ticket), tree.root]),
+        cOldHex: toBe32Hex(cOld),
+        cNewHex: toBe32Hex(cNew),
+        rootHex: toBe32Hex(tree.root),
+        ticket: move.ticket
+      };
+    },
+    async verifyLocally(p) {
+      const publicInputs = [p.cOldHex, p.cNewHex, toBe32Hex(BigInt(p.ticket)), p.rootHex].map(
+        (word) => `0x${word}`
+      );
+      return backend.verifyProof({ proof: p.proof, publicInputs }, { keccak: true });
+    }
+  };
+}
+export {
+  TREE_DEPTH,
+  buildEdgeTree,
+  bytesToHex,
+  canonicalEdges,
+  createWebProver,
+  initPoseidon,
+  merklePath,
+  poseidon2,
+  toBe32Blob,
+  toBe32Hex
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zktable/prover-web",
+  "version": "0.1.0",
+  "description": "Browser-side UltraHonk prover helpers for zkTable board moves",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Philotheephilix/zkTable.git",
+    "directory": "packages/prover-web"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@aztec/bb.js": "0.87.0",
+    "@noir-lang/noir_js": "1.0.0-beta.9"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.6"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "test": "vitest run"
+  }
+}