@sip-protocol/sdk 0.7.3 → 0.8.0

package/src/proofs/mock.ts

@@ -25,6 +25,9 @@ import type {
 } from './interface'
 import { ProofGenerationError } from './interface'
 import { ProofError, ErrorCode } from '../errors'
+import { createLogger } from '../logger'
+
+const log = createLogger('proofs/mock')
 
 /**
  * Mock proof marker - all mock proofs start with this prefix
@@ -107,12 +110,33 @@ export class MockProofProvider implements ProofProvider {
    */
   async initialize(): Promise<void> {
     if (!this._warningShown && !this._silent) {
-      console.warn(WARNING_MESSAGE)
+      log.warn(
+        { framework: 'mock' },
+        'MockProofProvider initialized - NOT FOR PRODUCTION USE. Mock proofs provide NO cryptographic security.'
+      )
       this._warningShown = true
     }
     this._isReady = true
   }
 
+  /**
+   * Wait for the provider to be ready, with optional timeout
+   *
+   * For MockProofProvider, initialization is instant so this always resolves immediately.
+   *
+   * @param timeoutMs - Maximum time to wait (ignored for mock provider)
+   */
+  async waitUntilReady(timeoutMs?: number): Promise<void> {
+    // Suppress unused variable warning
+    void timeoutMs
+
+    if (this._isReady) {
+      return
+    }
+    // Initialize if not already done
+    await this.initialize()
+  }
+
   /**
    * Generate a mock funding proof
    *

package/src/proofs/noir.ts

@@ -26,17 +26,20 @@ import { ProofError, ErrorCode } from '../errors'
 // Import Noir JS (dynamically loaded to support both Node and browser)
 import { Noir } from '@noir-lang/noir_js'
 import type { CompiledCircuit } from '@noir-lang/types'
-import { UltraHonkBackend } from '@aztec/bb.js'
+import { UltraHonkBackend, Barretenberg } from '@aztec/bb.js'
 import { secp256k1 } from '@noble/curves/secp256k1'
 
 // Import compiled circuit artifacts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// Circuit JSON files are typed via CompiledCircuit assertion
 import fundingCircuitArtifact from './circuits/funding_proof.json'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 import validityCircuitArtifact from './circuits/validity_proof.json'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 import fulfillmentCircuitArtifact from './circuits/fulfillment_proof.json'
 
+// Type assertion for circuit artifacts (JSON modules)
+const fundingCircuit = fundingCircuitArtifact as unknown as CompiledCircuit
+const validityCircuit = validityCircuitArtifact as unknown as CompiledCircuit
+const fulfillmentCircuit = fulfillmentCircuitArtifact as unknown as CompiledCircuit
+
 /**
  * Public key coordinates for secp256k1
  */
