@sip-protocol/sdk 0.2.0 → 0.2.1

package/dist/index.js

@@ -32,7 +32,6 @@ var index_exports = {};
 __export(index_exports, {
   ATTESTATION_VERSION: () => ATTESTATION_VERSION,
   BaseWalletAdapter: () => BaseWalletAdapter,
-  BrowserNoirProvider: () => BrowserNoirProvider,
   CHAIN_NUMERIC_IDS: () => CHAIN_NUMERIC_IDS,
   ComplianceManager: () => ComplianceManager,
   CryptoError: () => CryptoError,
@@ -5097,609 +5096,6 @@ function getBrowserInfo() {
   };
 }
 
-// src/proofs/browser.ts
-var import_noir_js2 = require("@noir-lang/noir_js");
-var import_bb2 = require("@aztec/bb.js");
-var import_secp256k14 = require("@noble/curves/secp256k1");
-var BrowserNoirProvider = class _BrowserNoirProvider {
-  framework = "noir";
-  _isReady = false;
-  config;
-  // Circuit instances
-  fundingNoir = null;
-  fundingBackend = null;
-  validityNoir = null;
-  validityBackend = null;
-  fulfillmentNoir = null;
-  fulfillmentBackend = null;
-  // Worker instance (optional)
-  worker = null;
-  workerPending = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.config = {
-      useWorker: config.useWorker ?? true,
-      verbose: config.verbose ?? false,
-      oraclePublicKey: config.oraclePublicKey ?? void 0,
-      timeout: config.timeout ?? 6e4
-    };
-    if (!isBrowser()) {
-      console.warn(
-        "[BrowserNoirProvider] Not running in browser environment. Consider using NoirProofProvider for Node.js."
-      );
-    }
-  }
-  get isReady() {
-    return this._isReady;
-  }
-  /**
-   * Get browser environment info
-   */
-  static getBrowserInfo() {
-    return getBrowserInfo();
-  }
-  /**
-   * Check if browser supports all required features
-   */
-  static checkBrowserSupport() {
-    const missing = [];
-    if (!isBrowser()) {
-      missing.push("browser environment");
-    }
-    if (typeof WebAssembly === "undefined") {
-      missing.push("WebAssembly");
-    }
-    if (!supportsSharedArrayBuffer()) {
-      missing.push("SharedArrayBuffer (requires COOP/COEP headers)");
-    }
-    return {
-      supported: missing.length === 0,
-      missing
-    };
-  }
-  /**
-   * Derive secp256k1 public key coordinates from a private key
-   */
-  static derivePublicKey(privateKey) {
-    const uncompressedPubKey = import_secp256k14.secp256k1.getPublicKey(privateKey, false);
-    const x = Array.from(uncompressedPubKey.slice(1, 33));
-    const y = Array.from(uncompressedPubKey.slice(33, 65));
-    return { x, y };
-  }
-  /**
-   * Initialize the browser provider
-   *
-   * Loads WASM and circuit artifacts. This should be called before any
-   * proof generation. Consider showing a loading indicator during init.
-   *
-   * @param onProgress - Optional progress callback
-   */
-  async initialize(onProgress) {
-    if (this._isReady) {
-      return;
-    }
-    const { supported, missing } = _BrowserNoirProvider.checkBrowserSupport();
-    if (!supported) {
-      throw new ProofError(
-        `Browser missing required features: ${missing.join(", ")}`,
-        "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
-      );
-    }
-    try {
-      onProgress?.({
-        stage: "initializing",
-        percent: 0,
-        message: "Loading WASM runtime..."
-      });
-      if (this.config.verbose) {
-        console.log("[BrowserNoirProvider] Initializing...");
-        console.log("[BrowserNoirProvider] Browser info:", getBrowserInfo());
-      }
-      const fundingCircuit = funding_proof_default;
-      const validityCircuit = validity_proof_default;
-      const fulfillmentCircuit = fulfillment_proof_default;
-      onProgress?.({
-        stage: "initializing",
-        percent: 20,
-        message: "Creating proof backends..."
-      });
-      this.fundingBackend = new import_bb2.UltraHonkBackend(fundingCircuit.bytecode);
-      this.validityBackend = new import_bb2.UltraHonkBackend(validityCircuit.bytecode);
-      this.fulfillmentBackend = new import_bb2.UltraHonkBackend(fulfillmentCircuit.bytecode);
-      onProgress?.({
-        stage: "initializing",
-        percent: 60,
-        message: "Initializing Noir circuits..."
-      });
-      this.fundingNoir = new import_noir_js2.Noir(fundingCircuit);
-      this.validityNoir = new import_noir_js2.Noir(validityCircuit);
-      this.fulfillmentNoir = new import_noir_js2.Noir(fulfillmentCircuit);
-      onProgress?.({
-        stage: "initializing",
-        percent: 90,
-        message: "Setting up worker..."
-      });
-      if (this.config.useWorker && supportsWebWorkers()) {
-        await this.initializeWorker();
-      }
-      this._isReady = true;
-      onProgress?.({
-        stage: "complete",
-        percent: 100,
-        message: "Ready for proof generation"
-      });
-      if (this.config.verbose) {
-        console.log("[BrowserNoirProvider] Initialization complete");
-      }
-    } catch (error) {
-      throw new ProofError(
-        `Failed to initialize BrowserNoirProvider: ${error instanceof Error ? error.message : String(error)}`,
-        "SIP_4003" /* PROOF_NOT_IMPLEMENTED */,
-        { context: { error } }
-      );
-    }
-  }
-  /**
-   * Initialize Web Worker for off-main-thread proof generation
-   */
-  async initializeWorker() {
-    if (this.config.verbose) {
-      console.log("[BrowserNoirProvider] Worker support: using async main-thread");
-    }
-  }
-  /**
-   * Generate a Funding Proof
-   *
-   * Proves: balance >= minimumRequired without revealing balance
-   *
-   * @param params - Funding proof parameters
-   * @param onProgress - Optional progress callback
-   */
-  async generateFundingProof(params, onProgress) {
-    this.ensureReady();
-    if (!this.fundingNoir || !this.fundingBackend) {
-      throw new ProofGenerationError("funding", "Funding circuit not initialized");
-    }
-    try {
-      onProgress?.({
-        stage: "witness",
-        percent: 10,
-        message: "Preparing witness inputs..."
-      });
-      const { commitmentHash, blindingField } = await this.computeCommitmentHash(
-        params.balance,
-        params.blindingFactor,
-        params.assetId
-      );
-      const witnessInputs = {
-        commitment_hash: commitmentHash,
-        minimum_required: params.minimumRequired.toString(),
-        asset_id: this.assetIdToField(params.assetId),
-        balance: params.balance.toString(),
-        blinding: blindingField
-      };
-      onProgress?.({
-        stage: "witness",
-        percent: 30,
-        message: "Generating witness..."
-      });
-      const { witness } = 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 publicInputs = [
-        `0x${commitmentHash}`,
-        `0x${params.minimumRequired.toString(16).padStart(16, "0")}`,
-        `0x${this.assetIdToField(params.assetId)}`
-      ];
-      const proof = {
-        type: "funding",
-        proof: `0x${bytesToHex7(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
-   *
-   * Proves: Intent is authorized by sender without revealing identity
-   */
-  async generateValidityProof(params, onProgress) {
-    this.ensureReady();
-    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${bytesToHex7(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
-   *
-   * Proves: Solver correctly executed the intent
-   */
-  async generateFulfillmentProof(params, onProgress) {
-    this.ensureReady();
-    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${bytesToHex7(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
-   */
-  async verifyProof(proof) {
-    this.ensureReady();
-    let backend = null;
-    switch (proof.type) {
-      case "funding":
-        backend = this.fundingBackend;
-        break;
-      case "validity":
-        backend = this.validityBackend;
-        break;
-      case "fulfillment":
-        backend = this.fulfillmentBackend;
-        break;
-      default:
-        throw new ProofError(`Unknown proof type: ${proof.type}`, "SIP_4003" /* PROOF_NOT_IMPLEMENTED */);
-    }
-    if (!backend) {
-      throw new ProofError(
-        `${proof.type} backend not initialized`,
-        "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
-      );
-    }
-    try {
-      const proofHex = proof.proof.startsWith("0x") ? proof.proof.slice(2) : proof.proof;
-      const proofBytes = hexToBytes5(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);
-      }
-      return false;
-    }
-  }
-  /**
-   * Destroy the provider and free resources
-   */
-  async destroy() {
-    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;
-    }
-    if (this.worker) {
-      this.worker.terminate();
-      this.worker = null;
-    }
-    this.fundingNoir = null;
-    this.validityNoir = null;
-    this.fulfillmentNoir = null;
-    this._isReady = false;
-  }
-  // ─── Private Utility Methods ────────────────────────────────────────────────
-  ensureReady() {
-    if (!this._isReady) {
-      throw new ProofError(
-        "BrowserNoirProvider not initialized. Call initialize() first.",
-        "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
-      );
-    }
-  }
-  async computeCommitmentHash(balance, blindingFactor, assetId) {
-    const blindingField = this.bytesToField(blindingFactor);
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const preimage = new Uint8Array([
-      ...this.bigintToBytes(balance, 8),
-      ...blindingFactor.slice(0, 32),
-      ...hexToBytes5(this.assetIdToField(assetId))
-    ]);
-    const hash2 = sha25611(preimage);
-    const commitmentHash = nobleToHex(hash2);
-    return { commitmentHash, blindingField };
-  }
-  assetIdToField(assetId) {
-    if (assetId.startsWith("0x")) {
-      return assetId.slice(2).padStart(64, "0");
-    }
-    const encoder = new TextEncoder();
-    const bytes = encoder.encode(assetId);
-    let result = 0n;
-    for (let i = 0; i < bytes.length && i < 31; i++) {
-      result = result * 256n + BigInt(bytes[i]);
-    }
-    return result.toString(16).padStart(64, "0");
-  }
-  bytesToField(bytes) {
-    let result = 0n;
-    const len = Math.min(bytes.length, 31);
-    for (let i = 0; i < len; i++) {
-      result = result * 256n + BigInt(bytes[i]);
-    }
-    return result.toString();
-  }
-  bigintToBytes(value, length) {
-    const bytes = new Uint8Array(length);
-    let v = value;
-    for (let i = length - 1; i >= 0; i--) {
-      bytes[i] = Number(v & 0xffn);
-      v = v >> 8n;
-    }
-    return bytes;
-  }
-  hexToField(hex) {
-    const h = hex.startsWith("0x") ? hex.slice(2) : hex;
-    return h.padStart(64, "0");
-  }
-  fieldToBytes32(field) {
-    const hex = field.padStart(64, "0");
-    const bytes = [];
-    for (let i = 0; i < 32; i++) {
-      bytes.push(parseInt(hex.slice(i * 2, i * 2 + 2), 16));
-    }
-    return bytes;
-  }
-  async computeSenderCommitment(senderAddressField, senderBlindingField) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const addressBytes = hexToBytes5(senderAddressField);
-    const blindingBytes = hexToBytes5(senderBlindingField.padStart(64, "0"));
-    const preimage = new Uint8Array([...addressBytes, ...blindingBytes]);
-    const hash2 = sha25611(preimage);
-    const commitmentX = nobleToHex(hash2.slice(0, 16)).padStart(64, "0");
-    const commitmentY = nobleToHex(hash2.slice(16, 32)).padStart(64, "0");
-    return { commitmentX, commitmentY };
-  }
-  async computeNullifier(senderSecretField, intentHashField, nonceField) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const secretBytes = hexToBytes5(senderSecretField.padStart(64, "0"));
-    const intentBytes = hexToBytes5(intentHashField);
-    const nonceBytes = hexToBytes5(nonceField.padStart(64, "0"));
-    const preimage = new Uint8Array([...secretBytes, ...intentBytes, ...nonceBytes]);
-    const hash2 = sha25611(preimage);
-    return nobleToHex(hash2);
-  }
-  async computeOutputCommitment(outputAmount, outputBlinding) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const amountBytes = this.bigintToBytes(outputAmount, 8);
-    const blindingBytes = outputBlinding.slice(0, 32);
-    const preimage = new Uint8Array([...amountBytes, ...blindingBytes]);
-    const hash2 = sha25611(preimage);
-    const commitmentX = nobleToHex(hash2.slice(0, 16)).padStart(64, "0");
-    const commitmentY = nobleToHex(hash2.slice(16, 32)).padStart(64, "0");
-    return { commitmentX, commitmentY };
-  }
-  async computeSolverId(solverSecretField) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const secretBytes = hexToBytes5(solverSecretField.padStart(64, "0"));
-    const hash2 = sha25611(secretBytes);
-    return nobleToHex(hash2);
-  }
-  async computeOracleMessageHash(recipient, amount, txHash, blockNumber) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const recipientBytes = hexToBytes5(this.hexToField(recipient));
-    const amountBytes = this.bigintToBytes(amount, 8);
-    const txHashBytes = hexToBytes5(this.hexToField(txHash));
-    const blockBytes = this.bigintToBytes(blockNumber, 8);
-    const preimage = new Uint8Array([
-      ...recipientBytes,
-      ...amountBytes,
-      ...txHashBytes,
-      ...blockBytes
-    ]);
-    const hash2 = sha25611(preimage);
-    return Array.from(hash2);
-  }
-  getPublicKeyCoordinates(privateKey) {
-    const uncompressedPubKey = import_secp256k14.secp256k1.getPublicKey(privateKey, false);
-    const x = Array.from(uncompressedPubKey.slice(1, 33));
-    const y = Array.from(uncompressedPubKey.slice(33, 65));
-    return { x, y };
-  }
-};
-
 // src/oracle/types.ts
 var ORACLE_DOMAIN = "SIP-ORACLE-ATTESTATION-V1";
 var ATTESTATION_VERSION = 1;
@@ -7653,7 +7049,7 @@ function getPaymentSummary(payment) {
 
 // src/treasury/treasury.ts
 var import_types12 = require("@sip-protocol/types");
-var import_secp256k15 = require("@noble/curves/secp256k1");
+var import_secp256k14 = require("@noble/curves/secp256k1");
 var import_sha25610 = require("@noble/hashes/sha256");
 var import_utils12 = require("@noble/hashes/utils");
 var DEFAULT_PROPOSAL_TTL = 7 * 24 * 60 * 60;
@@ -8169,7 +7565,7 @@ function signMessage(messageHash, privateKey) {
   const keyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
   const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
   try {
-    const signature = import_secp256k15.secp256k1.sign(messageHash, keyBytes);
+    const signature = import_secp256k14.secp256k1.sign(messageHash, keyBytes);
     return `0x${signature.toCompactHex()}`;
   } finally {
     secureWipe(keyBytes);
@@ -8181,7 +7577,7 @@ function verifySignature(messageHash, signature, publicKey) {
   try {
     const sigBytes = (0, import_utils12.hexToBytes)(sigHex);
     const pubKeyBytes = (0, import_utils12.hexToBytes)(pubKeyHex);
-    return import_secp256k15.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
+    return import_secp256k14.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
   } catch {
     return false;
   }
@@ -12710,7 +12106,6 @@ var import_types32 = require("@sip-protocol/types");
 0 && (module.exports = {
   ATTESTATION_VERSION,
   BaseWalletAdapter,
-  BrowserNoirProvider,
   CHAIN_NUMERIC_IDS,
   ComplianceManager,
   CryptoError,

package/dist/index.mjs

@@ -1,7 +1,6 @@
 import {
   ATTESTATION_VERSION,
   BaseWalletAdapter,
-  BrowserNoirProvider,
   CHAIN_NUMERIC_IDS,
   ComplianceManager,
   CryptoError,
@@ -213,11 +212,10 @@ import {
   withSecureBuffer,
   withSecureBufferSync,
   wrapError
-} from "./chunk-O4Y2ZUDL.mjs";
+} from "./chunk-4VJHI66K.mjs";
 export {
   ATTESTATION_VERSION,
   BaseWalletAdapter,
-  BrowserNoirProvider,
   CHAIN_NUMERIC_IDS,
   ComplianceManager,
   CryptoError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sip-protocol/sdk",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Core SDK for Shielded Intents Protocol - Privacy layer for cross-chain transactions",
   "author": "SIP Protocol <hello@sip-protocol.org>",
   "homepage": "https://sip-protocol.org",
@@ -27,9 +27,6 @@
       "require": "./dist/browser.js"
     }
   },
-  "browser": {
-    "./dist/index.mjs": "./dist/browser.mjs"
-  },
   "files": [
     "dist",
     "src"

package/src/browser.ts

@@ -19,9 +19,11 @@
 // Re-export everything from main entry
 export * from './index'
 
-// Browser-specific exports (already in main, but explicit here)
+// Browser-specific exports (import directly from browser module to get WASM support)
+export { BrowserNoirProvider } from './proofs/browser'
+
+// Re-export utilities that are already in main (for convenience)
 export {
-  BrowserNoirProvider,
   isBrowser,
   supportsWebWorkers,
   supportsSharedArrayBuffer,