@unlink-xyz/core 0.1.0

package/dist/prover/config.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Configuration for the prover system
+ * Handles artifact loading from local files or remote artifact server
+ */
+/**
+ * Environment-based configuration for artifact loading
+ */
+export interface ProverConfig {
+    /** Base URL for the artifact server (browser mode) */
+    rpcUrl: string;
+    /** Whether to enable artifact caching */
+    enableCache: boolean;
+}
+/**
+ * Default configuration
+ * Can be overridden via environment variables
+ */
+export declare const DEFAULT_CONFIG: ProverConfig;
+/**
+ * Artifact file types
+ */
+export declare enum ArtifactType {
+    WASM = "joinsplit.wasm",
+    ZKEY = "joinsplit.zkey",
+    VKEY = "joinsplit.vkey.json"
+}
+/**
+ * Build artifact URL for a given circuit and artifact type
+ * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
+ * @param artifactType Type of artifact to fetch
+ * @param baseUrl Base URL of the artifact server
+ * @returns Full URL to the artifact
+ */
+export declare function buildArtifactUrl(circuitName: string, artifactType: ArtifactType, baseUrl?: string): string;
+/**
+ * Get relative path for local artifact loading
+ * Used in Node.js environment when artifacts are bundled
+ * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
+ * @param artifactType Type of artifact
+ * @returns Relative path to artifact
+ */
+export declare function getLocalArtifactPath(circuitName: string, artifactType: ArtifactType): string[];
+/**
+ * Runtime detection utilities
+ */
+export declare const Runtime: {
+    /**
+     * Check if running in browser environment
+     */
+    isBrowser(): boolean;
+    /**
+     * Check if running in Node.js environment
+     */
+    isNode(): boolean;
+    /**
+     * Get environment description for debugging
+     */
+    getEnvironment(): string;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/prover/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../prover/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,YAM5B,CAAC;AAEF;;GAEG;AACH,oBAAY,YAAY;IACtB,IAAI,mBAAmB;IACvB,IAAI,mBAAmB;IACvB,IAAI,wBAAwB;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,YAAY,EAC1B,OAAO,GAAE,MAA8B,GACtC,MAAM,CAIR;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,YAAY,GACzB,MAAM,EAAE,CAQV;AAED;;GAEG;AACH,eAAO,MAAM,OAAO;IAClB;;OAEG;iBACU,OAAO;IAIpB;;OAEG;cACO,OAAO;IAQjB;;OAEG;sBACe,MAAM;CAKzB,CAAC"}

package/dist/prover/config.js

@@ -0,0 +1,80 @@
+/**
+ * Configuration for the prover system
+ * Handles artifact loading from local files or remote artifact server
+ */
+/**
+ * Default configuration
+ * Can be overridden via environment variables
+ */
+export const DEFAULT_CONFIG = {
+    rpcUrl: typeof process !== "undefined" && process.env?.UNLINK_RPC_URL
+        ? process.env.UNLINK_RPC_URL
+        : "http://localhost:3000",
+    enableCache: true,
+};
+/**
+ * Artifact file types
+ */
+export var ArtifactType;
+(function (ArtifactType) {
+    ArtifactType["WASM"] = "joinsplit.wasm";
+    ArtifactType["ZKEY"] = "joinsplit.zkey";
+    ArtifactType["VKEY"] = "joinsplit.vkey.json";
+})(ArtifactType || (ArtifactType = {}));
+/**
+ * Build artifact URL for a given circuit and artifact type
+ * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
+ * @param artifactType Type of artifact to fetch
+ * @param baseUrl Base URL of the artifact server
+ * @returns Full URL to the artifact
+ */
+export function buildArtifactUrl(circuitName, artifactType, baseUrl = DEFAULT_CONFIG.rpcUrl) {
+    // Remove trailing slash from baseUrl
+    const cleanBaseUrl = baseUrl.replace(/\/$/, "");
+    return `${cleanBaseUrl}/artifacts/${circuitName}/${artifactType}`;
+}
+/**
+ * Get relative path for local artifact loading
+ * Used in Node.js environment when artifacts are bundled
+ * @param circuitName Full circuit name (e.g., "joinsplit_2x3_16")
+ * @param artifactType Type of artifact
+ * @returns Relative path to artifact
+ */
+export function getLocalArtifactPath(circuitName, artifactType) {
+    // Return multiple candidate paths for different build scenarios
+    return [
+        // When compiled: dist/prover/ -> ../../artifacts/circuits/{circuit}/
+        `../../artifacts/circuits/${circuitName}/${artifactType}`,
+        // When in source: prover/ -> ../artifacts/circuits/{circuit}/
+        `../artifacts/circuits/${circuitName}/${artifactType}`,
+    ];
+}
+/**
+ * Runtime detection utilities
+ */
+export const Runtime = {
+    /**
+     * Check if running in browser environment
+     */
+    isBrowser() {
+        return typeof window !== "undefined" && typeof document !== "undefined";
+    },
+    /**
+     * Check if running in Node.js environment
+     */
+    isNode() {
+        return (typeof process !== "undefined" &&
+            process.versions != null &&
+            process.versions.node != null);
+    },
+    /**
+     * Get environment description for debugging
+     */
+    getEnvironment() {
+        if (this.isBrowser())
+            return "browser";
+        if (this.isNode())
+            return "node";
+        return "unknown";
+    },
+};

package/dist/prover/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./prover.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/prover/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../prover/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/prover/index.js

@@ -0,0 +1 @@
+export * from "./prover.js";

package/dist/prover/prover.d.ts

@@ -0,0 +1,59 @@
+import { Groth16Proof, PublicSignals } from "snarkjs";
+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[];
+}
+export declare function proveTransaction(input: JoinsplitProofInput): Promise<JoinsplitProof>;
+/**
+ * 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 declare function getVerificationKey(inputs: number, outputs: number): Promise<VerificationKey>;
+/**
+ * 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 declare function verifyProof(proof: Groth16Proof, publicSignals: PublicSignals): Promise<boolean>;
+/**
+ * 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 declare function verifyProofWithCircuit(proof: Groth16Proof, publicSignals: PublicSignals, inputs: number, outputs: number): Promise<boolean>;
+//# sourceMappingURL=prover.d.ts.map

package/dist/prover/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../../prover/prover.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA4BtD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;CAC7B;AAiND,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,cAAc,CAAC,CAmCzB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,CAAC,CAU1B;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,YAAY,EACnB,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,OAAO,CAAC,CAuClB;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,YAAY,EACnB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAUlB"}

package/dist/prover/prover.js

@@ -0,0 +1,274 @@
+import * as snarkjs from "snarkjs";
+import { CoreError } from "../errors.js";
+import { ArtifactType, buildArtifactUrl, DEFAULT_CONFIG, getLocalArtifactPath, Runtime, } from "./config.js";
+import { getCircuitConfig, SUPPORTED_CIRCUITS, } 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 = {};
+/**
+ * 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, outputs) {
+    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) {
+    // Check cache first
+    if (artifactCache[circuitName]) {
+        return artifactCache[circuitName];
+    }
+    let wasm;
+    let zkey;
+    let vkey;
+    // 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.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) {
+    const url = new URL(relativePath, import.meta.url);
+    try {
+        if (url.protocol === "file:") {
+            const fs = (await import("fs")).default;
+            const readPromise = 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.message}`);
+    }
+}
+async function readTextResource(relativePath) {
+    const url = new URL(relativePath, import.meta.url);
+    if (url.protocol === "file:") {
+        const fs = (await import("fs")).default;
+        const readPromise = 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) {
+    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;
+        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.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, outputs) {
+    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.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, publicSignals) {
+    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 = 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.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, publicSignals, inputs, outputs) {
+    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.message);
+    }
+}

package/dist/prover/registry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Circuit registry for automatic prover selection
+ * Maps circuit dimensions (inputs x outputs) to circuit configurations
+ */
+export interface CircuitConfig {
+    /** Full circuit name (e.g., "joinsplit_2x3_16") */
+    readonly name: string;
+    /** Number of inputs (nullifiers) */
+    readonly inputs: number;
+    /** Number of outputs (commitments) */
+    readonly outputs: number;
+    /** Merkle tree depth */
+    readonly depth: number;
+}
+export type CircuitKey = "3x3" | "2x3" | "1x2" | "1x1";
+/**
+ * Registry of available circuits
+ * Auto-generated from circuits/circuits.json
+ */
+export declare const CIRCUIT_REGISTRY: Record<CircuitKey, CircuitConfig>;
+/**
+ * Get list of all supported circuit keys
+ */
+export declare const SUPPORTED_CIRCUITS: CircuitKey[];
+/**
+ * Get circuit configuration by dimensions
+ * @param inputs Number of inputs (nullifiers)
+ * @param outputs Number of outputs (commitments)
+ * @returns Circuit configuration or undefined if not supported
+ */
+export declare function getCircuitConfig(inputs: number, outputs: number): CircuitConfig | undefined;
+/**
+ * Check if a circuit configuration is supported
+ * @param inputs Number of inputs (nullifiers)
+ * @param outputs Number of outputs (commitments)
+ * @returns True if supported
+ */
+export declare function isCircuitSupported(inputs: number, outputs: number): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/prover/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../prover/registry.ts"],"names":[],"mappings":"AAKA;;;GAGG;AAEH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wBAAwB;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,aAAa,CAyBrD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAoC,UAAU,EAAE,CAAC;AAEhF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,aAAa,GAAG,SAAS,CAG3B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3E"}

