@sip-protocol/sdk 0.6.6 → 0.6.9

package/dist/browser.js

@@ -5439,7 +5439,8 @@ async function createShieldedIntent(params, options) {
     const effectiveAuthSig = authorizationSignature ?? new Uint8Array(64);
     const fundingResult = await proofProvider.generateFundingProof({
       balance: input.amount,
-      minimumRequired: output.minAmount,
+      minimumRequired: input.amount,
+      // Fix: Must be same units as balance (input asset)
       blindingFactor: hexToUint8(inputCommitment.blindingFactor),
       assetId: input.asset.symbol,
       userAddress: senderAddress ?? "0x0",
@@ -21291,6 +21292,8 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   validityBackend = null;
   fulfillmentNoir = null;
   fulfillmentBackend = null;
+  // Mutex for WASM operations (prevents BorrowMutError from concurrent access)
+  wasmMutex = Promise.resolve();
   // Worker instance (optional)
   worker = null;
   workerPending = /* @__PURE__ */ new Map();
@@ -21590,57 +21593,59 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     if (!this.fundingNoir || !this.fundingBackend) {
       throw new ProofGenerationError("funding", "Funding circuit not initialized");
     }
-    try {
-      onProgress?.({
-        stage: "witness",
-        percent: 10,
-        message: "Preparing witness inputs..."
-      });
-      const blindingField = this.bytesToField(params.blindingFactor);
-      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..."
-      });
-      const { witness, returnValue } = await this.fundingNoir.execute(witnessInputs);
-      onProgress?.({
-        stage: "proving",
-        percent: 50,
-        message: "Generating proof (this may take a moment)..."
-      });
-      const proofData = await this.fundingBackend.generateProof(witness);
-      onProgress?.({
-        stage: "complete",
-        percent: 100,
-        message: "Proof generated successfully"
-      });
-      const commitmentHashBytes = returnValue;
-      const commitmentHashHex = bytesToHex11(new Uint8Array(commitmentHashBytes));
-      const publicInputs = [
-        `0x${params.minimumRequired.toString(16).padStart(64, "0")}`,
-        `0x${this.assetIdToField(params.assetId)}`,
-        `0x${commitmentHashHex}`
-      ];
-      const proof = {
-        type: "funding",
-        proof: `0x${bytesToHex11(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 : void 0
-      );
-    }
+    return this.acquireWasmLock(async () => {
+      try {
+        onProgress?.({
+          stage: "witness",
+          percent: 10,
+          message: "Preparing witness inputs..."
+        });
+        const blindingField = this.bytesToField(params.blindingFactor);
+        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..."
+        });
+        const { witness, returnValue } = await this.fundingNoir.execute(witnessInputs);
+        onProgress?.({
+          stage: "proving",
+          percent: 50,
+          message: "Generating proof (this may take a moment)..."
+        });
+        const proofData = await this.fundingBackend.generateProof(witness);
+        onProgress?.({
+          stage: "complete",
+          percent: 100,
+          message: "Proof generated successfully"
+        });
+        const commitmentHashBytes = returnValue;
+        const commitmentHashHex = bytesToHex11(new Uint8Array(commitmentHashBytes));
+        const publicInputs = [
+          `0x${params.minimumRequired.toString(16).padStart(64, "0")}`,
+          `0x${this.assetIdToField(params.assetId)}`,
+          `0x${commitmentHashHex}`
+        ];
+        const proof = {
+          type: "funding",
+          proof: `0x${bytesToHex11(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 : void 0
+        );
+      }
+    });
   }
   /**
    * Generate a Validity Proof
@@ -21652,89 +21657,91 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     if (!this.validityNoir || !this.validityBackend) {
       throw new ProofGenerationError("validity", "Validity circuit not initialized");
     }
-    try {
-      onProgress?.({
-        stage: "witness",
-        percent: 10,
-        message: "Preparing validity witness..."
-      });
-      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);
-      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);
-      let pubKeyX;
-      let pubKeyY;
-      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,
-        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,
-        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..."
-      });
-      const proofData = await this.validityBackend.generateProof(witness);
-      onProgress?.({
-        stage: "complete",
-        percent: 100,
-        message: "Validity proof generated"
-      });
-      const publicInputs = [
-        `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 = {
-        type: "validity",
-        proof: `0x${bytesToHex11(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 : void 0
-      );
-    }
+    return this.acquireWasmLock(async () => {
+      try {
+        onProgress?.({
+          stage: "witness",
+          percent: 10,
+          message: "Preparing validity witness..."
+        });
+        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);
+        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);
+        let pubKeyX;
+        let pubKeyY;
+        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,
+          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,
+          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..."
+        });
+        const proofData = await this.validityBackend.generateProof(witness);
+        onProgress?.({
+          stage: "complete",
+          percent: 100,
+          message: "Validity proof generated"
+        });
+        const publicInputs = [
+          `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 = {
+          type: "validity",
+          proof: `0x${bytesToHex11(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 : void 0
+        );
+      }
+    });
   }
   /**
    * Generate a Fulfillment Proof
@@ -21746,95 +21753,97 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     if (!this.fulfillmentNoir || !this.fulfillmentBackend) {
       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);
-      onProgress?.({
-        stage: "complete",
-        percent: 100,
-        message: "Fulfillment proof generated"
-      });
-      const publicInputs = [
-        `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 = {
-        type: "fulfillment",
-        proof: `0x${bytesToHex11(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 : void 0
-      );
-    }
+    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: "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${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 = {
+          type: "fulfillment",
+          proof: `0x${bytesToHex11(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 : void 0
+        );
+      }
+    });
   }
   /**
    * Verify a proof
@@ -21861,22 +21870,25 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
         "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
       );
     }
-    try {
-      const proofHex = proof.proof.startsWith("0x") ? proof.proof.slice(2) : proof.proof;
-      const proofBytes = hexToBytes9(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;
+    return this.acquireWasmLock(async () => {
+      try {
+        const proofHex = proof.proof.startsWith("0x") ? proof.proof.slice(2) : proof.proof;
+        const proofBytes = hexToBytes9(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;
-    }
+    });
   }
   /**
    * Destroy the provider and free resources
@@ -21904,6 +21916,25 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     this._isReady = false;
   }
   // ─── 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.
+   */
+  async acquireWasmLock(operation) {
+    const previousLock = this.wasmMutex;
+    let releaseLock;
+    this.wasmMutex = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    try {
+      await previousLock;
+      return await operation();
+    } finally {
+      releaseLock();
+    }
+  }
   ensureReady() {
     if (!this._isReady) {
       throw new ProofError(