@voter-protocol/noir-prover 0.1.3 → 0.2.0

package/dist/noir-prover/src/cross-origin-isolation.d.ts

@@ -27,3 +27,4 @@ export declare function checkCrossOriginIsolation(): {
  * Call this before initializing NoirProver.
  */
 export declare function requireCrossOriginIsolation(): void;
+//# sourceMappingURL=cross-origin-isolation.d.ts.map

package/dist/noir-prover/src/cross-origin-isolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-origin-isolation.d.ts","sourceRoot":"","sources":["../../../src/cross-origin-isolation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,yBAAyB,IAAI;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,0BAA0B,EAAE,OAAO,CAAC;IACpC,OAAO,EAAE;QACL,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;KACvB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;CACnB,CA2BA;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAyBlD"}

package/dist/noir-prover/src/fixtures.d.ts

@@ -0,0 +1,82 @@
+import { CircuitInputs, CircuitDepth, AuthorityLevel } from './types.js';
+/**
+ * Reset fixtures singleton to release WASM memory
+ * Call this between profiler runs to prevent memory accumulation
+ */
+export declare function resetFixtures(): void;
+/**
+ * Compute nullifier as the circuit does internally
+ *
+ * From the new secure circuit:
+ * ```noir
+ * let nullifier = poseidon2_hash2(user_secret, action_domain);
+ * ```
+ *
+ * Note: This is for reference/testing only - the actual nullifier is
+ * computed INSIDE the circuit and returned as a public output.
+ *
+ * BA-003 FIX: Uses poseidon2Hash2() with domain separation tag to match circuit
+ */
+export declare function computeNullifier(userSecret: string, actionDomain: string): Promise<string>;
+/**
+ * Fixture configuration options for the new secure circuit
+ */
+export interface FixtureOptions {
+    /** User's secret for nullifier derivation and leaf computation */
+    userSecret?: string;
+    /** District identifier */
+    districtId?: string;
+    /** Authority level (1-5) */
+    authorityLevel?: AuthorityLevel;
+    /** Registration salt for leaf computation */
+    registrationSalt?: string;
+    /** Action domain (replaces epochId + campaignId) */
+    actionDomain?: string;
+    /** Leaf position in tree (0 to 2^depth - 1) */
+    leafIndex?: number;
+    /** Custom merkle path siblings */
+    merklePath?: string[];
+    /**
+     * Circuit depth (18, 20, 22, or 24)
+     * Determines merkle path length and max leaf index
+     * Defaults to DEFAULT_CIRCUIT_DEPTH (20)
+     */
+    depth?: CircuitDepth;
+}
+/**
+ * Generate valid circuit inputs for the new secure circuit
+ *
+ * Creates inputs that WILL satisfy circuit constraints:
+ * - Leaf is computed from userSecret, districtId, authorityLevel, registrationSalt
+ * - Merkle root is computed from the leaf + path
+ * - Nullifier will be computed inside the circuit from userSecret + actionDomain
+ *
+ * @param options - Optional overrides for fixture values (including depth)
+ * @returns CircuitInputs that will pass circuit assertions
+ */
+export declare function generateValidInputs(options?: FixtureOptions): Promise<CircuitInputs>;
+/**
+ * Generate realistic fixtures using shadow-atlas style district data
+ *
+ * Creates a more realistic scenario:
+ * - District identifier based on real naming convention
+ * - Non-trivial merkle path (not all zeros)
+ * - Realistic authority level
+ *
+ * @param depth - Circuit depth (defaults to DEFAULT_CIRCUIT_DEPTH)
+ */
+export declare function generateRealisticInputs(depth?: CircuitDepth): Promise<CircuitInputs>;
+/**
+ * Precomputed minimal valid fixture for DEFAULT_CIRCUIT_DEPTH
+ * @deprecated Use getPrecomputedFixture(depth) instead for explicit depth control
+ */
+export declare const PRECOMPUTED_FIXTURE: CircuitInputs;
+/**
+ * Get precomputed fixture for a specific depth
+ * Lazily computes and caches fixtures per depth
+ *
+ * @param depth - Circuit depth (defaults to DEFAULT_CIRCUIT_DEPTH)
+ * @returns Precomputed CircuitInputs that satisfy circuit constraints
+ */
+export declare function getPrecomputedFixture(depth?: CircuitDepth): Promise<CircuitInputs>;
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/noir-prover/src/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../../src/fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AA4B9E;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAQpC;AAsHD;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAE7B,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAG1B,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAEtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAgDxB;AAED;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,GAAE,YAAoC,GAC1C,OAAO,CAAC,aAAa,CAAC,CAqCxB;AAqBD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAKjC,CAAC;AAKF;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,GAAE,YAAoC,GAC1C,OAAO,CAAC,aAAa,CAAC,CAuCxB"}

package/dist/noir-prover/src/hash.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hash.worker.d.ts.map

package/dist/noir-prover/src/hash.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.worker.d.ts","sourceRoot":"","sources":["../../../src/hash.worker.ts"],"names":[],"mappings":""}

package/dist/noir-prover/src/index.d.ts

@@ -2,7 +2,15 @@
  * @voter-protocol/noir-prover
  *
  * Browser-native ZK prover using Barretenberg/Noir backend.
+ *
+ * Public API exports for production use.
+ * Dev-only code (profiler, test fixtures, orchestrator) is kept internal.
  */
-export { NoirProver } from './prover';
-export type { ProverConfig, ProofResult, CircuitInputs } from './types';
+export { NoirProver, getProver, getProverForDepth, resetProverSingleton, resetProverForDepth, } from './prover';
+export { TwoTreeNoirProver, getTwoTreeProverForDepth, resetTwoTreeProverSingleton, resetTwoTreeProverForDepth, } from './two-tree-prover';
+export type { ProverConfig, ProofResult, CircuitInputs, CircuitDepth, AuthorityLevel } from './types';
+export { DEFAULT_CIRCUIT_DEPTH, validateAuthorityLevel } from './types';
+export type { TwoTreeProverConfig, TwoTreeProofInput, TwoTreeProofResult, } from './types';
+export { DISTRICT_SLOT_COUNT, TWO_TREE_PUBLIC_INPUT_COUNT } from './types';
 export { checkCrossOriginIsolation, requireCrossOriginIsolation } from './cross-origin-isolation';
+//# sourceMappingURL=index.d.ts.map

package/dist/noir-prover/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,OAAO,EACH,UAAU,EACV,SAAS,EACT,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,GACtB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACH,iBAAiB,EACjB,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,GAC7B,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACtG,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAGxE,YAAY,EACR,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,GACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAG3E,OAAO,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/noir-prover/src/profiler.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Memory and Performance Profiler for NoirProver
+ *
+ * Run this on real mobile devices to get actual memory/timing data.
+ *
+ * ARCHITECTURE (matches communique pattern):
+ * - Hash worker: Generates valid circuit inputs using Poseidon2 (TERMINABLE for memory)
+ * - Main thread: Runs NoirProver for proof generation (UltraHonkBackend internal workers)
+ *
+ * MEMORY MANAGEMENT:
+ * The hash worker can be TERMINATED between runs to reclaim its WASM memory.
+ * Main thread WASM memory cannot be reclaimed without a page refresh.
+ *
+ * USAGE:
+ * 1. Build and serve this in a web page
+ * 2. Open on real iPhone (Safari) or Android (Chrome)
+ * 3. Open browser DevTools (Safari Web Inspector / Chrome Remote Debug)
+ * 4. Call window.runProverProfile() from console
+ * 5. Watch memory timeline + console output
+ *
+ * Expected times for ~4K constraint circuit:
+ * - Desktop (8 threads): 5-15 seconds
+ * - Mobile (1-4 threads): 20-60 seconds
+ */
+export declare function setQuietMode(quiet: boolean): void;
+export interface ProfileResult {
+    device: string;
+    userAgent: string;
+    timestamp: string;
+    memoryBefore?: number;
+    memoryAfterInit?: number;
+    memoryAfterInputs?: number;
+    memoryAfterProof?: number;
+    memoryAfterCleanup?: number;
+    memoryPeak?: number;
+    initTimeMs: number;
+    inputGenTimeMs: number;
+    proofTimeMs: number;
+    cleanupTimeMs: number;
+    totalTimeMs: number;
+    threads: number;
+    sharedArrayBuffer: boolean;
+    crossOriginIsolated: boolean;
+    workerSupported: boolean;
+    proofSizeBytes?: number;
+    error?: string;
+    orchestratorReused: boolean;
+}
+/**
+ * Run full profiling suite using ProverOrchestrator
+ *
+ * This matches the communique architecture:
+ * - Input generation in terminable worker
+ * - Proof generation on main thread
+ *
+ * SINGLETON MODE: Reuses orchestrator across runs to avoid recreating UltraHonkBackend.
+ * Worker is still terminated between runs for memory isolation.
+ */
+export declare function runProfile(): Promise<ProfileResult>;
+/**
+ * Reset the profiler by destroying the shared orchestrator.
+ * Use this for testing or to force a fresh start.
+ */
+export declare function resetProfiler(): Promise<void>;
+/**
+ * Run multiple profiler iterations with shared orchestrator
+ *
+ * This demonstrates proper memory management:
+ * - Worker termination reclaims input generation WASM memory between runs
+ * - Orchestrator (including UltraHonkBackend) is reused across all runs
+ * - First run initializes, subsequent runs reuse
+ */
+export declare function runProfileMultiple(iterations?: number): Promise<ProfileResult[]>;
+//# sourceMappingURL=profiler.d.ts.map

package/dist/noir-prover/src/profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiler.d.ts","sourceRoot":"","sources":["../../../src/profiler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAiBH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAGjD;AAcD,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAGlB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IAGpB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,eAAe,EAAE,OAAO,CAAC;IAGzB,cAAc,CAAC,EAAE,MAAM,CAAC;IAGxB,KAAK,CAAC,EAAE,MAAM,CAAC;IAGf,kBAAkB,EAAE,OAAO,CAAC;CAC/B;AA6BD;;;;;;;;;GASG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC,CAoLzD;AAED;;;GAGG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAcnD;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,UAAU,GAAE,MAAU,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAuBzF"}

package/dist/noir-prover/src/prover-e2e.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=prover-e2e.test.d.ts.map

package/dist/noir-prover/src/prover-e2e.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover-e2e.test.d.ts","sourceRoot":"","sources":["../../../src/prover-e2e.test.ts"],"names":[],"mappings":""}

package/dist/noir-prover/src/prover-orchestrator.d.ts

@@ -0,0 +1,104 @@
+import { CircuitInputs, ProofResult } from './types';
+import { GenerateInputsOptions } from './worker-protocol';
+export interface OrchestratorConfig {
+    /** Auto-terminate worker after each proof to reclaim memory */
+    autoTerminate?: boolean;
+    /** Progress callback for proof generation */
+    onProgress?: (stage: string, percent: number) => void;
+}
+export declare class ProverOrchestrator {
+    private worker;
+    private workerReady;
+    private workerInitPromise;
+    private prover;
+    private proverInitPromise;
+    private config;
+    constructor(config?: OrchestratorConfig);
+    /**
+     * Initialize both main thread prover and hash worker
+     */
+    init(): Promise<void>;
+    /**
+     * Initialize only the main thread prover (for proof generation)
+     *
+     * SINGLETON PATTERN: Uses getProver() to retrieve the shared prover instance.
+     * The prover is initialized once at module level and reused across all orchestrators.
+     * This prevents memory leaks from creating multiple UltraHonkBackend instances.
+     */
+    initProver(): Promise<void>;
+    /**
+     * Initialize only the hash worker (for input generation)
+     */
+    initWorker(): Promise<void>;
+    /**
+     * Generate valid circuit inputs using Poseidon2 hashing (runs in worker)
+     *
+     * The new secure circuit computes internally:
+     * - leaf = hash(userSecret, districtId, authorityLevel, registrationSalt)
+     * - nullifier = hash(userSecret, actionDomain)
+     *
+     * This function computes:
+     * - merkleRoot = compute_merkle_root(computed_leaf, path, index)
+     */
+    generateInputs(options?: GenerateInputsOptions): Promise<CircuitInputs>;
+    /**
+     * Compute Merkle root from leaf + path (runs in worker)
+     */
+    computeMerkleRoot(leaf: string, merklePath: string[], leafIndex: number): Promise<string>;
+    /**
+     * Generate a ZK proof (runs on main thread)
+     *
+     * UltraHonkBackend internally creates its own Web Workers for parallelism.
+     * Running this inside another worker causes nested worker deadlocks.
+     */
+    prove(inputs: CircuitInputs): Promise<ProofResult>;
+    /**
+     * Full proof flow: generate inputs + prove
+     */
+    proveWithInputGeneration(options?: GenerateInputsOptions): Promise<{
+        inputs: CircuitInputs;
+        proof: ProofResult;
+    }>;
+    /**
+     * Terminate the hash worker to reclaim its WASM memory
+     *
+     * This is the ONLY way to reclaim WebAssembly linear memory.
+     * After termination, call initWorker() to create a fresh worker.
+     */
+    terminateWorker(): void;
+    /**
+     * Destroy the main thread prover
+     *
+     * NO-OP: The prover is now a singleton managed at module level.
+     * It should NOT be destroyed between runs to prevent memory leaks
+     * from recreating UltraHonkBackend instances.
+     *
+     * This method is kept for backward compatibility but does nothing.
+     * The singleton prover will be automatically cleaned up when the
+     * page/module is unloaded.
+     *
+     * @deprecated Use singleton prover pattern - no manual cleanup needed
+     */
+    destroyProver(): Promise<void>;
+    /**
+     * Full cleanup: terminate worker only
+     *
+     * SINGLETON PATTERN: Only terminates the worker to reclaim its WASM memory.
+     * The prover is a singleton and should not be destroyed between runs.
+     */
+    destroy(): Promise<void>;
+    isWorkerReady(): boolean;
+    isProverReady(): boolean;
+    /**
+     * Check if the orchestrator is fully initialized (both prover and worker ready)
+     */
+    isInitialized(): boolean;
+    getThreadCount(): number;
+}
+/**
+ * Create a prover orchestrator configured for memory-constrained environments
+ *
+ * Auto-terminates worker after each proof to prevent WASM memory accumulation.
+ */
+export declare function createMemorySafeOrchestrator(): ProverOrchestrator;
+//# sourceMappingURL=prover-orchestrator.d.ts.map

package/dist/noir-prover/src/prover-orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover-orchestrator.d.ts","sourceRoot":"","sources":["../../../src/prover-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAAe,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAM5E,MAAM,WAAW,kBAAkB;IAC/B,+DAA+D;IAC/D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACzD;AAED,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAA8B;IAEvD,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,iBAAiB,CAA8B;IAEvD,OAAO,CAAC,MAAM,CAAqB;gBAEvB,MAAM,GAAE,kBAAuB;IAW3C;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B;;;;;;OAMG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAcjC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkDjC;;;;;;;;;OASG;IACG,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,aAAa,CAAC;IA2BjF;;OAEG;IACG,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA+B/F;;;;;OAKG;IACG,KAAK,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAiBxD;;OAEG;IACG,wBAAwB,CAC1B,OAAO,GAAE,qBAA0B,GACpC,OAAO,CAAC;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE,CAAC;IAczD;;;;;OAKG;IACH,eAAe,IAAI,IAAI;IAYvB;;;;;;;;;;;;OAYG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IASpC;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAW9B,aAAa,IAAI,OAAO;IAIxB,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB,cAAc,IAAI,MAAM;CAG3B;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,kBAAkB,CAEjE"}

package/dist/noir-prover/src/prover.d.ts

@@ -1,20 +1,35 @@
-import { ProverConfig, CircuitInputs, ProofResult } from './types';
+import { ProverConfig, CircuitInputs, ProofResult, CircuitDepth } from './types';
 export declare class NoirProver {
     private backend;
     private noir;
     private config;
+    private threads;
+    private readonly depth;
     constructor(config?: ProverConfig);
     /**
      * Initialize the prover (must be called before generating proofs)
+     * Lazily loads the circuit for the configured depth
      */
     init(): Promise<void>;
+    /**
+     * Get the circuit depth for this prover instance
+     */
+    getDepth(): CircuitDepth;
     /**
      * Pre-warm the prover by initializing backend
      * Call this on app load to hide latency from user
      */
     warmup(): Promise<void>;
+    /** Maximum allowed Merkle depth (prevents DoS via oversized arrays) */
+    private static readonly MAX_MERKLE_DEPTH;
     /**
      * Generate a ZK proof for district membership
+     *
+     * The new secure circuit computes leaf and nullifier internally:
+     * - leaf = hash(userSecret, districtId, authorityLevel, registrationSalt)
+     * - nullifier = hash(userSecret, actionDomain)
+     *
+     * This prevents attackers from submitting arbitrary leaves or nullifiers.
      */
     prove(inputs: CircuitInputs): Promise<ProofResult>;
     /**
@@ -26,3 +41,30 @@ export declare class NoirProver {
      */
     destroy(): Promise<void>;
 }
+/**
+ * Get or create a NoirProver instance for the specified depth
+ * Safe for concurrent calls - deduplicates initialization per depth
+ *
+ * @param depth - Circuit depth (18, 20, 22, or 24). Defaults to 20.
+ * @param config - Optional prover configuration (threads, etc.)
+ */
+export declare function getProverForDepth(depth?: CircuitDepth, config?: Omit<ProverConfig, 'depth'>): Promise<NoirProver>;
+/**
+ * Get or create the default NoirProver instance (depth=20)
+ * Backward-compatible API - equivalent to getProverForDepth(20)
+ *
+ * @param config - Optional prover configuration
+ * @deprecated Use getProverForDepth() for explicit depth control
+ */
+export declare function getProver(config?: ProverConfig): Promise<NoirProver>;
+/**
+ * Reset all singleton instances (for testing or page unload)
+ */
+export declare function resetProverSingleton(): Promise<void>;
+/**
+ * Reset a specific depth's singleton instance
+ *
+ * @param depth - Circuit depth to reset
+ */
+export declare function resetProverForDepth(depth: CircuitDepth): Promise<void>;
+//# sourceMappingURL=prover.d.ts.map

package/dist/noir-prover/src/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../../../src/prover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,SAAS,CAAC;AAgDtG,qBAAa,UAAU;IACnB,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAEzB,MAAM,GAAE,YAAiB;IAWrC;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB3B;;OAEG;IACH,QAAQ,IAAI,YAAY;IAIxB;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAK7B,uEAAuE;IACvE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAM;IAE9C;;;;;;;;OAQG;IACG,KAAK,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;IAsFxD;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAKzE;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAOjC;AASD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACnC,KAAK,GAAE,YAAoC,EAC3C,MAAM,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,GACrC,OAAO,CAAC,UAAU,CAAC,CA+CrB;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAG1E;AAED;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1D;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5E"}

package/dist/noir-prover/src/prover.test.d.ts

@@ -12,3 +12,4 @@
  * Full proof tests require the same noir_js version.
  */
 export {};
+//# sourceMappingURL=prover.test.d.ts.map

package/dist/noir-prover/src/prover.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.test.d.ts","sourceRoot":"","sources":["../../../src/prover.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/noir-prover/src/two-tree-prover.d.ts

@@ -0,0 +1,106 @@
+import { TwoTreeProverConfig, TwoTreeProofInput, TwoTreeProofResult, CircuitDepth } from './types';
+export declare class TwoTreeNoirProver {
+    private backend;
+    private noir;
+    private readonly threads;
+    private readonly depth;
+    constructor(config?: TwoTreeProverConfig);
+    /**
+     * Initialize the prover (must be called before generating proofs).
+     * Lazily loads the circuit for the configured depth.
+     */
+    init(): Promise<void>;
+    /**
+     * Get the circuit depth for this prover instance.
+     */
+    getDepth(): CircuitDepth;
+    /**
+     * Pre-warm the prover by initializing backend.
+     * Call this on app load to hide latency from user.
+     */
+    warmup(): Promise<void>;
+    /** Maximum allowed Merkle depth (prevents DoS via oversized arrays) */
+    private static readonly MAX_MERKLE_DEPTH;
+    /**
+     * Validate all inputs before circuit execution.
+     * Throws descriptive errors for any invalid input.
+     */
+    validateInputs(inputs: TwoTreeProofInput): void;
+    /**
+     * Format TypeScript inputs into the Noir circuit's expected parameter names
+     * and types (snake_case, hex strings, integer arrays).
+     *
+     * This is exposed as a method for testing purposes.
+     */
+    formatInputs(inputs: TwoTreeProofInput): Record<string, unknown>;
+    /**
+     * Generate a ZK proof for two-tree membership.
+     *
+     * The circuit internally verifies:
+     * 1. User leaf in Tree 1: hash4(user_secret, cell_id, registration_salt, authority_level)
+     * 2. District commitment: poseidon2_sponge_24(districts)
+     * 3. Cell map leaf in Tree 2: hash2(cell_id, district_commitment)
+     * 4. Nullifier: hash2(identity_commitment, action_domain) (NUL-001)
+     * 5. Authority level in [1, 5]
+     *
+     * @param inputs - All public and private inputs for the circuit
+     * @returns Proof bytes and public inputs as hex strings
+     */
+    generateProof(inputs: TwoTreeProofInput): Promise<TwoTreeProofResult>;
+    /**
+     * Verify a two-tree membership proof.
+     *
+     * BR5-006: Validates public input count before backend verification.
+     * For full public input binding (matching proof outputs to expected values),
+     * use verifyProofWithExpectedInputs().
+     *
+     * @param proofResult - The proof result from generateProof()
+     * @returns true if the proof is valid
+     */
+    verifyProof(proofResult: TwoTreeProofResult): Promise<boolean>;
+    /**
+     * Verify a proof AND validate that public inputs match expected values.
+     *
+     * BR5-006 FIX: The base verifyProof() only checks that the proof is
+     * cryptographically valid for its public inputs. It does NOT verify that
+     * those inputs match what the caller intended. An attacker could substitute
+     * a valid proof generated for different inputs (e.g., different districts
+     * or a different authority level).
+     *
+     * This method binds the proof to the caller's expected values by checking:
+     * - user_root matches
+     * - cell_map_root matches
+     * - All 24 districts match
+     * - nullifier matches
+     * - action_domain matches
+     * - authority_level matches
+     *
+     * @param proofResult - The proof from generateProof()
+     * @param expectedInputs - The original inputs used for proof generation
+     * @returns true if proof is valid AND public inputs match expectations
+     */
+    verifyProofWithExpectedInputs(proofResult: TwoTreeProofResult, expectedInputs: TwoTreeProofInput): Promise<boolean>;
+    /**
+     * Clean up resources (WASM memory, web workers).
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * Get or create a TwoTreeNoirProver instance for the specified depth.
+ * Safe for concurrent calls - deduplicates initialization per depth.
+ *
+ * @param depth - Circuit depth (18, 20, 22, or 24). Defaults to 20.
+ * @param config - Optional prover configuration (threads, etc.)
+ */
+export declare function getTwoTreeProverForDepth(depth?: CircuitDepth, config?: Omit<TwoTreeProverConfig, 'depth'>): Promise<TwoTreeNoirProver>;
+/**
+ * Reset all two-tree singleton instances (for testing or page unload).
+ */
+export declare function resetTwoTreeProverSingleton(): Promise<void>;
+/**
+ * Reset a specific depth's two-tree singleton instance.
+ *
+ * @param depth - Circuit depth to reset
+ */
+export declare function resetTwoTreeProverForDepth(depth: CircuitDepth): Promise<void>;
+//# sourceMappingURL=two-tree-prover.d.ts.map

package/dist/noir-prover/src/two-tree-prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"two-tree-prover.d.ts","sourceRoot":"","sources":["../../../src/two-tree-prover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAMH,OAAO,KAAK,EACR,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACf,MAAM,SAAS,CAAC;AAkHjB,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAEzB,MAAM,GAAE,mBAAwB;IAS5C;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B;;OAEG;IACH,QAAQ,IAAI,YAAY;IAIxB;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAS7B,uEAAuE;IACvE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAM;IAE9C;;;OAGG;IACH,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IA8J/C;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA8BhE;;;;;;;;;;;;OAYG;IACG,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAwC3E;;;;;;;;;OASG;IACG,WAAW,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBpE;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,6BAA6B,CAC/B,WAAW,EAAE,kBAAkB,EAC/B,cAAc,EAAE,iBAAiB,GAClC,OAAO,CAAC,OAAO,CAAC;IAiDnB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAOjC;AAaD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC1C,KAAK,GAAE,YAAoC,EAC3C,MAAM,CAAC,EAAE,IAAI,CAAC,mBAAmB,EAAE,OAAO,CAAC,GAC5C,OAAO,CAAC,iBAAiB,CAAC,CAoC5B;AAED;;GAEG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAQjE;AAED;;;;GAIG;AACH,wBAAsB,0BAA0B,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAOnF"}

package/dist/noir-prover/src/two-tree-prover.test.d.ts

@@ -0,0 +1,18 @@
+/**
+ * TwoTreeNoirProver Unit Tests
+ *
+ * Tests the two-tree ZK proving infrastructure with the two_tree_membership circuit.
+ *
+ * Focus areas:
+ * - Input validation (authority level, zero secret, array lengths, bit values)
+ * - Input formatting (TypeScript -> Noir snake_case mapping)
+ * - Circuit loading per depth
+ * - Public input count verification
+ *
+ * NOTE: Full proof generation requires the Barretenberg backend and is slow.
+ * For unit tests we focus on validation, formatting, and circuit initialization.
+ * The circuit execute() call (witness generation) validates circuit logic without
+ * needing the full proving backend.
+ */
+export {};
+//# sourceMappingURL=two-tree-prover.test.d.ts.map

package/dist/noir-prover/src/two-tree-prover.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"two-tree-prover.test.d.ts","sourceRoot":"","sources":["../../../src/two-tree-prover.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}