package/dist/prover/registry.js

@@ -0,0 +1,57 @@
+// AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
+// Generated by scripts/generate-registry.ts
+// Source: circuits/circuits.json
+// Generated at: 2025-11-25T13:26:58.576Z
+/**
+ * Registry of available circuits
+ * Auto-generated from circuits/circuits.json
+ */
+export const CIRCUIT_REGISTRY = {
+    "3x3": {
+        name: "joinsplit_3x3_16",
+        inputs: 3,
+        outputs: 3,
+        depth: 16,
+    },
+    "2x3": {
+        name: "joinsplit_2x3_16",
+        inputs: 2,
+        outputs: 3,
+        depth: 16,
+    },
+    "1x2": {
+        name: "joinsplit_1x2_16",
+        inputs: 1,
+        outputs: 2,
+        depth: 16,
+    },
+    "1x1": {
+        name: "joinsplit_1x1_16",
+        inputs: 1,
+        outputs: 1,
+        depth: 16,
+    },
+};
+/**
+ * Get list of all supported circuit keys
+ */
+export const SUPPORTED_CIRCUITS = Object.keys(CIRCUIT_REGISTRY);
+/**
+ * Get circuit configuration by dimensions
+ * @param inputs Number of inputs (nullifiers)
+ * @param outputs Number of outputs (commitments)
+ * @returns Circuit configuration or undefined if not supported
+ */
+export function getCircuitConfig(inputs, outputs) {
+    const key = `${inputs}x${outputs}`;
+    return CIRCUIT_REGISTRY[key];
+}
+/**
+ * Check if a circuit configuration is supported
+ * @param inputs Number of inputs (nullifiers)
+ * @param outputs Number of outputs (commitments)
+ * @returns True if supported
+ */
+export function isCircuitSupported(inputs, outputs) {
+    return getCircuitConfig(inputs, outputs) !== undefined;
+}

