@sip-protocol/sdk 0.1.9 → 0.2.1

package/dist/browser.mjs

@@ -0,0 +1,1037 @@
+import {
+  ATTESTATION_VERSION,
+  BaseWalletAdapter,
+  CHAIN_NUMERIC_IDS,
+  ComplianceManager,
+  CryptoError,
+  DEFAULT_THRESHOLD,
+  DEFAULT_TOTAL_ORACLES,
+  DerivationPath,
+  EncryptionNotImplementedError,
+  ErrorCode,
+  EthereumChainId,
+  EthereumWalletAdapter,
+  HardwareErrorCode,
+  HardwareWalletError,
+  IntentBuilder,
+  IntentError,
+  IntentStatus,
+  LedgerWalletAdapter,
+  MockEthereumAdapter,
+  MockLedgerAdapter,
+  MockProofProvider,
+  MockSolanaAdapter,
+  MockSolver,
+  MockTrezorAdapter,
+  MockWalletAdapter,
+  NATIVE_TOKENS,
+  NEARIntentsAdapter,
+  NetworkError,
+  NoirProofProvider,
+  ORACLE_DOMAIN,
+  OneClickClient,
+  OneClickDepositMode,
+  OneClickErrorCode,
+  OneClickSwapStatus,
+  OneClickSwapType,
+  PaymentBuilder,
+  PaymentStatus,
+  PrivacyLevel,
+  ProofError,
+  ProofGenerationError,
+  ProofNotImplementedError,
+  ProposalStatus,
+  ReportStatus,
+  SIP,
+  SIPError,
+  SIP_VERSION,
+  STABLECOIN_ADDRESSES,
+  STABLECOIN_DECIMALS,
+  STABLECOIN_INFO,
+  SolanaWalletAdapter,
+  Treasury,
+  TrezorWalletAdapter,
+  ValidationError,
+  WalletError,
+  WalletErrorCode,
+  ZcashErrorCode,
+  ZcashRPCClient,
+  ZcashRPCError,
+  ZcashShieldedService,
+  addBlindings,
+  addCommitments,
+  addOracle,
+  attachProofs,
+  base58ToHex,
+  bytesToHex,
+  checkEd25519StealthAddress,
+  checkStealthAddress,
+  commit,
+  commitZero,
+  computeAttestationHash,
+  createCommitment,
+  createEthereumAdapter,
+  createLedgerAdapter,
+  createMockEthereumAdapter,
+  createMockEthereumProvider,
+  createMockLedgerAdapter,
+  createMockSolanaAdapter,
+  createMockSolanaConnection,
+  createMockSolanaProvider,
+  createMockSolver,
+  createMockTrezorAdapter,
+  createNEARIntentsAdapter,
+  createOracleRegistry,
+  createProductionSIP,
+  createSIP,
+  createShieldedIntent,
+  createShieldedPayment,
+  createSolanaAdapter,
+  createTrezorAdapter,
+  createWalletFactory,
+  createZcashClient,
+  createZcashShieldedService,
+  decodeStealthMetaAddress,
+  decryptMemo,
+  decryptWithViewing,
+  deriveEd25519StealthPrivateKey,
+  deriveOracleId,
+  deriveStealthPrivateKey,
+  deriveViewingKey,
+  deserializeAttestationMessage,
+  deserializeIntent,
+  deserializePayment,
+  detectEthereumWallets,
+  detectSolanaWallets,
+  ed25519PublicKeyToNearAddress,
+  ed25519PublicKeyToSolanaAddress,
+  encodeStealthMetaAddress,
+  encryptForViewing,
+  featureNotSupportedError,
+  formatStablecoinAmount,
+  fromHex,
+  fromStablecoinUnits,
+  fulfillment_proof_default,
+  funding_proof_default,
+  generateBlinding,
+  generateEd25519StealthAddress,
+  generateEd25519StealthMetaAddress,
+  generateIntentId,
+  generateRandomBytes,
+  generateStealthAddress,
+  generateStealthMetaAddress,
+  generateViewingKey,
+  getActiveOracles,
+  getAvailableTransports,
+  getBrowserInfo,
+  getChainNumericId,
+  getChainsForStablecoin,
+  getCurveForChain,
+  getDefaultRpcEndpoint,
+  getDerivationPath,
+  getErrorMessage,
+  getEthereumProvider,
+  getGenerators,
+  getIntentSummary,
+  getPaymentSummary,
+  getPaymentTimeRemaining,
+  getPrivacyConfig,
+  getPrivacyDescription,
+  getSolanaProvider,
+  getStablecoin,
+  getStablecoinInfo,
+  getStablecoinsForChain,
+  getSupportedStablecoins,
+  getTimeRemaining,
+  hasEnoughOracles,
+  hasErrorCode,
+  hasRequiredProofs,
+  hash,
+  hexToBytes,
+  hexToNumber,
+  isBrowser,
+  isEd25519Chain,
+  isExpired,
+  isNonNegativeAmount,
+  isPaymentExpired,
+  isPrivate,
+  isPrivateWalletAdapter,
+  isSIPError,
+  isStablecoin,
+  isStablecoinOnChain,
+  isValidAmount,
+  isValidChainId,
+  isValidCompressedPublicKey,
+  isValidEd25519PublicKey,
+  isValidHex,
+  isValidHexLength,
+  isValidNearAccountId,
+  isValidNearImplicitAddress,
+  isValidPrivacyLevel,
+  isValidPrivateKey,
+  isValidScalar,
+  isValidSlippage,
+  isValidSolanaAddress,
+  isValidStealthMetaAddress,
+  nearAddressToEd25519PublicKey,
+  normalizeAddress,
+  notConnectedError,
+  publicKeyToEthAddress,
+  registerWallet,
+  removeOracle,
+  secureWipe,
+  secureWipeAll,
+  serializeAttestationMessage,
+  serializeIntent,
+  serializePayment,
+  signAttestationMessage,
+  solanaAddressToEd25519PublicKey,
+  solanaPublicKeyToHex,
+  subtractBlindings,
+  subtractCommitments,
+  supportsSharedArrayBuffer,
+  supportsViewingKey,
+  supportsWebBluetooth,
+  supportsWebHID,
+  supportsWebUSB,
+  supportsWebWorkers,
+  toHex,
+  toStablecoinUnits,
+  trackIntent,
+  trackPayment,
+  updateOracleStatus,
+  validateAsset,
+  validateCreateIntentParams,
+  validateIntentInput,
+  validateIntentOutput,
+  validateScalar,
+  validateViewingKey,
+  validity_proof_default,
+  verifyAttestation,
+  verifyCommitment,
+  verifyOpening,
+  verifyOracleSignature,
+  walletRegistry,
+  withSecureBuffer,
+  withSecureBufferSync,
+  wrapError
+} from "./chunk-4VJHI66K.mjs";
+
+// src/proofs/browser.ts
+import { Noir } from "@noir-lang/noir_js";
+import { UltraHonkBackend } from "@aztec/bb.js";
+import { secp256k1 } from "@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 = 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 UltraHonkBackend(fundingCircuit.bytecode);
+      this.validityBackend = new UltraHonkBackend(validityCircuit.bytecode);
+      this.fulfillmentBackend = new UltraHonkBackend(fulfillmentCircuit.bytecode);
+      onProgress?.({
+        stage: "initializing",
+        percent: 60,
+        message: "Initializing Noir circuits..."
+      });
+      this.fundingNoir = new Noir(fundingCircuit);
+      this.validityNoir = new Noir(validityCircuit);
+      this.fulfillmentNoir = new 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${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 : 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${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 : 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${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 : 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 = 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);
+      }
+      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 } = 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),
+      ...hexToBytes(this.assetIdToField(assetId))
+    ]);
+    const hash2 = sha256(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 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
+    const addressBytes = hexToBytes(senderAddressField);
+    const blindingBytes = hexToBytes(senderBlindingField.padStart(64, "0"));
+    const preimage = new Uint8Array([...addressBytes, ...blindingBytes]);
+    const hash2 = sha256(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 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
+    const secretBytes = hexToBytes(senderSecretField.padStart(64, "0"));
+    const intentBytes = hexToBytes(intentHashField);
+    const nonceBytes = hexToBytes(nonceField.padStart(64, "0"));
+    const preimage = new Uint8Array([...secretBytes, ...intentBytes, ...nonceBytes]);
+    const hash2 = sha256(preimage);
+    return nobleToHex(hash2);
+  }
+  async computeOutputCommitment(outputAmount, outputBlinding) {
+    const { sha256 } = 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 = sha256(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 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
+    const secretBytes = hexToBytes(solverSecretField.padStart(64, "0"));
+    const hash2 = sha256(secretBytes);
+    return nobleToHex(hash2);
+  }
+  async computeOracleMessageHash(recipient, amount, txHash, blockNumber) {
+    const { sha256 } = await import("@noble/hashes/sha256");
+    const recipientBytes = hexToBytes(this.hexToField(recipient));
+    const amountBytes = this.bigintToBytes(amount, 8);
+    const txHashBytes = hexToBytes(this.hexToField(txHash));
+    const blockBytes = this.bigintToBytes(blockNumber, 8);
+    const preimage = new Uint8Array([
+      ...recipientBytes,
+      ...amountBytes,
+      ...txHashBytes,
+      ...blockBytes
+    ]);
+    const hash2 = sha256(preimage);
+    return Array.from(hash2);
+  }
+  getPublicKeyCoordinates(privateKey) {
+    const uncompressedPubKey = secp256k1.getPublicKey(privateKey, false);
+    const x = Array.from(uncompressedPubKey.slice(1, 33));
+    const y = Array.from(uncompressedPubKey.slice(33, 65));
+    return { x, y };
+  }
+};
+export {
+  ATTESTATION_VERSION,
+  BaseWalletAdapter,
+  BrowserNoirProvider,
+  CHAIN_NUMERIC_IDS,
+  ComplianceManager,
+  CryptoError,
+  DEFAULT_THRESHOLD,
+  DEFAULT_TOTAL_ORACLES,
+  DerivationPath,
+  EncryptionNotImplementedError,
+  ErrorCode,
+  EthereumChainId,
+  EthereumWalletAdapter,
+  HardwareErrorCode,
+  HardwareWalletError,
+  IntentBuilder,
+  IntentError,
+  IntentStatus,
+  LedgerWalletAdapter,
+  MockEthereumAdapter,
+  MockLedgerAdapter,
+  MockProofProvider,
+  MockSolanaAdapter,
+  MockSolver,
+  MockTrezorAdapter,
+  MockWalletAdapter,
+  NATIVE_TOKENS,
+  NEARIntentsAdapter,
+  NetworkError,
+  NoirProofProvider,
+  ORACLE_DOMAIN,
+  OneClickClient,
+  OneClickDepositMode,
+  OneClickErrorCode,
+  OneClickSwapStatus,
+  OneClickSwapType,
+  PaymentBuilder,
+  PaymentStatus,
+  PrivacyLevel,
+  ProofError,
+  ProofGenerationError,
+  ProofNotImplementedError,
+  ProposalStatus,
+  ReportStatus,
+  SIP,
+  SIPError,
+  SIP_VERSION,
+  STABLECOIN_ADDRESSES,
+  STABLECOIN_DECIMALS,
+  STABLECOIN_INFO,
+  SolanaWalletAdapter,
+  Treasury,
+  TrezorWalletAdapter,
+  ValidationError,
+  WalletError,
+  WalletErrorCode,
+  ZcashErrorCode,
+  ZcashRPCClient,
+  ZcashRPCError,
+  ZcashShieldedService,
+  addBlindings,
+  addCommitments,
+  addOracle,
+  attachProofs,
+  base58ToHex,
+  bytesToHex as browserBytesToHex,
+  hexToBytes as browserHexToBytes,
+  checkEd25519StealthAddress,
+  checkStealthAddress,
+  commit,
+  commitZero,
+  computeAttestationHash,
+  createCommitment,
+  createEthereumAdapter,
+  createLedgerAdapter,
+  createMockEthereumAdapter,
+  createMockEthereumProvider,
+  createMockLedgerAdapter,
+  createMockSolanaAdapter,
+  createMockSolanaConnection,
+  createMockSolanaProvider,
+  createMockSolver,
+  createMockTrezorAdapter,
+  createNEARIntentsAdapter,
+  createOracleRegistry,
+  createProductionSIP,
+  createSIP,
+  createShieldedIntent,
+  createShieldedPayment,
+  createSolanaAdapter,
+  createTrezorAdapter,
+  createWalletFactory,
+  createZcashClient,
+  createZcashShieldedService,
+  decodeStealthMetaAddress,
+  decryptMemo,
+  decryptWithViewing,
+  deriveEd25519StealthPrivateKey,
+  deriveOracleId,
+  deriveStealthPrivateKey,
+  deriveViewingKey,
+  deserializeAttestationMessage,
+  deserializeIntent,
+  deserializePayment,
+  detectEthereumWallets,
+  detectSolanaWallets,
+  ed25519PublicKeyToNearAddress,
+  ed25519PublicKeyToSolanaAddress,
+  encodeStealthMetaAddress,
+  encryptForViewing,
+  featureNotSupportedError,
+  formatStablecoinAmount,
+  fromHex,
+  fromStablecoinUnits,
+  generateBlinding,
+  generateEd25519StealthAddress,
+  generateEd25519StealthMetaAddress,
+  generateIntentId,
+  generateRandomBytes,
+  generateStealthAddress,
+  generateStealthMetaAddress,
+  generateViewingKey,
+  getActiveOracles,
+  getAvailableTransports,
+  getBrowserInfo,
+  getChainNumericId,
+  getChainsForStablecoin,
+  getCurveForChain,
+  getDefaultRpcEndpoint,
+  getDerivationPath,
+  getErrorMessage,
+  getEthereumProvider,
+  getGenerators,
+  getIntentSummary,
+  getPaymentSummary,
+  getPaymentTimeRemaining,
+  getPrivacyConfig,
+  getPrivacyDescription,
+  getSolanaProvider,
+  getStablecoin,
+  getStablecoinInfo,
+  getStablecoinsForChain,
+  getSupportedStablecoins,
+  getTimeRemaining,
+  hasEnoughOracles,
+  hasErrorCode,
+  hasRequiredProofs,
+  hash,
+  hexToNumber,
+  isBrowser,
+  isEd25519Chain,
+  isExpired,
+  isNonNegativeAmount,
+  isPaymentExpired,
+  isPrivate,
+  isPrivateWalletAdapter,
+  isSIPError,
+  isStablecoin,
+  isStablecoinOnChain,
+  isValidAmount,
+  isValidChainId,
+  isValidCompressedPublicKey,
+  isValidEd25519PublicKey,
+  isValidHex,
+  isValidHexLength,
+  isValidNearAccountId,
+  isValidNearImplicitAddress,
+  isValidPrivacyLevel,
+  isValidPrivateKey,
+  isValidScalar,
+  isValidSlippage,
+  isValidSolanaAddress,
+  isValidStealthMetaAddress,
+  nearAddressToEd25519PublicKey,
+  normalizeAddress,
+  notConnectedError,
+  publicKeyToEthAddress,
+  registerWallet,
+  removeOracle,
+  secureWipe,
+  secureWipeAll,
+  serializeAttestationMessage,
+  serializeIntent,
+  serializePayment,
+  signAttestationMessage,
+  solanaAddressToEd25519PublicKey,
+  solanaPublicKeyToHex,
+  subtractBlindings,
+  subtractCommitments,
+  supportsSharedArrayBuffer,
+  supportsViewingKey,
+  supportsWebBluetooth,
+  supportsWebHID,
+  supportsWebUSB,
+  supportsWebWorkers,
+  toHex,
+  toStablecoinUnits,
+  trackIntent,
+  trackPayment,
+  updateOracleStatus,
+  validateAsset,
+  validateCreateIntentParams,
+  validateIntentInput,
+  validateIntentOutput,
+  validateScalar,
+  validateViewingKey,
+  verifyAttestation,
+  verifyCommitment,
+  verifyOpening,
+  verifyOracleSignature,
+  walletRegistry,
+  withSecureBuffer,
+  withSecureBufferSync,
+  wrapError
+};