@unlink-xyz/core 0.1.3 → 0.1.4

package/prover/prover.test.ts

@@ -1,309 +0,0 @@
-import { access } from "fs/promises";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import * as snarkjs from "snarkjs";
-import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
-
-import { CoreError } from "../errors.js";
-import {
-  getVerificationKey,
-  proveTransaction,
-  verifyProof,
-  type JoinsplitProofInput,
-} from "./prover.js";
-
-// Mock snarkjs module
-vi.mock("snarkjs");
-
-// Test helpers
-function createMockInput(
-  overrides?: Partial<JoinsplitProofInput>,
-): JoinsplitProofInput {
-  return {
-    merkleRoot: 1n,
-    boundParamsHash: 2n,
-    nullifiers: [3n, 4n],
-    commitmentsOut: [5n, 6n, 7n],
-    token: 8n,
-    publicKey: [9n, 10n],
-    signature: [11n, 11n, 11n],
-    randomIn: [12n, 13n],
-    valueIn: [14n, 15n],
-    pathElements: [[0n], [0n]],
-    leavesIndices: [16n, 17n],
-    nullifyingKey: 18n,
-    npkOut: [19n, 20n, 21n],
-    valueOut: [22n, 23n, 24n],
-    ...overrides,
-  };
-}
-
-function createMockProof() {
-  return {
-    pi_a: ["1", "2", "3"],
-    pi_b: [
-      ["4", "5"],
-      ["6", "7"],
-      ["8", "9"],
-    ],
-    pi_c: ["10", "11", "12"],
-    protocol: "groth16" as const,
-    curve: "bn128" as const,
-  };
-}
-
-function createMockPublicSignals() {
-  // 2x3 circuit has 7 public signals: [root, hash, nullifier1, nullifier2, commit1, commit2, commit3]
-  return ["25", "26", "27", "28", "29", "30", "31"];
-}
-
-describe("prover", () => {
-  beforeAll(async () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-
-    // Check if artifacts exist for 2x3 circuit (used in these tests)
-    try {
-      await access(
-        join(
-          __dirname,
-          "../artifacts/circuits/joinsplit_2x3_16/joinsplit.wasm",
-        ),
-      );
-      await access(
-        join(
-          __dirname,
-          "../artifacts/circuits/joinsplit_2x3_16/joinsplit.zkey",
-        ),
-      );
-      await access(
-        join(
-          __dirname,
-          "../artifacts/circuits/joinsplit_2x3_16/joinsplit.vkey.json",
-        ),
-      );
-    } catch (error) {
-      throw new Error(
-        "Circuit artifacts not found. Please run 'pnpm run circuits:build' first.",
-      );
-    }
-
-    // Mock verify to return true by default (proveTransaction calls it internally)
-    const verifyMock = vi.mocked(snarkjs.groth16.verify);
-    verifyMock.mockResolvedValue(true);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("getVerificationKey", () => {
-    it("loads and returns the verification key", async () => {
-      // Test uses 2 inputs, 3 outputs (see createMockInput)
-      const vkey = await getVerificationKey(2, 3);
-
-      expect(vkey).toBeDefined();
-      expect(vkey.protocol).toBe("groth16");
-      expect(vkey.curve).toBe("bn128");
-      expect(vkey.nPublic).toBe(7); // 2 (root + hash) + 2 (nullifiers) + 3 (commitments) = 7
-      expect(vkey.vk_alpha_1).toBeInstanceOf(Array);
-      expect(vkey.vk_beta_2).toBeInstanceOf(Array);
-      expect(vkey.vk_gamma_2).toBeInstanceOf(Array);
-      expect(vkey.vk_delta_2).toBeInstanceOf(Array);
-      expect(vkey.vk_alphabeta_12).toBeInstanceOf(Array);
-      expect(vkey.IC).toBeInstanceOf(Array);
-      expect(vkey.IC.length).toBe(8); // nPublic + 1
-    });
-  });
-
-  describe("fetchArtifact", () => {
-    it("successfully loads wasm and zkey files", async () => {
-      const mockInput = createMockInput();
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      const fullProveMock = vi.mocked(snarkjs.groth16.fullProve);
-      fullProveMock.mockResolvedValue({
-        proof: mockProof,
-        publicSignals: mockPublicSignals,
-      });
-
-      // This should not throw file loading errors
-      const result = await proveTransaction(mockInput);
-
-      expect(result).toBeDefined();
-      expect(result.proof).toEqual(mockProof);
-      expect(result.publicSignals).toEqual(mockPublicSignals);
-
-      // Verify fullProve was called with buffers (artifacts were loaded)
-      expect(fullProveMock).toHaveBeenCalledTimes(1);
-      const call = fullProveMock.mock.calls[0];
-      expect(call[1]).toBeInstanceOf(Uint8Array); // wasm bytes
-      expect(call[2]).toBeInstanceOf(Uint8Array); // zkey bytes
-    });
-  });
-
-  describe("proveTransaction", () => {
-    it("generates proof with valid input", async () => {
-      const mockInput = createMockInput({
-        merkleRoot: 100n,
-      });
-
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      const fullProveMock = vi.mocked(snarkjs.groth16.fullProve);
-      fullProveMock.mockResolvedValue({
-        proof: mockProof,
-        publicSignals: mockPublicSignals,
-      });
-
-      const result = await proveTransaction(mockInput);
-
-      expect(result.proof).toEqual(mockProof);
-      expect(result.publicSignals).toEqual(mockPublicSignals);
-      expect(fullProveMock).toHaveBeenCalledTimes(1);
-
-      // Verify the call was made with input signals and file buffers
-      const call = fullProveMock.mock.calls[0];
-      expect(call[0]).toBeDefined(); // inputSignals
-      expect(call[1]).toBeInstanceOf(Uint8Array); // wasm bytes
-      expect(call[2]).toBeInstanceOf(Uint8Array); // zkey bytes
-    });
-
-    it("wraps errors with CoreError", async () => {
-      const mockInput = createMockInput({
-        nullifiers: [3n],
-        commitmentsOut: [4n],
-        randomIn: [9n],
-        valueIn: [10n],
-        pathElements: [[0n]],
-        leavesIndices: [11n],
-        npkOut: [13n],
-        valueOut: [14n],
-      });
-
-      const mockError = new Error("snarkjs internal error");
-      const fullProveMock = vi.mocked(snarkjs.groth16.fullProve);
-      fullProveMock.mockRejectedValue(mockError);
-
-      await expect(proveTransaction(mockInput)).rejects.toThrow(CoreError);
-      await expect(proveTransaction(mockInput)).rejects.toThrow(
-        "proof generation failed: snarkjs internal error",
-      );
-    });
-  });
-
-  describe("verifyProof", () => {
-    it("verifies a valid proof successfully", async () => {
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      const verifyMock = vi.mocked(snarkjs.groth16.verify);
-      verifyMock.mockResolvedValue(true);
-
-      const result = await verifyProof(mockProof, mockPublicSignals);
-
-      expect(result).toBe(true);
-      expect(verifyMock).toHaveBeenCalledTimes(1);
-
-      // Verify it was called with vkey, publicSignals, and proof
-      const call = verifyMock.mock.calls[0];
-      expect(call[0]).toBeDefined(); // vkey
-      expect(call[1]).toEqual(mockPublicSignals);
-      expect(call[2]).toEqual(mockProof);
-    });
-
-    it("returns false for invalid proof", async () => {
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      const verifyMock = vi.mocked(snarkjs.groth16.verify);
-      verifyMock.mockResolvedValue(false);
-
-      const result = await verifyProof(mockProof, mockPublicSignals);
-
-      expect(result).toBe(false);
-    });
-
-    it("wraps errors with CoreError", async () => {
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      const mockError = new Error("verification error");
-      const verifyMock = vi.mocked(snarkjs.groth16.verify);
-      verifyMock.mockRejectedValue(mockError);
-
-      await expect(verifyProof(mockProof, mockPublicSignals)).rejects.toThrow(
-        CoreError,
-      );
-      await expect(verifyProof(mockProof, mockPublicSignals)).rejects.toThrow(
-        "proof verification failed",
-      );
-    });
-
-    it("completes full prove and verify workflow", async () => {
-      const mockInput = createMockInput();
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      // Mock proof generation
-      const fullProveMock = vi.mocked(snarkjs.groth16.fullProve);
-      fullProveMock.mockResolvedValue({
-        proof: mockProof,
-        publicSignals: mockPublicSignals,
-      });
-
-      // Mock verification
-      const verifyMock = vi.mocked(snarkjs.groth16.verify);
-      verifyMock.mockResolvedValue(true);
-
-      // Generate proof
-      const proofResult = await proveTransaction(mockInput);
-
-      // Verify proof
-      const verificationResult = await verifyProof(
-        proofResult.proof,
-        proofResult.publicSignals,
-      );
-
-      expect(verificationResult).toBe(true);
-      expect(fullProveMock).toHaveBeenCalledTimes(1);
-      expect(verifyMock).toHaveBeenCalledTimes(2); // 1 internal + 1 explicit
-    });
-  });
-
-  describe("artifact caching", () => {
-    it("loads artifacts only once across multiple calls", async () => {
-      const mockInput = createMockInput();
-      const mockProof = createMockProof();
-      const mockPublicSignals = createMockPublicSignals();
-
-      const fullProveMock = vi.mocked(snarkjs.groth16.fullProve);
-      fullProveMock.mockResolvedValue({
-        proof: mockProof,
-        publicSignals: mockPublicSignals,
-      });
-
-      const verifyMock = vi.mocked(snarkjs.groth16.verify);
-      verifyMock.mockResolvedValue(true);
-
-      // Make multiple calls
-      await proveTransaction(mockInput);
-      await proveTransaction(mockInput);
-      await getVerificationKey(2, 3); // 2 inputs, 3 outputs
-      await verifyProof(mockProof, mockPublicSignals);
-
-      // All functions should work and be called
-      expect(fullProveMock).toHaveBeenCalledTimes(2);
-      expect(verifyMock).toHaveBeenCalledTimes(3); // 2 internal + 1 explicit
-
-      // Verify artifacts are being reused (same Uint8Array instances)
-      const firstCall = fullProveMock.mock.calls[0];
-      const secondCall = fullProveMock.mock.calls[1];
-
-      expect(firstCall[1]).toBe(secondCall[1]); // Same wasm buffer instance
-      expect(firstCall[2]).toBe(secondCall[2]); // Same zkey buffer instance
-    });
-  });
-});

package/prover/prover.ts

@@ -1,405 +0,0 @@
-import { Groth16Proof, PublicSignals } from "snarkjs";
-import * as snarkjs from "snarkjs";
-
-import { CoreError } from "../errors.js";
-import {
-  ArtifactType,
-  buildArtifactUrl,
-  DEFAULT_CONFIG,
-  getLocalArtifactPath,
-  Runtime,
-} from "./config.js";
-import {
-  getCircuitConfig,
-  SUPPORTED_CIRCUITS,
-  type CircuitConfig,
-} from "./registry.js";
-
-// Cache for loaded artifacts to avoid reloading 18MB of files on every call
-// Now keyed by circuit name to support multiple circuits
-const artifactCache: Record<
-  string,
-  {
-    wasm: Uint8Array;
-    zkey: Uint8Array;
-    vkey: VerificationKey;
-  }
-> = {};
-
-export interface JoinsplitProof {
-  readonly proof: Groth16Proof;
-  readonly publicSignals: PublicSignals;
-}
-
-export interface VerificationKey {
-  readonly protocol: string;
-  readonly curve: string;
-  readonly nPublic: number;
-  readonly vk_alpha_1: string[];
-  readonly vk_beta_2: string[][];
-  readonly vk_gamma_2: string[][];
-  readonly vk_delta_2: string[][];
-  readonly vk_alphabeta_12: string[][][];
-  readonly IC: string[][];
-}
-
-export interface JoinsplitProofInput {
-  readonly merkleRoot: bigint;
-  readonly boundParamsHash: bigint;
-  readonly nullifiers: bigint[];
-  readonly commitmentsOut: bigint[];
-  readonly token: bigint;
-  readonly publicKey: bigint[];
-  readonly signature: bigint[];
-  readonly randomIn: bigint[];
-  readonly valueIn: bigint[];
-  readonly pathElements: bigint[][];
-  readonly leavesIndices: bigint[];
-  readonly nullifyingKey: bigint;
-  readonly npkOut: bigint[];
-  readonly valueOut: bigint[];
-}
-
-/**
- * Select the appropriate circuit based on input/output dimensions
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns Circuit configuration
- * @throws CoreError if no matching circuit is found
- */
-function selectCircuit(inputs: number, outputs: number): CircuitConfig {
-  const config = getCircuitConfig(inputs, outputs);
-
-  if (!config) {
-    throw new CoreError(
-      `No circuit available for ${inputs} inputs and ${outputs} outputs. ` +
-        `Supported circuits: ${SUPPORTED_CIRCUITS.join(", ")}`,
-    );
-  }
-
-  return config;
-}
-
-/**
- * Fetch circuit artifacts for a specific circuit
- * Supports both browser (remote) and Node.js (local) environments
- * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
- * @returns Artifacts object with wasm, zkey, and vkey
- */
-async function fetchCircuitArtifacts(circuitName: string) {
-  // Check cache first
-  if (artifactCache[circuitName]) {
-    return artifactCache[circuitName];
-  }
-
-  let wasm: Uint8Array | undefined;
-  let zkey: Uint8Array | undefined;
-  let vkey: VerificationKey | undefined;
-
-  // Browser environment: fetch from artifact server
-  if (Runtime.isBrowser()) {
-    try {
-      const baseUrl = DEFAULT_CONFIG.rpcUrl;
-
-      const wasmUrl = buildArtifactUrl(circuitName, ArtifactType.WASM, baseUrl);
-      const zkeyUrl = buildArtifactUrl(circuitName, ArtifactType.ZKEY, baseUrl);
-      const vkeyUrl = buildArtifactUrl(circuitName, ArtifactType.VKEY, baseUrl);
-
-      const [wasmRes, zkeyRes, vkeyRes] = await Promise.all([
-        fetch(wasmUrl),
-        fetch(zkeyUrl),
-        fetch(vkeyUrl),
-      ]);
-
-      if (!wasmRes.ok || !zkeyRes.ok || !vkeyRes.ok) {
-        throw new CoreError(
-          `Failed to fetch artifacts for ${circuitName} from ${baseUrl}. ` +
-            `Status: wasm=${wasmRes.status}, zkey=${zkeyRes.status}, vkey=${vkeyRes.status}`,
-        );
-      }
-
-      wasm = new Uint8Array(await wasmRes.arrayBuffer());
-      zkey = new Uint8Array(await zkeyRes.arrayBuffer());
-      vkey = await vkeyRes.json();
-    } catch (error) {
-      throw new CoreError(
-        `Failed to fetch artifacts from server for ${circuitName}: ${(error as Error).message}`,
-      );
-    }
-  }
-  // Node.js environment: try local file paths
-  else {
-    const wasmCandidates = getLocalArtifactPath(circuitName, ArtifactType.WASM);
-    const zkeyCandidates = getLocalArtifactPath(circuitName, ArtifactType.ZKEY);
-    const vkeyCandidates = getLocalArtifactPath(circuitName, ArtifactType.VKEY);
-
-    let wasmLoaded = false;
-    for (const candidate of wasmCandidates) {
-      try {
-        wasm = await readBinaryResource(candidate);
-        wasmLoaded = true;
-        break;
-      } catch {
-        // Try next candidate
-      }
-    }
-
-    if (!wasmLoaded) {
-      throw new CoreError(
-        `Could not find WASM artifact for ${circuitName}. ` +
-          `Please run 'pnpm run build:all' in the circuits package.`,
-      );
-    }
-
-    // Load zkey
-    let zkeyLoaded = false;
-    for (const candidate of zkeyCandidates) {
-      try {
-        zkey = await readBinaryResource(candidate);
-        zkeyLoaded = true;
-        break;
-      } catch {
-        // Try next candidate
-      }
-    }
-
-    if (!zkeyLoaded) {
-      throw new CoreError(
-        `Could not find zkey artifact for ${circuitName}. ` +
-          `Please run 'pnpm run build:all' in the circuits package.`,
-      );
-    }
-
-    // Load vkey
-    let vkeyLoaded = false;
-    for (const candidate of vkeyCandidates) {
-      try {
-        const vkeyText = await readTextResource(candidate);
-        vkey = JSON.parse(vkeyText);
-        vkeyLoaded = true;
-        break;
-      } catch {
-        // Try next candidate
-      }
-    }
-
-    if (!vkeyLoaded) {
-      throw new CoreError(
-        `Could not find verification key for ${circuitName}. ` +
-          `Please run 'pnpm run build:all' in the circuits package.`,
-      );
-    }
-  }
-
-  // Verify all artifacts were loaded
-  if (!wasm || !zkey || !vkey) {
-    throw new CoreError(
-      `Failed to load all artifacts for ${circuitName}. ` +
-        `Missing: ${!wasm ? "wasm " : ""}${!zkey ? "zkey " : ""}${!vkey ? "vkey" : ""}`,
-    );
-  }
-
-  // Cache the artifacts for future calls
-  // TypeScript now knows these are defined after the check above
-  const artifacts = { wasm, zkey, vkey };
-  artifactCache[circuitName] = artifacts;
-
-  return artifacts;
-}
-
-async function readBinaryResource(relativePath: string): Promise<Uint8Array> {
-  const url = new URL(relativePath, import.meta.url);
-
-  try {
-    if (url.protocol === "file:") {
-      const fs = (await import("fs")).default;
-      const readPromise: Promise<Buffer> = new Promise((resolve, reject) => {
-        fs.readFile(url.pathname, (err, data) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(data);
-          }
-        });
-      });
-      const buf = await readPromise;
-      return new Uint8Array(buf);
-    }
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new CoreError(
-        `failed to fetch ${relativePath}: ${response.statusText}`,
-      );
-    }
-    return new Uint8Array(await response.arrayBuffer());
-  } catch (error) {
-    throw new CoreError(
-      `failed to read binary resource ${relativePath}: ${
-        (error as Error).message
-      }`,
-    );
-  }
-}
-
-async function readTextResource(relativePath: string): Promise<string> {
-  const url = new URL(relativePath, import.meta.url);
-  if (url.protocol === "file:") {
-    const fs = (await import("fs")).default;
-    const readPromise: Promise<Buffer> = new Promise((resolve, reject) => {
-      fs.readFile(url.pathname, (err, data) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(data);
-        }
-      });
-    });
-    const buf = await readPromise;
-    return buf.toString("utf-8");
-  }
-
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new CoreError(
-      `failed to fetch ${relativePath}: ${response.statusText}`,
-    );
-  }
-  return response.text();
-}
-
-export async function proveTransaction(
-  input: JoinsplitProofInput,
-): Promise<JoinsplitProof> {
-  try {
-    // Auto-detect circuit based on input dimensions
-    const nInputs = input.nullifiers.length;
-    const nOutputs = input.commitmentsOut.length;
-
-    const circuit = selectCircuit(nInputs, nOutputs);
-
-    // Fetch circuit artifacts (wasm and zkey)
-    const { wasm, vkey, zkey } = await fetchCircuitArtifacts(circuit.name);
-
-    const inputSignals = input as unknown as Record<
-      string,
-      bigint | bigint[] | string
-    >;
-
-    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
-      inputSignals,
-      wasm,
-      zkey,
-    );
-
-    // Additional verification step (optional)
-    const isValid = await snarkjs.groth16.verify(vkey, publicSignals, proof);
-    if (!isValid) {
-      throw new CoreError("generated proof is invalid");
-    }
-
-    return {
-      proof,
-      publicSignals,
-    };
-  } catch (error) {
-    throw new CoreError("proof generation failed: " + (error as Error).message);
-  }
-}
-
-/**
- * Get verification key for a specific circuit configuration
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns Verification key for the circuit
- */
-export async function getVerificationKey(
-  inputs: number,
-  outputs: number,
-): Promise<VerificationKey> {
-  try {
-    const circuit = selectCircuit(inputs, outputs);
-    const { vkey } = await fetchCircuitArtifacts(circuit.name);
-    return vkey;
-  } catch (error) {
-    throw new CoreError(
-      "failed to load verification key: " + (error as Error).message,
-    );
-  }
-}
-
-/**
- * Verify a proof with public signals
- * Auto-detects the circuit from the public signals structure
- * @param proof Groth16 proof
- * @param publicSignals Public signals array
- * @returns True if proof is valid
- */
-export async function verifyProof(
-  proof: Groth16Proof,
-  publicSignals: PublicSignals,
-): Promise<boolean> {
-  try {
-    // Public signals structure: [merkleRoot, boundParamsHash, ...nullifiers, ...commitments]
-    // We need to determine the circuit from the length
-    // This is tricky without additional context, so we'll need to try to infer
-    // or require explicit circuit specification
-
-    // For now, extract nullifier and commitment counts from the public signals
-    // The caller should know this information, but we can make an educated guess
-    // based on the total length and circuit registry
-
-    // Length = 2 (root + hash) + nInputs + nOutputs
-    const totalLength = publicSignals.length;
-    const variableCount = totalLength - 2; // Remove merkleRoot and boundParamsHash
-
-    // Try to find a matching circuit
-    let vkey: VerificationKey | null = null;
-    for (const circuitKey of SUPPORTED_CIRCUITS) {
-      const parts = circuitKey.split("x");
-      const config = getCircuitConfig(parseInt(parts[0]!), parseInt(parts[1]!));
-      if (config && config.inputs + config.outputs === variableCount) {
-        const artifacts = await fetchCircuitArtifacts(config.name);
-        vkey = artifacts.vkey;
-        break;
-      }
-    }
-
-    if (!vkey) {
-      throw new CoreError(
-        `Could not determine circuit from ${totalLength} public signals`,
-      );
-    }
-
-    return await snarkjs.groth16.verify(vkey, publicSignals, proof);
-  } catch (error) {
-    throw new CoreError(
-      "proof verification failed: " + (error as Error).message,
-    );
-  }
-}
-
-/**
- * Verify a proof with explicit circuit specification
- * Preferred method when you know the circuit dimensions
- * @param proof Groth16 proof
- * @param publicSignals Public signals array
- * @param inputs Number of inputs (nullifiers)
- * @param outputs Number of outputs (commitments)
- * @returns True if proof is valid
- */
-export async function verifyProofWithCircuit(
-  proof: Groth16Proof,
-  publicSignals: PublicSignals,
-  inputs: number,
-  outputs: number,
-): Promise<boolean> {
-  try {
-    const circuit = selectCircuit(inputs, outputs);
-    const { vkey } = await fetchCircuitArtifacts(circuit.name);
-    return await snarkjs.groth16.verify(vkey, publicSignals, proof);
-  } catch (error) {
-    throw new CoreError(
-      "proof verification failed: " + (error as Error).message,
-    );
-  }
-}