package/dist/schema.d.ts

@@ -0,0 +1,4 @@
+import type { Storage } from "./types.js";
+export declare const CORE_SCHEMA_VERSION = 1;
+export declare function migrate(storage: Storage): Promise<void>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,wBAAsB,OAAO,CAAC,OAAO,EAAE,OAAO,iBAW7C"}

package/dist/schema.js

@@ -0,0 +1,14 @@
+import { SchemaMismatchError } from "./errors.js";
+export const CORE_SCHEMA_VERSION = 1;
+export async function migrate(storage) {
+    await storage.open();
+    const current = await storage.getSchemaVersion();
+    if (current === 0) {
+        // seed structures if needed
+        await storage.setSchemaVersion(CORE_SCHEMA_VERSION);
+        return;
+    }
+    if (current !== CORE_SCHEMA_VERSION) {
+        throw new SchemaMismatchError(current, CORE_SCHEMA_VERSION);
+    }
+}

package/dist/state/ciphertext-store.d.ts

@@ -0,0 +1,12 @@
+import type { Storage } from "../types.js";
+export declare function createCiphertextStore(storage: Storage): {
+    /**
+     * Store encrypted note payloads alongside their on-chain commitments.
+     */
+    putCiphertext(chainId: number, index: number, payload: Uint8Array): Promise<void>;
+    /**
+     * Retrieve encrypted note payloads; returns null when the ciphertext is missing.
+     */
+    getCiphertext(chainId: number, index: number): Promise<Uint8Array<ArrayBuffer> | null>;
+};
+//# sourceMappingURL=ciphertext-store.d.ts.map

package/dist/state/ciphertext-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ciphertext-store.d.ts","sourceRoot":"","sources":["../../state/ciphertext-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO;IAElD;;OAEG;2BAC0B,MAAM,SAAS,MAAM,WAAW,UAAU;IAQvE;;OAEG;2BAC0B,MAAM,SAAS,MAAM;EAOrD"}

package/dist/state/ciphertext-store.js

@@ -0,0 +1,25 @@
+import { keys, validateKey } from "../keys.js";
+import { ensureChainId, ensurePositiveInt } from "../utils/validators.js";
+export function createCiphertextStore(storage) {
+    return {
+        /**
+         * Store encrypted note payloads alongside their on-chain commitments.
+         */
+        async putCiphertext(chainId, index, payload) {
+            ensureChainId(chainId);
+            ensurePositiveInt("ciphertext index", index);
+            const key = keys.ciphertext(chainId, index);
+            validateKey(key);
+            await storage.put(key, new Uint8Array(payload));
+        },
+        /**
+         * Retrieve encrypted note payloads; returns null when the ciphertext is missing.
+         */
+        async getCiphertext(chainId, index) {
+            ensureChainId(chainId);
+            ensurePositiveInt("ciphertext index", index);
+            const data = await storage.get(keys.ciphertext(chainId, index));
+            return data ? new Uint8Array(data) : null;
+        },
+    };
+}

package/dist/state/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./merkle/index.js";
+export * from "./store/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../state/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}