@sip-protocol/sdk 0.6.6 → 0.6.8

package/src/proofs/browser.ts

@@ -156,6 +156,9 @@ export class BrowserNoirProvider implements ProofProvider {
   private fulfillmentNoir: Noir | null = null
   private fulfillmentBackend: UltraHonkBackend | null = null
 
+  // Mutex for WASM operations (prevents BorrowMutError from concurrent access)
+  private wasmMutex: Promise<void> = Promise.resolve()
+
   // Worker instance (optional)
   private worker: Worker | null = null
   private workerPending: Map<
@@ -556,76 +559,79 @@ export class BrowserNoirProvider implements ProofProvider {
       throw new ProofGenerationError('funding', 'Funding circuit not initialized')
     }
 
-    try {
-      onProgress?.({
-        stage: 'witness',
-        percent: 10,
-        message: 'Preparing witness inputs...',
-      })
-
-      // Convert blinding factor to field element
-      const blindingField = this.bytesToField(params.blindingFactor)
-
-      // Circuit signature: (minimum_required: pub Field, asset_id: pub Field, balance: Field, blinding: Field) -> [u8; 32]
-      // Using Field type for unlimited precision (handles NEAR's 24 decimals, etc.)
-      const witnessInputs = {
-        minimum_required: `0x${params.minimumRequired.toString(16)}`,
-        asset_id: `0x${this.assetIdToField(params.assetId)}`,
-        balance: `0x${params.balance.toString(16)}`,
-        blinding: blindingField,
-      }
-
-      onProgress?.({
-        stage: 'witness',
-        percent: 30,
-        message: 'Generating witness...',
-      })
-
-      // Generate witness - circuit returns commitment hash as [u8; 32]
-      const { witness, returnValue } = await this.fundingNoir.execute(witnessInputs)
-
-      onProgress?.({
-        stage: 'proving',
-        percent: 50,
-        message: 'Generating proof (this may take a moment)...',
-      })
-
-      // Generate proof
-      const proofData = await this.fundingBackend.generateProof(witness)
+    // Use mutex to prevent concurrent WASM access (causes BorrowMutError)
+    return this.acquireWasmLock(async () => {
+      try {
+        onProgress?.({
+          stage: 'witness',
+          percent: 10,
+          message: 'Preparing witness inputs...',
+        })
+
+        // Convert blinding factor to field element
+        const blindingField = this.bytesToField(params.blindingFactor)
+
+        // Circuit signature: (minimum_required: pub Field, asset_id: pub Field, balance: Field, blinding: Field) -> [u8; 32]
+        // Using Field type for unlimited precision (handles NEAR's 24 decimals, etc.)
+        const witnessInputs = {
+          minimum_required: `0x${params.minimumRequired.toString(16)}`,
+          asset_id: `0x${this.assetIdToField(params.assetId)}`,
+          balance: `0x${params.balance.toString(16)}`,
+          blinding: blindingField,
+        }
 
-      onProgress?.({
-        stage: 'complete',
-        percent: 100,
-        message: 'Proof generated successfully',
-      })
+        onProgress?.({
+          stage: 'witness',
+          percent: 30,
+          message: 'Generating witness...',
+        })
+
+        // Generate witness - circuit returns commitment hash as [u8; 32]
+        const { witness, returnValue } = await this.fundingNoir!.execute(witnessInputs)
+
+        onProgress?.({
+          stage: 'proving',
+          percent: 50,
+          message: 'Generating proof (this may take a moment)...',
+        })
+
+        // Generate proof
+        const proofData = await this.fundingBackend!.generateProof(witness)
+
+        onProgress?.({
+          stage: 'complete',
+          percent: 100,
+          message: 'Proof generated successfully',
+        })
+
+        // Extract commitment hash from circuit return value
+        const commitmentHashBytes = returnValue as number[]
+        const commitmentHashHex = bytesToHex(new Uint8Array(commitmentHashBytes))
+
+        // Order: minimum_required, asset_id, commitment_hash (return value)
+        // Field values padded to 64 hex chars (32 bytes)
+        const publicInputs: `0x${string}`[] = [
+          `0x${params.minimumRequired.toString(16).padStart(64, '0')}`,
+          `0x${this.assetIdToField(params.assetId)}`,
+          `0x${commitmentHashHex}`,
+        ]
+
+        const proof: ZKProof = {
+          type: 'funding',
+          proof: `0x${bytesToHex(proofData.proof)}`,
+          publicInputs,
+        }
 
-      // Extract commitment hash from circuit return value
-      const commitmentHashBytes = returnValue as number[]
-      const commitmentHashHex = bytesToHex(new Uint8Array(commitmentHashBytes))
-
-      // Order: minimum_required, asset_id, commitment_hash (return value)
-      // Field values padded to 64 hex chars (32 bytes)
-      const publicInputs: `0x${string}`[] = [
-        `0x${params.minimumRequired.toString(16).padStart(64, '0')}`,
-        `0x${this.assetIdToField(params.assetId)}`,
-        `0x${commitmentHashHex}`,
-      ]
-
-      const proof: ZKProof = {
-        type: 'funding',
-        proof: `0x${bytesToHex(proofData.proof)}`,
-        publicInputs,
+        return { proof, publicInputs }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        throw new ProofGenerationError(
+          'funding',
+          `Failed to generate funding proof: ${message}`,
+          error instanceof Error ? error : undefined
+        )
       }
-
-      return { proof, publicInputs }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new ProofGenerationError(
-        'funding',
-        `Failed to generate funding proof: ${message}`,
-        error instanceof Error ? error : undefined
-      )
-    }
+    })
   }
 
   /**
@@ -643,105 +649,108 @@ export class BrowserNoirProvider implements ProofProvider {
       throw new ProofGenerationError('validity', 'Validity circuit not initialized')
     }
 
-    try {
-      onProgress?.({
-        stage: 'witness',
-        percent: 10,
-        message: 'Preparing validity witness...',
-      })
-
-      // Convert inputs to field elements
-      const intentHashField = this.hexToField(params.intentHash)
-      const senderAddressField = this.hexToField(params.senderAddress)
-      const senderBlindingField = this.bytesToField(params.senderBlinding)
-      const senderSecretField = this.bytesToField(params.senderSecret)
-      const nonceField = this.bytesToField(params.nonce)
-
-      // Compute derived values
-      const { commitmentX, commitmentY } = await this.computeSenderCommitment(
-        senderAddressField,
-        senderBlindingField
-      )
-      const nullifier = await this.computeNullifier(senderSecretField, intentHashField, nonceField)
-
-      const signature = Array.from(params.authorizationSignature)
-      const messageHash = this.fieldToBytes32(intentHashField)
-
-      // Get public key
-      let pubKeyX: number[]
-      let pubKeyY: number[]
-      if (params.senderPublicKey) {
-        pubKeyX = Array.from(params.senderPublicKey.x)
-        pubKeyY = Array.from(params.senderPublicKey.y)
-      } else {
-        const coords = this.getPublicKeyCoordinates(params.senderSecret)
-        pubKeyX = coords.x
-        pubKeyY = coords.y
-      }
-
-      const witnessInputs = {
-        intent_hash: intentHashField,
-        sender_commitment_x: commitmentX,
-        sender_commitment_y: commitmentY,
-        nullifier: nullifier,
-        timestamp: params.timestamp.toString(),
-        expiry: params.expiry.toString(),
-        sender_address: senderAddressField,
-        sender_blinding: senderBlindingField,
-        sender_secret: senderSecretField,
-        pub_key_x: pubKeyX,
-        pub_key_y: pubKeyY,
-        signature: signature,
-        message_hash: messageHash,
-        nonce: nonceField,
-      }
-
-      onProgress?.({
-        stage: 'witness',
-        percent: 30,
-        message: 'Generating witness...',
-      })
-
-      const { witness } = await this.validityNoir.execute(witnessInputs)
-
-      onProgress?.({
-        stage: 'proving',
-        percent: 50,
-        message: 'Generating validity proof...',
-      })
+    // Use mutex to prevent concurrent WASM access (causes BorrowMutError)
+    return this.acquireWasmLock(async () => {
+      try {
+        onProgress?.({
+          stage: 'witness',
+          percent: 10,
+          message: 'Preparing validity witness...',
+        })
+
+        // Convert inputs to field elements
+        const intentHashField = this.hexToField(params.intentHash)
+        const senderAddressField = this.hexToField(params.senderAddress)
+        const senderBlindingField = this.bytesToField(params.senderBlinding)
+        const senderSecretField = this.bytesToField(params.senderSecret)
+        const nonceField = this.bytesToField(params.nonce)
+
+        // Compute derived values
+        const { commitmentX, commitmentY } = await this.computeSenderCommitment(
+          senderAddressField,
+          senderBlindingField
+        )
+        const nullifier = await this.computeNullifier(senderSecretField, intentHashField, nonceField)
+
+        const signature = Array.from(params.authorizationSignature)
+        const messageHash = this.fieldToBytes32(intentHashField)
+
+        // Get public key
+        let pubKeyX: number[]
+        let pubKeyY: number[]
+        if (params.senderPublicKey) {
+          pubKeyX = Array.from(params.senderPublicKey.x)
+          pubKeyY = Array.from(params.senderPublicKey.y)
+        } else {
+          const coords = this.getPublicKeyCoordinates(params.senderSecret)
+          pubKeyX = coords.x
+          pubKeyY = coords.y
+        }
 
-      const proofData = await this.validityBackend.generateProof(witness)
+        const witnessInputs = {
+          intent_hash: intentHashField,
+          sender_commitment_x: commitmentX,
+          sender_commitment_y: commitmentY,
+          nullifier: nullifier,
+          timestamp: params.timestamp.toString(),
+          expiry: params.expiry.toString(),
+          sender_address: senderAddressField,
+          sender_blinding: senderBlindingField,
+          sender_secret: senderSecretField,
+          pub_key_x: pubKeyX,
+          pub_key_y: pubKeyY,
+          signature: signature,
+          message_hash: messageHash,
+          nonce: nonceField,
+        }
 
-      onProgress?.({
-        stage: 'complete',
-        percent: 100,
-        message: 'Validity proof generated',
-      })
+        onProgress?.({
+          stage: 'witness',
+          percent: 30,
+          message: 'Generating witness...',
+        })
+
+        const { witness } = await this.validityNoir!.execute(witnessInputs)
+
+        onProgress?.({
+          stage: 'proving',
+          percent: 50,
+          message: 'Generating validity proof...',
+        })
+
+        const proofData = await this.validityBackend!.generateProof(witness)
+
+        onProgress?.({
+          stage: 'complete',
+          percent: 100,
+          message: 'Validity proof generated',
+        })
+
+        const publicInputs: `0x${string}`[] = [
+          `0x${intentHashField}`,
+          `0x${commitmentX}`,
+          `0x${commitmentY}`,
+          `0x${nullifier}`,
+          `0x${params.timestamp.toString(16).padStart(16, '0')}`,
+          `0x${params.expiry.toString(16).padStart(16, '0')}`,
+        ]
+
+        const proof: ZKProof = {
+          type: 'validity',
+          proof: `0x${bytesToHex(proofData.proof)}`,
+          publicInputs,
+        }
 
-      const publicInputs: `0x${string}`[] = [
-        `0x${intentHashField}`,
-        `0x${commitmentX}`,
-        `0x${commitmentY}`,
-        `0x${nullifier}`,
-        `0x${params.timestamp.toString(16).padStart(16, '0')}`,
-        `0x${params.expiry.toString(16).padStart(16, '0')}`,
-      ]
-
-      const proof: ZKProof = {
-        type: 'validity',
-        proof: `0x${bytesToHex(proofData.proof)}`,
-        publicInputs,
+        return { proof, publicInputs }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        throw new ProofGenerationError(
+          'validity',
+          `Failed to generate validity proof: ${message}`,
+          error instanceof Error ? error : undefined
+        )
       }
-
-      return { proof, publicInputs }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new ProofGenerationError(
-        'validity',
-        `Failed to generate validity proof: ${message}`,
-        error instanceof Error ? error : undefined
-      )
-    }
+    })
   }
 
   /**
@@ -759,109 +768,112 @@ export class BrowserNoirProvider implements ProofProvider {
       throw new ProofGenerationError('fulfillment', 'Fulfillment circuit not initialized')
     }
 
-    try {
-      onProgress?.({
-        stage: 'witness',
-        percent: 10,
-        message: 'Preparing fulfillment witness...',
-      })
-
-      const intentHashField = this.hexToField(params.intentHash)
-      const recipientStealthField = this.hexToField(params.recipientStealth)
-
-      const { commitmentX, commitmentY } = await this.computeOutputCommitment(
-        params.outputAmount,
-        params.outputBlinding
-      )
-
-      const solverSecretField = this.bytesToField(params.solverSecret)
-      const solverId = await this.computeSolverId(solverSecretField)
-      const outputBlindingField = this.bytesToField(params.outputBlinding)
-
-      const attestation = params.oracleAttestation
-      const attestationRecipientField = this.hexToField(attestation.recipient)
-      const attestationTxHashField = this.hexToField(attestation.txHash)
-      const oracleSignature = Array.from(attestation.signature)
-      const oracleMessageHash = await this.computeOracleMessageHash(
-        attestation.recipient,
-        attestation.amount,
-        attestation.txHash,
-        attestation.blockNumber
-      )
-
-      const oraclePubKeyX = this.config.oraclePublicKey?.x ?? new Array(32).fill(0)
-      const oraclePubKeyY = this.config.oraclePublicKey?.y ?? new Array(32).fill(0)
-
-      const witnessInputs = {
-        intent_hash: intentHashField,
-        output_commitment_x: commitmentX,
-        output_commitment_y: commitmentY,
-        recipient_stealth: recipientStealthField,
-        min_output_amount: params.minOutputAmount.toString(),
-        solver_id: solverId,
-        fulfillment_time: params.fulfillmentTime.toString(),
-        expiry: params.expiry.toString(),
-        output_amount: params.outputAmount.toString(),
-        output_blinding: outputBlindingField,
-        solver_secret: solverSecretField,
-        attestation_recipient: attestationRecipientField,
-        attestation_amount: attestation.amount.toString(),
-        attestation_tx_hash: attestationTxHashField,
-        attestation_block: attestation.blockNumber.toString(),
-        oracle_signature: oracleSignature,
-        oracle_message_hash: oracleMessageHash,
-        oracle_pub_key_x: oraclePubKeyX,
-        oracle_pub_key_y: oraclePubKeyY,
-      }
-
-      onProgress?.({
-        stage: 'witness',
-        percent: 30,
-        message: 'Generating witness...',
-      })
-
-      const { witness } = await this.fulfillmentNoir.execute(witnessInputs)
-
-      onProgress?.({
-        stage: 'proving',
-        percent: 50,
-        message: 'Generating fulfillment proof...',
-      })
-
-      const proofData = await this.fulfillmentBackend.generateProof(witness)
+    // Use mutex to prevent concurrent WASM access (causes BorrowMutError)
+    return this.acquireWasmLock(async () => {
+      try {
+        onProgress?.({
+          stage: 'witness',
+          percent: 10,
+          message: 'Preparing fulfillment witness...',
+        })
+
+        const intentHashField = this.hexToField(params.intentHash)
+        const recipientStealthField = this.hexToField(params.recipientStealth)
+
+        const { commitmentX, commitmentY } = await this.computeOutputCommitment(
+          params.outputAmount,
+          params.outputBlinding
+        )
+
+        const solverSecretField = this.bytesToField(params.solverSecret)
+        const solverId = await this.computeSolverId(solverSecretField)
+        const outputBlindingField = this.bytesToField(params.outputBlinding)
+
+        const attestation = params.oracleAttestation
+        const attestationRecipientField = this.hexToField(attestation.recipient)
+        const attestationTxHashField = this.hexToField(attestation.txHash)
+        const oracleSignature = Array.from(attestation.signature)
+        const oracleMessageHash = await this.computeOracleMessageHash(
+          attestation.recipient,
+          attestation.amount,
+          attestation.txHash,
+          attestation.blockNumber
+        )
+
+        const oraclePubKeyX = this.config.oraclePublicKey?.x ?? new Array(32).fill(0)
+        const oraclePubKeyY = this.config.oraclePublicKey?.y ?? new Array(32).fill(0)
+
+        const witnessInputs = {
+          intent_hash: intentHashField,
+          output_commitment_x: commitmentX,
+          output_commitment_y: commitmentY,
+          recipient_stealth: recipientStealthField,
+          min_output_amount: params.minOutputAmount.toString(),
+          solver_id: solverId,
+          fulfillment_time: params.fulfillmentTime.toString(),
+          expiry: params.expiry.toString(),
+          output_amount: params.outputAmount.toString(),
+          output_blinding: outputBlindingField,
+          solver_secret: solverSecretField,
+          attestation_recipient: attestationRecipientField,
+          attestation_amount: attestation.amount.toString(),
+          attestation_tx_hash: attestationTxHashField,
+          attestation_block: attestation.blockNumber.toString(),
+          oracle_signature: oracleSignature,
+          oracle_message_hash: oracleMessageHash,
+          oracle_pub_key_x: oraclePubKeyX,
+          oracle_pub_key_y: oraclePubKeyY,
+        }
 
-      onProgress?.({
-        stage: 'complete',
-        percent: 100,
-        message: 'Fulfillment proof generated',
-      })
+        onProgress?.({
+          stage: 'witness',
+          percent: 30,
+          message: 'Generating witness...',
+        })
+
+        const { witness } = await this.fulfillmentNoir!.execute(witnessInputs)
+
+        onProgress?.({
+          stage: 'proving',
+          percent: 50,
+          message: 'Generating fulfillment proof...',
+        })
+
+        const proofData = await this.fulfillmentBackend!.generateProof(witness)
+
+        onProgress?.({
+          stage: 'complete',
+          percent: 100,
+          message: 'Fulfillment proof generated',
+        })
+
+        const publicInputs: `0x${string}`[] = [
+          `0x${intentHashField}`,
+          `0x${commitmentX}`,
+          `0x${commitmentY}`,
+          `0x${recipientStealthField}`,
+          `0x${params.minOutputAmount.toString(16).padStart(16, '0')}`,
+          `0x${solverId}`,
+          `0x${params.fulfillmentTime.toString(16).padStart(16, '0')}`,
+          `0x${params.expiry.toString(16).padStart(16, '0')}`,
+        ]
+
+        const proof: ZKProof = {
+          type: 'fulfillment',
+          proof: `0x${bytesToHex(proofData.proof)}`,
+          publicInputs,
+        }
 
-      const publicInputs: `0x${string}`[] = [
-        `0x${intentHashField}`,
-        `0x${commitmentX}`,
-        `0x${commitmentY}`,
-        `0x${recipientStealthField}`,
-        `0x${params.minOutputAmount.toString(16).padStart(16, '0')}`,
-        `0x${solverId}`,
-        `0x${params.fulfillmentTime.toString(16).padStart(16, '0')}`,
-        `0x${params.expiry.toString(16).padStart(16, '0')}`,
-      ]
-
-      const proof: ZKProof = {
-        type: 'fulfillment',
-        proof: `0x${bytesToHex(proofData.proof)}`,
-        publicInputs,
+        return { proof, publicInputs }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        throw new ProofGenerationError(
+          'fulfillment',
+          `Failed to generate fulfillment proof: ${message}`,
+          error instanceof Error ? error : undefined
+        )
       }
-
-      return { proof, publicInputs }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
-      throw new ProofGenerationError(
-        'fulfillment',
-        `Failed to generate fulfillment proof: ${message}`,
-        error instanceof Error ? error : undefined
-      )
-    }
+    })
   }
 
   /**
@@ -893,24 +905,29 @@ export class BrowserNoirProvider implements ProofProvider {
       )
     }
 
-    try {
-      const proofHex = proof.proof.startsWith('0x') ? proof.proof.slice(2) : proof.proof
-      const proofBytes = hexToBytes(proofHex)
-
-      const isValid = await backend.verifyProof({
-        proof: proofBytes,
-        publicInputs: proof.publicInputs.map((input) =>
-          input.startsWith('0x') ? input.slice(2) : input
-        ),
-      })
-
-      return isValid
-    } catch (error) {
-      if (this.config.verbose) {
-        console.error('[BrowserNoirProvider] Verification error:', error)
+    const backendToUse = backend
+
+    // Use mutex to prevent concurrent WASM access (causes BorrowMutError)
+    return this.acquireWasmLock(async () => {
+      try {
+        const proofHex = proof.proof.startsWith('0x') ? proof.proof.slice(2) : proof.proof
+        const proofBytes = hexToBytes(proofHex)
+
+        const isValid = await backendToUse.verifyProof({
+          proof: proofBytes,
+          publicInputs: proof.publicInputs.map((input) =>
+            input.startsWith('0x') ? input.slice(2) : input
+          ),
+        })
+
+        return isValid
+      } catch (error) {
+        if (this.config.verbose) {
+          console.error('[BrowserNoirProvider] Verification error:', error)
+        }
+        return false
       }
-      return false
-    }
+    })
   }
 
   /**
@@ -941,6 +958,34 @@ export class BrowserNoirProvider implements ProofProvider {
 
   // ─── Private Utility Methods ────────────────────────────────────────────────
 
+  /**
+   * Acquire WASM mutex lock for exclusive access
+   *
+   * The ACVM WASM module uses Rust RefCell internally which panics on
+   * concurrent mutable borrows. This mutex ensures serial execution.
+   */
+  private async acquireWasmLock<T>(operation: () => Promise<T>): Promise<T> {
+    // Wait for any pending operation to complete
+    const previousLock = this.wasmMutex
+
+    // Create a new lock that will be released when our operation completes
+    let releaseLock: () => void
+    this.wasmMutex = new Promise<void>((resolve) => {
+      releaseLock = resolve
+    })
+
+    try {
+      // Wait for previous operation
+      await previousLock
+
+      // Execute our operation
+      return await operation()
+    } finally {
+      // Release the lock
+      releaseLock!()
+    }
+  }
+
   private ensureReady(): void {
     if (!this._isReady) {
       throw new ProofError(