@sip-protocol/sdk 0.2.0 → 0.2.2

package/dist/browser.mjs

@@ -1,21 +1,16 @@
 import {
   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,
@@ -27,8 +22,6 @@ import {
   MockWalletAdapter,
   NATIVE_TOKENS,
   NEARIntentsAdapter,
-  NetworkError,
-  NoirProofProvider,
   ORACLE_DOMAIN,
   OneClickClient,
   OneClickDepositMode,
@@ -38,13 +31,9 @@ import {
   PaymentBuilder,
   PaymentStatus,
   PrivacyLevel,
-  ProofError,
-  ProofGenerationError,
-  ProofNotImplementedError,
   ProposalStatus,
   ReportStatus,
   SIP,
-  SIPError,
   SIP_VERSION,
   STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS,
@@ -52,7 +41,6 @@ import {
   SolanaWalletAdapter,
   Treasury,
   TrezorWalletAdapter,
-  ValidationError,
   WalletError,
   WalletErrorCode,
   ZcashErrorCode,
@@ -128,7 +116,6 @@ import {
   getCurveForChain,
   getDefaultRpcEndpoint,
   getDerivationPath,
-  getErrorMessage,
   getEthereumProvider,
   getGenerators,
   getIntentSummary,
@@ -143,7 +130,6 @@ import {
   getSupportedStablecoins,
   getTimeRemaining,
   hasEnoughOracles,
-  hasErrorCode,
   hasRequiredProofs,
   hash,
   hexToBytes,
@@ -155,7 +141,6 @@ import {
   isPaymentExpired,
   isPrivate,
   isPrivateWalletAdapter,
-  isSIPError,
   isStablecoin,
   isStablecoinOnChain,
   isValidAmount,
@@ -211,9 +196,632 @@ import {
   verifyOracleSignature,
   walletRegistry,
   withSecureBuffer,
-  withSecureBufferSync,
+  withSecureBufferSync
+} from "./chunk-DU7LQDD2.mjs";
+import {
+  fulfillment_proof_default,
+  funding_proof_default,
+  validity_proof_default
+} from "./chunk-VITVG25F.mjs";
+import {
+  CryptoError,
+  EncryptionNotImplementedError,
+  ErrorCode,
+  IntentError,
+  NetworkError,
+  ProofError,
+  ProofGenerationError,
+  ProofNotImplementedError,
+  SIPError,
+  ValidationError,
+  getErrorMessage,
+  hasErrorCode,
+  isSIPError,
   wrapError
-} from "./chunk-O4Y2ZUDL.mjs";
+} from "./chunk-UHZKNGIT.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,
@@ -244,7 +852,6 @@ export {
   NATIVE_TOKENS,
   NEARIntentsAdapter,
   NetworkError,
-  NoirProofProvider,
   ORACLE_DOMAIN,
   OneClickClient,
   OneClickDepositMode,