@@ -113,11 +116,19 @@ export interface NoirProviderConfig {
  * })
  * ```
  */
+/** Default initialization timeout in milliseconds */
+const DEFAULT_INIT_TIMEOUT_MS = 30000
+
 export class NoirProofProvider implements ProofProvider {
   readonly framework: ProofFramework = 'noir'
   private _isReady = false
+  private _initPromise: Promise<void> | null = null
+  private _initError: Error | null = null
   private config: NoirProviderConfig
 
+  // Barretenberg instance (shared by all backends)
+  private barretenberg: Barretenberg | null = null
+
   // Circuit instances
   private fundingNoir: Noir | null = null
   private fundingBackend: UltraHonkBackend | null = null
@@ -185,21 +196,94 @@ export class NoirProofProvider implements ProofProvider {
    * Loads circuit artifacts and initializes the proving backend.
    */
   async initialize(): Promise<void> {
+    // If already ready, return immediately
     if (this._isReady) {
       return
     }
 
+    // If initialization is in progress, wait for it
+    if (this._initPromise) {
+      return this._initPromise
+    }
+
+    // If a previous initialization failed, rethrow the error
+    if (this._initError) {
+      throw this._initError
+    }
+
+    // Start initialization and track the promise
+    this._initPromise = this._doInitialize()
+
+    try {
+      await this._initPromise
+    } catch (error) {
+      // Store error for future calls
+      this._initError = error instanceof Error ? error : new Error(String(error))
+      this._initPromise = null
+      throw error
+    }
+  }
+
+  /**
+   * Wait for the provider to be ready, with optional timeout
+   *
+   * This method blocks until initialization is complete or the timeout is reached.
+   * If initialization is already complete, resolves immediately.
+   * If initialization hasn't started, this method will start it.
+   *
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+   * @throws ProofError if timeout is reached before ready
+   * @throws ProofError if initialization fails
+   */
+  async waitUntilReady(timeoutMs: number = DEFAULT_INIT_TIMEOUT_MS): Promise<void> {
+    if (this._isReady) {
+      return
+    }
+
+    // If there was a previous error, throw it
+    if (this._initError) {
+      throw new ProofError(
+        `NoirProofProvider initialization failed: ${this._initError.message}`,
+        ErrorCode.PROOF_PROVIDER_NOT_READY,
+        { context: { error: this._initError } }
+      )
+    }
+
+    // Start initialization if not already started
+    const initPromise = this._initPromise ?? this.initialize()
+
+    // Race between initialization and timeout
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new ProofError(
+          `NoirProofProvider initialization timed out after ${timeoutMs}ms`,
+          ErrorCode.PROOF_PROVIDER_NOT_READY
+        ))
+      }, timeoutMs)
+    })
+
+    await Promise.race([initPromise, timeoutPromise])
+  }
+
+  /**
+   * Internal initialization logic
+   */
+  private async _doInitialize(): Promise<void> {
     try {
       if (this.config.verbose) {
         console.log('[NoirProofProvider] Initializing...')
       }
 
-      // Initialize Funding Proof circuit
-      // Cast to CompiledCircuit - the JSON artifact matches the expected structure
-      const fundingCircuit = fundingCircuitArtifact as unknown as CompiledCircuit
+      // Initialize Barretenberg (bb.js 3.x requires shared instance)
+      this.barretenberg = await Barretenberg.new()
+
+      if (this.config.verbose) {
+        console.log('[NoirProofProvider] Barretenberg initialized')
+      }
 
-      // Create backend for proof generation
-      this.fundingBackend = new UltraHonkBackend(fundingCircuit.bytecode)
+      // Initialize Funding Proof circuit
+      // Create backend for proof generation (bb.js 3.x requires Barretenberg instance)
+      this.fundingBackend = new UltraHonkBackend(fundingCircuit.bytecode, this.barretenberg)
 
       // Create Noir instance for witness generation
       this.fundingNoir = new Noir(fundingCircuit)
@@ -212,10 +296,8 @@ export class NoirProofProvider implements ProofProvider {
       }
 
       // Initialize Validity Proof circuit
-      const validityCircuit = validityCircuitArtifact as unknown as CompiledCircuit
-
-      // Create backend for validity proof generation
-      this.validityBackend = new UltraHonkBackend(validityCircuit.bytecode)
+      // Create backend for validity proof generation (bb.js 3.x requires Barretenberg instance)
+      this.validityBackend = new UltraHonkBackend(validityCircuit.bytecode, this.barretenberg)
 
       // Create Noir instance for validity witness generation
       this.validityNoir = new Noir(validityCircuit)
@@ -225,10 +307,8 @@ export class NoirProofProvider implements ProofProvider {
       }
 
       // Initialize Fulfillment Proof circuit
-      const fulfillmentCircuit = fulfillmentCircuitArtifact as unknown as CompiledCircuit
-
-      // Create backend for fulfillment proof generation
-      this.fulfillmentBackend = new UltraHonkBackend(fulfillmentCircuit.bytecode)
+      // Create backend for fulfillment proof generation (bb.js 3.x requires Barretenberg instance)
+      this.fulfillmentBackend = new UltraHonkBackend(fulfillmentCircuit.bytecode, this.barretenberg)
 
       // Create Noir instance for fulfillment witness generation
       this.fulfillmentNoir = new Noir(fulfillmentCircuit)
@@ -819,21 +899,22 @@ export class NoirProofProvider implements ProofProvider {
    * Destroy the provider and free resources
    */
   async destroy(): Promise<void> {
-    if (this.fundingBackend) {
-      await this.fundingBackend.destroy()
-      this.fundingBackend = null
-    }
-    if (this.validityBackend) {
-      await this.validityBackend.destroy()
-      this.validityBackend = null
-    }
-    if (this.fulfillmentBackend) {
-      await this.fulfillmentBackend.destroy()
-      this.fulfillmentBackend = null
-    }
+    // Clear backend references (bb.js 3.x backends don't have destroy method)
+    this.fundingBackend = null
+    this.validityBackend = null
+    this.fulfillmentBackend = null
+
+    // Clear Noir instances
     this.fundingNoir = null
     this.validityNoir = null
     this.fulfillmentNoir = null
+
+    // Destroy shared Barretenberg instance (bb.js 3.x)
+    if (this.barretenberg) {
+      await this.barretenberg.destroy()
+      this.barretenberg = null
+    }
+
     this._isReady = false
   }