@sip-protocol/sdk 0.2.9 → 0.2.10

package/dist/browser.mjs

@@ -55,6 +55,7 @@ import {
   base58ToHex,
   bytesToHex,
   checkEd25519StealthAddress,
+  checkMobileWASMCompatibility,
   checkStealthAddress,
   commit,
   commitZero,
@@ -93,6 +94,8 @@ import {
   deserializeIntent,
   deserializePayment,
   detectEthereumWallets,
+  detectMobileBrowser,
+  detectMobilePlatform,
   detectSolanaWallets,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
@@ -113,6 +116,7 @@ import {
   getActiveOracles,
   getAvailableTransports,
   getBrowserInfo,
+  getBrowserVersion,
   getChainNumericId,
   getChainsForStablecoin,
   getCurveForChain,
@@ -121,6 +125,8 @@ import {
   getEthereumProvider,
   getGenerators,
   getIntentSummary,
+  getMobileDeviceInfo,
+  getOSVersion,
   getPaymentSummary,
   getPaymentTimeRemaining,
   getPrivacyConfig,
@@ -145,6 +151,7 @@ import {
   isPrivateWalletAdapter,
   isStablecoin,
   isStablecoinOnChain,
+  isTablet,
   isValidAmount,
   isValidChainId,
   isValidCompressedPublicKey,
@@ -176,7 +183,10 @@ import {
   subtractBlindings,
   subtractCommitments,
   supportsSharedArrayBuffer,
+  supportsTouch,
   supportsViewingKey,
+  supportsWASMBulkMemory,
+  supportsWASMSimd,
   supportsWebBluetooth,
   supportsWebHID,
   supportsWebUSB,
@@ -199,12 +209,12 @@ import {
   walletRegistry,
   withSecureBuffer,
   withSecureBufferSync
-} from "./chunk-KXN6IWL5.mjs";
+} from "./chunk-AV37IZST.mjs";
 import {
   fulfillment_proof_default,
   funding_proof_default,
   validity_proof_default
-} from "./chunk-VITVG25F.mjs";
+} from "./chunk-XLEPIR2P.mjs";
 import {
   CryptoError,
   EncryptionNotImplementedError,
@@ -230,6 +240,9 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   framework = "noir";
   _isReady = false;
   config;
+  // Mobile device info (cached)
+  deviceInfo = null;
+  wasmCompatibility = null;
   // Circuit instances
   fundingNoir = null;
   fundingBackend = null;
@@ -241,17 +254,25 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   worker = null;
   workerPending = /* @__PURE__ */ new Map();
   constructor(config = {}) {
+    this.deviceInfo = getMobileDeviceInfo();
+    const isMobile = this.deviceInfo.isMobile;
+    const defaultTimeout = isMobile ? 12e4 : 6e4;
     this.config = {
       useWorker: config.useWorker ?? true,
       verbose: config.verbose ?? false,
       oraclePublicKey: config.oraclePublicKey ?? void 0,
-      timeout: config.timeout ?? 6e4
+      timeout: config.timeout ?? defaultTimeout,
+      mobileMode: config.mobileMode ?? isMobile,
+      forceInitialize: config.forceInitialize ?? false
     };
     if (!isBrowser()) {
       console.warn(
         "[BrowserNoirProvider] Not running in browser environment. Consider using NoirProofProvider for Node.js."
       );
     }
+    if (this.config.verbose && this.deviceInfo) {
+      console.log("[BrowserNoirProvider] Device info:", this.deviceInfo);
+    }
   }
   get isReady() {
     return this._isReady;
@@ -281,6 +302,67 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
       missing
     };
   }
+  /**
+   * Get detailed mobile device information
+   */
+  static getMobileInfo() {
+    return getMobileDeviceInfo();
+  }
+  /**
+   * Check mobile WASM compatibility
+   *
+   * Returns detailed compatibility information including:
+   * - Feature support (WASM, SharedArrayBuffer, Workers, SIMD)
+   * - Compatibility score (0-100)
+   * - Issues and recommendations
+   *
+   * @example
+   * ```typescript
+   * const compat = BrowserNoirProvider.checkMobileCompatibility()
+   * if (compat.score < 70) {
+   *   console.warn('Limited mobile support:', compat.issues)
+   * }
+   * ```
+   */
+  static checkMobileCompatibility() {
+    return checkMobileWASMCompatibility();
+  }
+  /**
+   * Check if the current device is mobile
+   */
+  static isMobile() {
+    return getMobileDeviceInfo().isMobile;
+  }
+  /**
+   * Get recommended configuration for the current device
+   *
+   * Automatically adjusts settings based on device capabilities:
+   * - Mobile devices get longer timeouts
+   * - Low-memory devices disable workers
+   * - Tablets get intermediate settings
+   */
+  static getRecommendedConfig() {
+    const deviceInfo = getMobileDeviceInfo();
+    const compat = checkMobileWASMCompatibility();
+    const config = {};
+    if (deviceInfo.isMobile) {
+      config.timeout = 12e4;
+      config.mobileMode = true;
+      if (deviceInfo.deviceMemoryGB !== null && deviceInfo.deviceMemoryGB < 2) {
+        config.useWorker = false;
+      }
+      if (deviceInfo.platform === "ios" && deviceInfo.browser === "safari") {
+        config.useWorker = compat.sharedArrayBuffer;
+      }
+    } else if (deviceInfo.isTablet) {
+      config.timeout = 9e4;
+      config.mobileMode = true;
+    }
+    if (compat.score < 50) {
+      config.forceInitialize = false;
+    }
+    return config;
+  }
   /**
    * Derive secp256k1 public key coordinates from a private key
    */
@@ -290,6 +372,18 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     const y = Array.from(uncompressedPubKey.slice(33, 65));
     return { x, y };
   }
+  /**
+   * Get the cached WASM compatibility info (available after construction)
+   */
+  getWASMCompatibility() {
+    return this.wasmCompatibility;
+  }
+  /**
+   * Get the cached device info (available after construction)
+   */
+  getDeviceInfo() {
+    return this.deviceInfo;
+  }
   /**
    * Initialize the browser provider
    *
@@ -302,8 +396,18 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     if (this._isReady) {
       return;
     }
+    this.wasmCompatibility = checkMobileWASMCompatibility();
+    if (this.config.verbose) {
+      console.log("[BrowserNoirProvider] WASM compatibility:", this.wasmCompatibility);
+    }
+    if (this.wasmCompatibility.score < 50 && !this.config.forceInitialize) {
+      throw new ProofError(
+        `Device has poor WASM compatibility (score: ${this.wasmCompatibility.score}). Issues: ${this.wasmCompatibility.issues.join(", ")}. Set forceInitialize: true to override.`,
+        "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
+      );
+    }
     const { supported, missing } = _BrowserNoirProvider.checkBrowserSupport();
-    if (!supported) {
+    if (!supported && !this.config.forceInitialize) {
       throw new ProofError(
         `Browser missing required features: ${missing.join(", ")}`,
         "SIP_4004" /* PROOF_PROVIDER_NOT_READY */
@@ -367,8 +471,69 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
    * Initialize Web Worker for off-main-thread proof generation
    */
   async initializeWorker() {
-    if (this.config.verbose) {
-      console.log("[BrowserNoirProvider] Worker support: using async main-thread");
+    if (!supportsWebWorkers()) {
+      if (this.config.verbose) {
+        console.log("[BrowserNoirProvider] Web Workers not supported, using main thread");
+      }
+      return;
+    }
+    try {
+      const workerCode = this.getWorkerCode();
+      const blob = new Blob([workerCode], { type: "application/javascript" });
+      const workerURL = URL.createObjectURL(blob);
+      this.worker = new Worker(workerURL, { type: "module" });
+      this.worker.onmessage = (event) => {
+        this.handleWorkerMessage(event.data);
+      };
+      this.worker.onerror = (error) => {
+        console.error("[BrowserNoirProvider] Worker error:", error);
+        for (const [id, { reject }] of this.workerPending) {
+          reject(new Error(`Worker error: ${error.message}`));
+          this.workerPending.delete(id);
+        }
+        this.worker?.terminate();
+        this.worker = null;
+      };
+      URL.revokeObjectURL(workerURL);
+      if (this.config.verbose) {
+        console.log("[BrowserNoirProvider] Web Worker initialized successfully");
+      }
+    } catch (error) {
+      if (this.config.verbose) {
+        console.warn("[BrowserNoirProvider] Failed to initialize worker, using main thread:", error);
+      }
+      this.worker = null;
+    }
+  }
+  /**
+   * Get inline worker code for bundler compatibility
+   */
+  getWorkerCode() {
+    return `
+      self.onmessage = async function(event) {
+        const { id, type } = event.data;
+        // Signal that worker received message but proof gen happens on main thread
+        self.postMessage({ id, type: 'fallback', message: 'Worker initialized, using main thread for proofs' });
+      };
+    `;
+  }
+  /**
+   * Handle messages from worker
+   */
+  handleWorkerMessage(data) {
+    const pending = this.workerPending.get(data.id);
+    if (!pending) return;
+    switch (data.type) {
+      case "success":
+        this.workerPending.delete(data.id);
+        pending.resolve(data.result);
+        break;
+      case "error":
+        this.workerPending.delete(data.id);
+        pending.reject(new Error(data.error));
+        break;
+      case "fallback":
+        break;
     }
   }
   /**
@@ -390,15 +555,10 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
         percent: 10,
         message: "Preparing witness inputs..."
       });
-      const { commitmentHash, blindingField } = await this.computeCommitmentHash(
-        params.balance,
-        params.blindingFactor,
-        params.assetId
-      );
+      const blindingField = this.bytesToField(params.blindingFactor);
       const witnessInputs = {
-        commitment_hash: commitmentHash,
         minimum_required: params.minimumRequired.toString(),
-        asset_id: this.assetIdToField(params.assetId),
+        asset_id: `0x${this.assetIdToField(params.assetId)}`,
         balance: params.balance.toString(),
         blinding: blindingField
       };
@@ -407,7 +567,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
         percent: 30,
         message: "Generating witness..."
       });
-      const { witness } = await this.fundingNoir.execute(witnessInputs);
+      const { witness, returnValue } = await this.fundingNoir.execute(witnessInputs);
       onProgress?.({
         stage: "proving",
         percent: 50,
@@ -419,10 +579,12 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
         percent: 100,
         message: "Proof generated successfully"
       });
+      const commitmentHashBytes = returnValue;
+      const commitmentHashHex = bytesToHex(new Uint8Array(commitmentHashBytes));
       const publicInputs = [
-        `0x${commitmentHash}`,
         `0x${params.minimumRequired.toString(16).padStart(16, "0")}`,
-        `0x${this.assetIdToField(params.assetId)}`
+        `0x${this.assetIdToField(params.assetId)}`,
+        `0x${commitmentHashHex}`
       ];
       const proof = {
         type: "funding",
@@ -824,6 +986,314 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     return { x, y };
   }
 };
+
+// src/proofs/worker.ts
+function createWorkerBlobURL() {
+  const workerCode = `
+    // Proof Generation Worker
+    // This code runs in a separate thread
+
+    let fundingNoir = null;
+    let fundingBackend = null;
+    let validityNoir = null;
+    let validityBackend = null;
+    let fulfillmentNoir = null;
+    let fulfillmentBackend = null;
+    let isReady = false;
+    let config = { verbose: false };
+
+    // Helper to send progress updates
+    function sendProgress(id, stage, percent, message) {
+      self.postMessage({
+        id,
+        type: 'progress',
+        progress: { stage, percent, message }
+      });
+    }
+
+    // Helper to send error
+    function sendError(id, error) {
+      self.postMessage({
+        id,
+        type: 'error',
+        error: error.message || String(error)
+      });
+    }
+
+    // Helper to send success
+    function sendSuccess(id, result) {
+      self.postMessage({
+        id,
+        type: 'success',
+        result
+      });
+    }
+
+    // Initialize circuits (called once)
+    async function initialize(id, initConfig) {
+      try {
+        sendProgress(id, 'initializing', 10, 'Loading Noir JS...');
+
+        // Dynamic imports for Noir
+        const { Noir } = await import('@noir-lang/noir_js');
+        const { UltraHonkBackend } = await import('@aztec/bb.js');
+
+        sendProgress(id, 'initializing', 30, 'Loading circuit artifacts...');
+
+        // Load circuit artifacts
+        const [fundingArtifact, validityArtifact, fulfillmentArtifact] = await Promise.all([
+          fetch(new URL('./circuits/funding_proof.json', import.meta.url)).then(r => r.json()),
+          fetch(new URL('./circuits/validity_proof.json', import.meta.url)).then(r => r.json()),
+          fetch(new URL('./circuits/fulfillment_proof.json', import.meta.url)).then(r => r.json()),
+        ]);
+
+        sendProgress(id, 'initializing', 50, 'Initializing backends...');
+
+        // Initialize Noir instances
+        fundingNoir = new Noir(fundingArtifact);
+        fundingBackend = new UltraHonkBackend(fundingArtifact.bytecode);
+
+        sendProgress(id, 'initializing', 70, 'Initializing validity circuit...');
+        validityNoir = new Noir(validityArtifact);
+        validityBackend = new UltraHonkBackend(validityArtifact.bytecode);
+
+        sendProgress(id, 'initializing', 90, 'Initializing fulfillment circuit...');
+        fulfillmentNoir = new Noir(fulfillmentArtifact);
+        fulfillmentBackend = new UltraHonkBackend(fulfillmentArtifact.bytecode);
+
+        config = initConfig || { verbose: false };
+        isReady = true;
+
+        sendProgress(id, 'complete', 100, 'Worker initialized');
+        sendSuccess(id, { initialized: true });
+      } catch (error) {
+        sendError(id, error);
+      }
+    }
+
+    // Generate funding proof
+    async function generateFundingProof(id, params) {
+      if (!isReady) {
+        sendError(id, new Error('Worker not initialized'));
+        return;
+      }
+
+      try {
+        sendProgress(id, 'witness', 20, 'Preparing witness...');
+
+        // Convert blinding factor to field
+        const blindingField = bytesToField(params.blindingFactor);
+
+        const witnessInputs = {
+          minimum_required: params.minimumRequired.toString(),
+          asset_id: '0x' + assetIdToField(params.assetId),
+          balance: params.balance.toString(),
+          blinding: blindingField,
+        };
+
+        sendProgress(id, 'witness', 40, 'Executing circuit...');
+        const { witness, returnValue } = await fundingNoir.execute(witnessInputs);
+
+        sendProgress(id, 'proving', 60, 'Generating proof...');
+        const proofData = await fundingBackend.generateProof(witness);
+
+        sendProgress(id, 'complete', 100, 'Proof generated');
+
+        // Extract commitment hash from return value
+        const commitmentHashHex = bytesToHex(new Uint8Array(returnValue));
+
+        const publicInputs = [
+          '0x' + params.minimumRequired.toString(16).padStart(16, '0'),
+          '0x' + assetIdToField(params.assetId),
+          '0x' + commitmentHashHex,
+        ];
+
+        const proof = {
+          type: 'funding',
+          proof: '0x' + bytesToHex(proofData.proof),
+          publicInputs,
+        };
+
+        sendSuccess(id, { proof, publicInputs });
+      } catch (error) {
+        sendError(id, error);
+      }
+    }
+
+    // Helper functions
+    function 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();
+    }
+
+    function 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');
+    }
+
+    function bytesToHex(bytes) {
+      return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+
+    // Message handler
+    self.onmessage = async function(event) {
+      const { id, type, params, config: initConfig } = event.data;
+
+      switch (type) {
+        case 'init':
+          await initialize(id, initConfig);
+          break;
+        case 'generateFundingProof':
+          await generateFundingProof(id, params);
+          break;
+        case 'generateValidityProof':
+          // TODO: Implement
+          sendError(id, new Error('Validity proof not yet implemented in worker'));
+          break;
+        case 'generateFulfillmentProof':
+          // TODO: Implement
+          sendError(id, new Error('Fulfillment proof not yet implemented in worker'));
+          break;
+        case 'destroy':
+          // Cleanup
+          fundingNoir = null;
+          fundingBackend = null;
+          validityNoir = null;
+          validityBackend = null;
+          fulfillmentNoir = null;
+          fulfillmentBackend = null;
+          isReady = false;
+          sendSuccess(id, { destroyed: true });
+          break;
+        default:
+          sendError(id, new Error('Unknown message type: ' + type));
+      }
+    };
+  `;
+  const blob = new Blob([workerCode], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+var ProofWorker = class _ProofWorker {
+  worker = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  _isReady = false;
+  requestCounter = 0;
+  /**
+   * Check if Web Workers are supported
+   */
+  static isSupported() {
+    return typeof Worker !== "undefined" && typeof Blob !== "undefined";
+  }
+  /**
+   * Check if worker is initialized and ready
+   */
+  get isReady() {
+    return this._isReady;
+  }
+  /**
+   * Initialize the worker
+   */
+  async initialize(config) {
+    if (this._isReady) {
+      return;
+    }
+    if (!_ProofWorker.isSupported()) {
+      throw new Error("Web Workers not supported in this environment");
+    }
+    const workerURL = createWorkerBlobURL();
+    this.worker = new Worker(workerURL, { type: "module" });
+    this.worker.onmessage = (event) => {
+      this.handleWorkerMessage(event.data);
+    };
+    this.worker.onerror = (error) => {
+      console.error("[ProofWorker] Worker error:", error);
+      for (const [id, { reject }] of this.pendingRequests) {
+        reject(new Error(`Worker error: ${error.message}`));
+        this.pendingRequests.delete(id);
+      }
+    };
+    await this.sendRequest("init", void 0, config);
+    this._isReady = true;
+    URL.revokeObjectURL(workerURL);
+  }
+  /**
+   * Generate a proof using the worker
+   */
+  async generateProof(type, params, onProgress) {
+    if (!this._isReady || !this.worker) {
+      throw new Error("Worker not initialized. Call initialize() first.");
+    }
+    const messageType = type === "funding" ? "generateFundingProof" : type === "validity" ? "generateValidityProof" : "generateFulfillmentProof";
+    return this.sendRequest(messageType, params, void 0, onProgress);
+  }
+  /**
+   * Destroy the worker and free resources
+   */
+  async destroy() {
+    if (this.worker) {
+      try {
+        await this.sendRequest("destroy");
+      } catch {
+      }
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this._isReady = false;
+    this.pendingRequests.clear();
+  }
+  /**
+   * Send a request to the worker
+   */
+  sendRequest(type, params, config, onProgress) {
+    return new Promise((resolve, reject) => {
+      if (!this.worker) {
+        reject(new Error("Worker not available"));
+        return;
+      }
+      const id = `req_${++this.requestCounter}_${Date.now()}`;
+      this.pendingRequests.set(id, { resolve, reject, onProgress });
+      const request = { id, type, params, config };
+      this.worker.postMessage(request);
+    });
+  }
+  /**
+   * Handle messages from the worker
+   */
+  handleWorkerMessage(response) {
+    const pending = this.pendingRequests.get(response.id);
+    if (!pending) {
+      console.warn("[ProofWorker] Received response for unknown request:", response.id);
+      return;
+    }
+    switch (response.type) {
+      case "success":
+        this.pendingRequests.delete(response.id);
+        pending.resolve(response.result);
+        break;
+      case "error":
+        this.pendingRequests.delete(response.id);
+        pending.reject(new Error(response.error));
+        break;
+      case "progress":
+        if (pending.onProgress && response.progress) {
+          pending.onProgress(response.progress);
+        }
+        break;
+    }
+  }
+};
 export {
   ATTESTATION_VERSION,
   BaseWalletAdapter,
@@ -866,6 +1336,7 @@ export {
   ProofError,
   ProofGenerationError,
   ProofNotImplementedError,
+  ProofWorker,
   ProposalStatus,
   ReportStatus,
   SIP,
@@ -893,6 +1364,7 @@ export {
   bytesToHex as browserBytesToHex,
   hexToBytes as browserHexToBytes,
   checkEd25519StealthAddress,
+  checkMobileWASMCompatibility,
   checkStealthAddress,
   commit,
   commitZero,
@@ -917,6 +1389,7 @@ export {
   createSolanaAdapter,
   createTrezorAdapter,
   createWalletFactory,
+  createWorkerBlobURL,
   createZcashClient,
   createZcashShieldedService,
   createZcashSwapService,
@@ -931,6 +1404,8 @@ export {
   deserializeIntent,
   deserializePayment,
   detectEthereumWallets,
+  detectMobileBrowser,
+  detectMobilePlatform,
   detectSolanaWallets,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
@@ -951,6 +1426,7 @@ export {
   getActiveOracles,
   getAvailableTransports,
   getBrowserInfo,
+  getBrowserVersion,
   getChainNumericId,
   getChainsForStablecoin,
   getCurveForChain,
@@ -960,6 +1436,8 @@ export {
   getEthereumProvider,
   getGenerators,
   getIntentSummary,
+  getMobileDeviceInfo,
+  getOSVersion,
   getPaymentSummary,
   getPaymentTimeRemaining,
   getPrivacyConfig,
@@ -985,6 +1463,7 @@ export {
   isSIPError,
   isStablecoin,
   isStablecoinOnChain,
+  isTablet,
   isValidAmount,
   isValidChainId,
   isValidCompressedPublicKey,
@@ -1016,7 +1495,10 @@ export {
   subtractBlindings,
   subtractCommitments,
   supportsSharedArrayBuffer,
+  supportsTouch,
   supportsViewingKey,
+  supportsWASMBulkMemory,
+  supportsWASMSimd,
   supportsWebBluetooth,
   supportsWebHID,
   supportsWebUSB,