@sip-protocol/sdk 0.2.9 → 0.3.0

package/dist/browser.js

@@ -47,7 +47,7 @@ __export(browser_exports, {
   HardwareWalletError: () => HardwareWalletError,
   IntentBuilder: () => IntentBuilder,
   IntentError: () => IntentError,
-  IntentStatus: () => import_types34.IntentStatus,
+  IntentStatus: () => import_types37.IntentStatus,
   LedgerWalletAdapter: () => LedgerWalletAdapter,
   MockEthereumAdapter: () => MockEthereumAdapter,
   MockLedgerAdapter: () => MockLedgerAdapter,
@@ -56,36 +56,43 @@ __export(browser_exports, {
   MockSolver: () => MockSolver,
   MockTrezorAdapter: () => MockTrezorAdapter,
   MockWalletAdapter: () => MockWalletAdapter,
-  NATIVE_TOKENS: () => import_types34.NATIVE_TOKENS,
+  NATIVE_TOKENS: () => import_types37.NATIVE_TOKENS,
   NEARIntentsAdapter: () => NEARIntentsAdapter,
+  NEARIntentsBackend: () => NEARIntentsBackend,
   NetworkError: () => NetworkError,
   ORACLE_DOMAIN: () => ORACLE_DOMAIN,
   OneClickClient: () => OneClickClient,
-  OneClickDepositMode: () => import_types38.OneClickDepositMode,
-  OneClickErrorCode: () => import_types38.OneClickErrorCode,
-  OneClickSwapStatus: () => import_types38.OneClickSwapStatus,
-  OneClickSwapType: () => import_types38.OneClickSwapType,
+  OneClickDepositMode: () => import_types41.OneClickDepositMode,
+  OneClickErrorCode: () => import_types41.OneClickErrorCode,
+  OneClickSwapStatus: () => import_types41.OneClickSwapStatus,
+  OneClickSwapType: () => import_types41.OneClickSwapType,
   PaymentBuilder: () => PaymentBuilder,
-  PaymentStatus: () => import_types35.PaymentStatus,
-  PrivacyLevel: () => import_types34.PrivacyLevel,
+  PaymentStatus: () => import_types38.PaymentStatus,
+  PrivacyLevel: () => import_types37.PrivacyLevel,
   ProofError: () => ProofError,
   ProofGenerationError: () => ProofGenerationError,
   ProofNotImplementedError: () => ProofNotImplementedError,
-  ProposalStatus: () => import_types36.ProposalStatus,
-  ReportStatus: () => import_types37.ReportStatus,
+  ProofWorker: () => ProofWorker,
+  ProposalStatus: () => import_types39.ProposalStatus,
+  ReportStatus: () => import_types40.ReportStatus,
   SIP: () => SIP,
   SIPError: () => SIPError,
-  SIP_VERSION: () => import_types34.SIP_VERSION,
+  SIP_VERSION: () => import_types37.SIP_VERSION,
   STABLECOIN_ADDRESSES: () => STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS: () => STABLECOIN_DECIMALS,
   STABLECOIN_INFO: () => STABLECOIN_INFO,
+  SettlementRegistry: () => SettlementRegistry,
+  SettlementRegistryError: () => SettlementRegistryError,
+  SmartRouter: () => SmartRouter,
   SolanaWalletAdapter: () => SolanaWalletAdapter,
+  SwapStatus: () => SwapStatus,
   Treasury: () => Treasury,
   TrezorWalletAdapter: () => TrezorWalletAdapter,
   ValidationError: () => ValidationError,
   WalletError: () => WalletError,
-  WalletErrorCode: () => import_types33.WalletErrorCode,
-  ZcashErrorCode: () => import_types39.ZcashErrorCode,
+  WalletErrorCode: () => import_types36.WalletErrorCode,
+  ZcashErrorCode: () => import_types42.ZcashErrorCode,
+  ZcashNativeBackend: () => ZcashNativeBackend,
   ZcashRPCClient: () => ZcashRPCClient,
   ZcashRPCError: () => ZcashRPCError,
   ZcashShieldedService: () => ZcashShieldedService,
@@ -98,6 +105,7 @@ __export(browser_exports, {
   browserBytesToHex: () => bytesToHex7,
   browserHexToBytes: () => hexToBytes5,
   checkEd25519StealthAddress: () => checkEd25519StealthAddress,
+  checkMobileWASMCompatibility: () => checkMobileWASMCompatibility,
   checkStealthAddress: () => checkStealthAddress,
   commit: () => commit,
   commitZero: () => commitZero,
@@ -114,15 +122,19 @@ __export(browser_exports, {
   createMockSolver: () => createMockSolver,
   createMockTrezorAdapter: () => createMockTrezorAdapter,
   createNEARIntentsAdapter: () => createNEARIntentsAdapter,
+  createNEARIntentsBackend: () => createNEARIntentsBackend,
   createOracleRegistry: () => createOracleRegistry,
   createProductionSIP: () => createProductionSIP,
   createSIP: () => createSIP,
   createShieldedIntent: () => createShieldedIntent,
   createShieldedPayment: () => createShieldedPayment,
+  createSmartRouter: () => createSmartRouter,
   createSolanaAdapter: () => createSolanaAdapter,
   createTrezorAdapter: () => createTrezorAdapter,
   createWalletFactory: () => createWalletFactory,
+  createWorkerBlobURL: () => createWorkerBlobURL,
   createZcashClient: () => createZcashClient,
+  createZcashNativeBackend: () => createZcashNativeBackend,
   createZcashShieldedService: () => createZcashShieldedService,
   createZcashSwapService: () => createZcashSwapService,
   decodeStealthMetaAddress: () => decodeStealthMetaAddress,
@@ -136,6 +148,8 @@ __export(browser_exports, {
   deserializeIntent: () => deserializeIntent,
   deserializePayment: () => deserializePayment,
   detectEthereumWallets: () => detectEthereumWallets,
+  detectMobileBrowser: () => detectMobileBrowser,
+  detectMobilePlatform: () => detectMobilePlatform,
   detectSolanaWallets: () => detectSolanaWallets,
   ed25519PublicKeyToNearAddress: () => ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress: () => ed25519PublicKeyToSolanaAddress,
@@ -156,6 +170,7 @@ __export(browser_exports, {
   getActiveOracles: () => getActiveOracles,
   getAvailableTransports: () => getAvailableTransports,
   getBrowserInfo: () => getBrowserInfo,
+  getBrowserVersion: () => getBrowserVersion,
   getChainNumericId: () => getChainNumericId,
   getChainsForStablecoin: () => getChainsForStablecoin,
   getCurveForChain: () => getCurveForChain,
@@ -165,6 +180,8 @@ __export(browser_exports, {
   getEthereumProvider: () => getEthereumProvider,
   getGenerators: () => getGenerators,
   getIntentSummary: () => getIntentSummary,
+  getMobileDeviceInfo: () => getMobileDeviceInfo,
+  getOSVersion: () => getOSVersion,
   getPaymentSummary: () => getPaymentSummary,
   getPaymentTimeRemaining: () => getPaymentTimeRemaining,
   getPrivacyConfig: () => getPrivacyConfig,
@@ -185,11 +202,12 @@ __export(browser_exports, {
   isExpired: () => isExpired,
   isNonNegativeAmount: () => isNonNegativeAmount,
   isPaymentExpired: () => isPaymentExpired,
-  isPrivate: () => import_types34.isPrivate,
+  isPrivate: () => import_types37.isPrivate,
   isPrivateWalletAdapter: () => isPrivateWalletAdapter,
   isSIPError: () => isSIPError,
   isStablecoin: () => isStablecoin,
   isStablecoinOnChain: () => isStablecoinOnChain,
+  isTablet: () => isTablet,
   isValidAmount: () => isValidAmount,
   isValidChainId: () => isValidChainId,
   isValidCompressedPublicKey: () => isValidCompressedPublicKey,
@@ -221,7 +239,10 @@ __export(browser_exports, {
   subtractBlindings: () => subtractBlindings,
   subtractCommitments: () => subtractCommitments,
   supportsSharedArrayBuffer: () => supportsSharedArrayBuffer,
-  supportsViewingKey: () => import_types34.supportsViewingKey,
+  supportsTouch: () => supportsTouch,
+  supportsViewingKey: () => import_types37.supportsViewingKey,
+  supportsWASMBulkMemory: () => supportsWASMBulkMemory,
+  supportsWASMSimd: () => supportsWASMSimd,
   supportsWebBluetooth: () => supportsWebBluetooth,
   supportsWebHID: () => supportsWebHID,
   supportsWebUSB: () => supportsWebUSB,
@@ -3460,6 +3481,280 @@ var MockProofProvider = class {
 };
 
 // src/proofs/browser-utils.ts
+function detectMobilePlatform() {
+  if (typeof navigator === "undefined") return "desktop";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/iphone|ipad|ipod/.test(ua) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return "ios";
+  }
+  if (/android/.test(ua)) {
+    return "android";
+  }
+  if (/mobile|webos|blackberry|opera mini|opera mobi|iemobile|wpdesktop/.test(ua)) {
+    return "other";
+  }
+  return "desktop";
+}
+function detectMobileBrowser() {
+  if (typeof navigator === "undefined") return "other";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/safari/.test(ua) && /iphone|ipad|ipod/.test(ua) && !/crios|fxios/.test(ua)) {
+    return "safari";
+  }
+  if (/chrome|crios/.test(ua) && !/edg|opr|samsung/.test(ua)) {
+    return "chrome";
+  }
+  if (/firefox|fxios/.test(ua)) {
+    return "firefox";
+  }
+  if (/samsung/.test(ua)) {
+    return "samsung";
+  }
+  if (/opr|opera/.test(ua)) {
+    return "opera";
+  }
+  if (/edg/.test(ua)) {
+    return "edge";
+  }
+  return "other";
+}
+function getBrowserVersion() {
+  if (typeof navigator === "undefined") return null;
+  const ua = navigator.userAgent;
+  const browser = detectMobileBrowser();
+  const patterns = {
+    safari: /version\/(\d+(\.\d+)*)/i,
+    chrome: /chrome\/(\d+(\.\d+)*)|crios\/(\d+(\.\d+)*)/i,
+    firefox: /firefox\/(\d+(\.\d+)*)|fxios\/(\d+(\.\d+)*)/i,
+    samsung: /samsungbrowser\/(\d+(\.\d+)*)/i,
+    opera: /opr\/(\d+(\.\d+)*)/i,
+    edge: /edg\/(\d+(\.\d+)*)/i,
+    other: /version\/(\d+(\.\d+)*)/i
+  };
+  const pattern = patterns[browser] || patterns.other;
+  const match = ua.match(pattern);
+  if (match) {
+    for (let i = 1; i < match.length; i++) {
+      if (match[i]) return match[i];
+    }
+  }
+  return null;
+}
+function getOSVersion() {
+  if (typeof navigator === "undefined") return null;
+  const ua = navigator.userAgent;
+  const platform = detectMobilePlatform();
+  if (platform === "ios") {
+    const match = ua.match(/os (\d+[_\d]*)/i);
+    return match ? match[1].replace(/_/g, ".") : null;
+  }
+  if (platform === "android") {
+    const match = ua.match(/android (\d+(\.\d+)*)/i);
+    return match ? match[1] : null;
+  }
+  return null;
+}
+function isTablet() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  if (/ipad/.test(ua) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return true;
+  }
+  if (/android/.test(ua) && !/mobile/.test(ua)) {
+    return true;
+  }
+  return false;
+}
+function supportsTouch() {
+  if (typeof window === "undefined") return false;
+  return "ontouchstart" in window || navigator.maxTouchPoints > 0;
+}
+function getMobileDeviceInfo() {
+  const platform = detectMobilePlatform();
+  return {
+    isMobile: platform !== "desktop",
+    platform,
+    browser: detectMobileBrowser(),
+    browserVersion: getBrowserVersion(),
+    osVersion: getOSVersion(),
+    isTablet: isTablet(),
+    supportsTouch: supportsTouch(),
+    deviceMemoryGB: (
+      // @ts-expect-error - deviceMemory is non-standard
+      typeof navigator !== "undefined" && navigator.deviceMemory ? (
+        // @ts-expect-error - deviceMemory is non-standard
+        navigator.deviceMemory
+      ) : null
+    ),
+    hardwareConcurrency: typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : null
+  };
+}
+function supportsWASMSimd() {
+  try {
+    return WebAssembly.validate(
+      new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        1,
+        0,
+        0,
+        0,
+        1,
+        5,
+        1,
+        96,
+        0,
+        1,
+        123,
+        3,
+        2,
+        1,
+        0,
+        10,
+        10,
+        1,
+        8,
+        0,
+        65,
+        0,
+        253,
+        15,
+        253,
+        98,
+        11
+      ])
+    );
+  } catch {
+    return false;
+  }
+}
+function supportsWASMBulkMemory() {
+  try {
+    return WebAssembly.validate(
+      new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        1,
+        0,
+        0,
+        0,
+        1,
+        4,
+        1,
+        96,
+        0,
+        0,
+        3,
+        2,
+        1,
+        0,
+        5,
+        3,
+        1,
+        0,
+        1,
+        10,
+        13,
+        1,
+        11,
+        0,
+        65,
+        0,
+        65,
+        0,
+        65,
+        0,
+        252,
+        11,
+        0,
+        11
+      ])
+    );
+  } catch {
+    return false;
+  }
+}
+function checkMobileWASMCompatibility() {
+  const issues = [];
+  const recommendations = [];
+  let score = 100;
+  const webAssembly = typeof WebAssembly !== "undefined";
+  if (!webAssembly) {
+    issues.push("WebAssembly not supported");
+    score -= 50;
+  }
+  const sharedArrayBuffer = supportsSharedArrayBuffer();
+  if (!sharedArrayBuffer) {
+    issues.push("SharedArrayBuffer not available (requires COOP/COEP headers)");
+    recommendations.push("Server must send Cross-Origin-Opener-Policy: same-origin");
+    recommendations.push("Server must send Cross-Origin-Embedder-Policy: require-corp");
+    score -= 20;
+  }
+  const webWorkers = supportsWebWorkers();
+  if (!webWorkers) {
+    issues.push("Web Workers not supported");
+    recommendations.push("Consider using a polyfill or fallback to main-thread execution");
+    score -= 15;
+  }
+  const simd = supportsWASMSimd();
+  if (!simd) {
+    recommendations.push("WASM SIMD not supported - proofs will be slower");
+    score -= 5;
+  }
+  const bulkMemory = supportsWASMBulkMemory();
+  if (!bulkMemory) {
+    recommendations.push("WASM bulk memory not supported - may affect performance");
+    score -= 5;
+  }
+  const bigInt = typeof BigInt !== "undefined";
+  if (!bigInt) {
+    issues.push("BigInt not supported (required for 64-bit operations)");
+    score -= 10;
+  }
+  const deviceInfo = getMobileDeviceInfo();
+  if (deviceInfo.isMobile) {
+    if (deviceInfo.deviceMemoryGB !== null && deviceInfo.deviceMemoryGB < 2) {
+      recommendations.push(`Low device memory (${deviceInfo.deviceMemoryGB}GB) - may experience issues with large proofs`);
+      score -= 5;
+    }
+    if (deviceInfo.platform === "ios" && deviceInfo.browser === "safari") {
+      if (!sharedArrayBuffer) {
+        recommendations.push("iOS Safari requires iOS 15.2+ for SharedArrayBuffer support");
+      }
+    }
+    if (deviceInfo.platform === "android" && deviceInfo.browser === "chrome") {
+      if (!sharedArrayBuffer) {
+        recommendations.push("Ensure COOP/COEP headers are set - Chrome Android requires them");
+      }
+    }
+  }
+  let summary;
+  if (score >= 90) {
+    summary = "Excellent - Full WASM proof support";
+  } else if (score >= 70) {
+    summary = "Good - WASM proofs supported with minor limitations";
+  } else if (score >= 50) {
+    summary = "Limited - WASM proofs may work with reduced performance";
+  } else {
+    summary = "Poor - WASM proofs not recommended on this device";
+  }
+  return {
+    webAssembly,
+    sharedArrayBuffer,
+    webWorkers,
+    simd,
+    bulkMemory,
+    bigInt,
+    score: Math.max(0, score),
+    summary,
+    issues,
+    recommendations
+  };
+}
 function hexToBytes5(hex) {
   const h = hex.startsWith("0x") ? hex.slice(2) : hex;
   if (h.length === 0) return new Uint8Array(0);
@@ -3775,10 +4070,10 @@ function hasEnoughOracles(registry) {
 }
 
 // src/index.ts
-var import_types34 = require("@sip-protocol/types");
-var import_types35 = require("@sip-protocol/types");
-var import_types36 = require("@sip-protocol/types");
 var import_types37 = require("@sip-protocol/types");
+var import_types38 = require("@sip-protocol/types");
+var import_types39 = require("@sip-protocol/types");
+var import_types40 = require("@sip-protocol/types");
 
 // src/solver/mock-solver.ts
 var import_types7 = require("@sip-protocol/types");
@@ -3948,25 +4243,1142 @@ var MockSolver = class {
   async getStatus(intentId) {
     return this.pendingFulfillments.get(intentId) ?? null;
   }
-  /**
-   * Reset solver state (for testing)
-   */
-  reset() {
-    this.pendingFulfillments.clear();
+  /**
+   * Reset solver state (for testing)
+   */
+  reset() {
+    this.pendingFulfillments.clear();
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createMockSolver(config) {
+  return new MockSolver(config);
+}
+
+// src/index.ts
+var import_types41 = require("@sip-protocol/types");
+
+// src/settlement/interface.ts
+var SwapStatus = /* @__PURE__ */ ((SwapStatus2) => {
+  SwapStatus2["PENDING_DEPOSIT"] = "pending_deposit";
+  SwapStatus2["DEPOSIT_CONFIRMED"] = "deposit_confirmed";
+  SwapStatus2["IN_PROGRESS"] = "in_progress";
+  SwapStatus2["SUCCESS"] = "success";
+  SwapStatus2["FAILED"] = "failed";
+  SwapStatus2["CANCELLED"] = "cancelled";
+  SwapStatus2["REFUNDING"] = "refunding";
+  SwapStatus2["REFUNDED"] = "refunded";
+  return SwapStatus2;
+})(SwapStatus || {});
+
+// src/settlement/registry.ts
+var SettlementRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SettlementRegistryError";
+  }
+};
+var SettlementRegistry = class {
+  backends = /* @__PURE__ */ new Map();
+  /**
+   * Register a settlement backend
+   *
+   * @param backend - Settlement backend to register
+   * @throws {SettlementRegistryError} If backend with same name already exists
+   *
+   * @example
+   * ```typescript
+   * registry.register(nearIntentsBackend)
+   * ```
+   */
+  register(backend) {
+    if (this.backends.has(backend.name)) {
+      throw new SettlementRegistryError(
+        `Backend '${backend.name}' is already registered`
+      );
+    }
+    this.backends.set(backend.name, backend);
+  }
+  /**
+   * Get a settlement backend by name
+   *
+   * @param name - Backend name
+   * @returns Settlement backend
+   * @throws {SettlementRegistryError} If backend is not found
+   *
+   * @example
+   * ```typescript
+   * const backend = registry.get('near-intents')
+   * ```
+   */
+  get(name) {
+    const backend = this.backends.get(name);
+    if (!backend) {
+      throw new SettlementRegistryError(`Backend '${name}' not found`);
+    }
+    return backend;
+  }
+  /**
+   * List all registered backend names
+   *
+   * @returns Array of backend names
+   *
+   * @example
+   * ```typescript
+   * const names = registry.list()
+   * // ['near-intents', 'zcash', 'thorchain']
+   * ```
+   */
+  list() {
+    return Array.from(this.backends.keys());
+  }
+  /**
+   * Get the best backend for a specific route
+   *
+   * Selection criteria (in order of priority):
+   * 1. Backends that support both source and destination chains
+   * 2. Backends with faster average execution time
+   * 3. First registered backend (if no execution time info)
+   *
+   * @param fromChain - Source chain
+   * @param toChain - Destination chain
+   * @returns Best settlement backend for the route
+   * @throws {SettlementRegistryError} If no backend supports the route
+   *
+   * @example
+   * ```typescript
+   * const backend = registry.getBestForRoute('ethereum', 'solana')
+   * const quote = await backend.getQuote({ ... })
+   * ```
+   */
+  getBestForRoute(fromChain, toChain) {
+    const supportedBackends = [];
+    for (const backend of Array.from(this.backends.values())) {
+      const { supportedSourceChains, supportedDestinationChains } = backend.capabilities;
+      const supportsSource = supportedSourceChains.includes(fromChain);
+      const supportsDestination = supportedDestinationChains.includes(toChain);
+      if (supportsSource && supportsDestination) {
+        supportedBackends.push(backend);
+      }
+    }
+    if (supportedBackends.length === 0) {
+      throw new SettlementRegistryError(
+        `No backend supports route from '${fromChain}' to '${toChain}'`
+      );
+    }
+    if (supportedBackends.length === 1) {
+      return supportedBackends[0];
+    }
+    supportedBackends.sort((a, b) => {
+      const timeA = a.capabilities.averageExecutionTime ?? Infinity;
+      const timeB = b.capabilities.averageExecutionTime ?? Infinity;
+      return timeA - timeB;
+    });
+    return supportedBackends[0];
+  }
+  /**
+   * Get all supported routes across all registered backends
+   *
+   * @returns Array of supported routes
+   *
+   * @example
+   * ```typescript
+   * const routes = registry.getSupportedRoutes()
+   * // [
+   * //   { fromChain: 'ethereum', toChain: 'solana', backend: 'near-intents' },
+   * //   { fromChain: 'solana', toChain: 'ethereum', backend: 'near-intents' },
+   * //   { fromChain: 'ethereum', toChain: 'zcash', backend: 'zcash' },
+   * //   ...
+   * // ]
+   * ```
+   */
+  getSupportedRoutes() {
+    const routes = [];
+    for (const backend of Array.from(this.backends.values())) {
+      const { supportedSourceChains, supportedDestinationChains } = backend.capabilities;
+      for (const fromChain of supportedSourceChains) {
+        for (const toChain of supportedDestinationChains) {
+          routes.push({
+            fromChain,
+            toChain,
+            backend: backend.name
+          });
+        }
+      }
+    }
+    return routes;
+  }
+  /**
+   * Check if a backend is registered
+   *
+   * @param name - Backend name
+   * @returns True if backend is registered
+   *
+   * @example
+   * ```typescript
+   * if (registry.has('near-intents')) {
+   *   const backend = registry.get('near-intents')
+   * }
+   * ```
+   */
+  has(name) {
+    return this.backends.has(name);
+  }
+  /**
+   * Unregister a settlement backend
+   *
+   * @param name - Backend name to unregister
+   * @returns True if backend was unregistered, false if not found
+   *
+   * @example
+   * ```typescript
+   * registry.unregister('near-intents')
+   * ```
+   */
+  unregister(name) {
+    return this.backends.delete(name);
+  }
+  /**
+   * Clear all registered backends
+   *
+   * @example
+   * ```typescript
+   * registry.clear()
+   * ```
+   */
+  clear() {
+    this.backends.clear();
+  }
+  /**
+   * Get number of registered backends
+   *
+   * @returns Number of registered backends
+   *
+   * @example
+   * ```typescript
+   * const count = registry.size()
+   * ```
+   */
+  size() {
+    return this.backends.size;
+  }
+};
+
+// src/settlement/router.ts
+var SmartRouter = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Find best routes for a swap
+   *
+   * Queries all compatible backends in parallel and returns sorted routes.
+   *
+   * @param params - Route finding parameters
+   * @returns Sorted routes (best first)
+   * @throws {ValidationError} If no backends support the route
+   */
+  async findBestRoute(params) {
+    const {
+      from,
+      to,
+      amount,
+      privacyLevel,
+      preferSpeed = false,
+      preferLowFees = true,
+      recipientMetaAddress,
+      senderAddress,
+      slippageTolerance,
+      deadline
+    } = params;
+    if (amount <= 0n) {
+      throw new ValidationError("Amount must be greater than zero");
+    }
+    const allBackends = this.registry.list().map((name) => this.registry.get(name));
+    const compatibleBackends = allBackends.filter((backend) => {
+      const { supportedSourceChains, supportedDestinationChains, supportedPrivacyLevels } = backend.capabilities;
+      const supportsRoute = supportedSourceChains.includes(from.chain) && supportedDestinationChains.includes(to.chain);
+      const supportsPrivacy = supportedPrivacyLevels.includes(privacyLevel);
+      return supportsRoute && supportsPrivacy;
+    });
+    if (compatibleBackends.length === 0) {
+      throw new ValidationError(
+        `No backend supports route from ${from.chain} to ${to.chain} with privacy level ${privacyLevel}`
+      );
+    }
+    const quoteParams = {
+      fromChain: from.chain,
+      toChain: to.chain,
+      fromToken: from.token,
+      toToken: to.token,
+      amount,
+      privacyLevel,
+      recipientMetaAddress,
+      senderAddress,
+      slippageTolerance,
+      deadline
+    };
+    const quotePromises = compatibleBackends.map(async (backend) => {
+      try {
+        const quote = await backend.getQuote(quoteParams);
+        return {
+          backend: backend.name,
+          quote,
+          backendInstance: backend,
+          success: true
+        };
+      } catch (error) {
+        return {
+          backend: backend.name,
+          error: error instanceof Error ? error.message : "Unknown error",
+          success: false
+        };
+      }
+    });
+    const results = await Promise.all(quotePromises);
+    const successfulRoutes = results.filter((r) => r.success).map((r) => ({
+      backend: r.backend,
+      quote: r.quote,
+      backendInstance: r.backendInstance,
+      score: 0
+      // Will be calculated below
+    }));
+    if (successfulRoutes.length === 0) {
+      const errors = results.filter((r) => !r.success).map((r) => `${r.backend}: ${r.error}`).join(", ");
+      throw new NetworkError(
+        `All backends failed to provide quotes: ${errors}`
+      );
+    }
+    this.rankRoutes(successfulRoutes, { preferSpeed, preferLowFees });
+    successfulRoutes.sort((a, b) => b.score - a.score);
+    return successfulRoutes;
+  }
+  /**
+   * Compare quotes from multiple routes side-by-side
+   *
+   * @param routes - Routes to compare (from findBestRoute)
+   * @returns Comparison with best routes by different criteria
+   */
+  compareQuotes(routes) {
+    if (routes.length === 0) {
+      return {
+        routes: [],
+        bestByCost: null,
+        bestBySpeed: null,
+        bestByPrivacy: null,
+        metadata: {
+          totalQueried: 0,
+          failures: [],
+          queriedAt: Date.now()
+        }
+      };
+    }
+    const bestByCost = [...routes].sort((a, b) => {
+      const costA = this.calculateTotalCost(a.quote);
+      const costB = this.calculateTotalCost(b.quote);
+      return costA - costB;
+    })[0];
+    const bestBySpeed = [...routes].sort((a, b) => {
+      const timeA = a.quote.estimatedTime ?? Infinity;
+      const timeB = b.quote.estimatedTime ?? Infinity;
+      return timeA - timeB;
+    })[0];
+    const bestByPrivacy = [...routes].find((route) => {
+      const { supportedPrivacyLevels } = route.backendInstance.capabilities;
+      return supportedPrivacyLevels.includes("shielded") || supportedPrivacyLevels.includes("compliant");
+    }) || routes[0];
+    return {
+      routes,
+      bestByCost,
+      bestBySpeed,
+      bestByPrivacy,
+      metadata: {
+        totalQueried: routes.length,
+        failures: [],
+        // Could track from findBestRoute
+        queriedAt: Date.now()
+      }
+    };
+  }
+  /**
+   * Rank routes by score
+   *
+   * Scoring algorithm:
+   * - Base score: 100
+   * - Cost: Lower fees = higher score (up to +50)
+   * - Speed: Faster execution = higher score (up to +30)
+   * - Privacy: Better privacy support = higher score (up to +20)
+   *
+   * @private
+   */
+  rankRoutes(routes, preferences) {
+    const { preferSpeed, preferLowFees } = preferences;
+    const costs = routes.map((r) => this.calculateTotalCost(r.quote));
+    const times = routes.map((r) => r.quote.estimatedTime ?? Infinity);
+    const minCost = Math.min(...costs);
+    const maxCost = Math.max(...costs);
+    const minTime = Math.min(...times.filter((t) => t !== Infinity));
+    const maxTime = Math.max(...times.filter((t) => t !== Infinity));
+    routes.forEach((route, index) => {
+      let score = 100;
+      if (maxCost > minCost) {
+        const costNormalized = 1 - (costs[index] - minCost) / (maxCost - minCost);
+        const costWeight = preferLowFees ? 50 : 30;
+        score += costNormalized * costWeight;
+      }
+      const time = times[index];
+      if (time !== Infinity && maxTime > minTime) {
+        const speedNormalized = 1 - (time - minTime) / (maxTime - minTime);
+        const speedWeight = preferSpeed ? 50 : 30;
+        score += speedNormalized * speedWeight;
+      }
+      const { supportedPrivacyLevels } = route.backendInstance.capabilities;
+      if (supportedPrivacyLevels.includes("shielded")) {
+        score += 20;
+      } else if (supportedPrivacyLevels.includes("compliant")) {
+        score += 10;
+      }
+      route.score = score;
+    });
+  }
+  /**
+   * Calculate total cost from quote
+   *
+   * Returns total fee in USD if available, otherwise estimates from fees
+   *
+   * @private
+   */
+  calculateTotalCost(quote) {
+    if (quote.fees.totalFeeUSD) {
+      return parseFloat(quote.fees.totalFeeUSD);
+    }
+    const networkFee = parseFloat(quote.fees.networkFee) || 0;
+    const protocolFee = parseFloat(quote.fees.protocolFee) || 0;
+    return networkFee + protocolFee;
+  }
+};
+function createSmartRouter(registry) {
+  return new SmartRouter(registry);
+}
+
+// src/settlement/backends/near-intents.ts
+var import_types8 = require("@sip-protocol/types");
+function mapOneClickStatus(status) {
+  switch (status) {
+    case import_types8.OneClickSwapStatus.PENDING_DEPOSIT:
+      return "pending_deposit" /* PENDING_DEPOSIT */;
+    case import_types8.OneClickSwapStatus.PROCESSING:
+      return "in_progress" /* IN_PROGRESS */;
+    case import_types8.OneClickSwapStatus.SUCCESS:
+      return "success" /* SUCCESS */;
+    case import_types8.OneClickSwapStatus.FAILED:
+      return "failed" /* FAILED */;
+    case import_types8.OneClickSwapStatus.INCOMPLETE_DEPOSIT:
+      return "failed" /* FAILED */;
+    case import_types8.OneClickSwapStatus.REFUNDED:
+      return "refunded" /* REFUNDED */;
+    default:
+      return "pending_deposit" /* PENDING_DEPOSIT */;
+  }
+}
+var NEARIntentsBackend = class {
+  name = "near-intents";
+  capabilities;
+  adapter;
+  quoteCache;
+  constructor(config = {}) {
+    this.adapter = new NEARIntentsAdapter(config);
+    this.quoteCache = /* @__PURE__ */ new Map();
+    this.capabilities = {
+      supportedSourceChains: [
+        "near",
+        "ethereum",
+        "solana",
+        "polygon",
+        "arbitrum",
+        "optimism",
+        "base",
+        "bitcoin",
+        "zcash"
+      ],
+      supportedDestinationChains: [
+        "near",
+        "ethereum",
+        "solana",
+        "polygon",
+        "arbitrum",
+        "optimism",
+        "base",
+        "bitcoin",
+        "zcash"
+      ],
+      supportedPrivacyLevels: [
+        import_types8.PrivacyLevel.TRANSPARENT,
+        import_types8.PrivacyLevel.SHIELDED,
+        import_types8.PrivacyLevel.COMPLIANT
+      ],
+      supportsCancellation: false,
+      supportsRefunds: true,
+      averageExecutionTime: 300,
+      // 5 minutes
+      features: ["stealth-addresses", "cross-chain", "near-intents"]
+    };
+  }
+  /**
+   * Get quote for a cross-chain swap
+   */
+  async getQuote(params) {
+    this.validateQuoteParams(params);
+    const swapRequest = {
+      requestId: this.generateRequestId(),
+      privacyLevel: params.privacyLevel,
+      inputAsset: {
+        chain: params.fromChain,
+        symbol: params.fromToken,
+        decimals: 0
+        // Will be inferred by adapter
+      },
+      outputAsset: {
+        chain: params.toChain,
+        symbol: params.toToken,
+        decimals: 0
+        // Will be inferred by adapter
+      },
+      inputAmount: params.amount,
+      minOutputAmount: params.slippageTolerance ? params.amount - params.amount * BigInt(params.slippageTolerance) / BigInt(1e4) : void 0
+    };
+    const prepared = await this.adapter.prepareSwap(
+      swapRequest,
+      params.recipientMetaAddress,
+      params.senderAddress
+    );
+    const oneClickQuote = await this.adapter.getQuote(prepared);
+    this.quoteCache.set(oneClickQuote.quoteId, params);
+    const quote = {
+      quoteId: oneClickQuote.quoteId,
+      amountIn: oneClickQuote.amountIn,
+      amountOut: oneClickQuote.amountOut,
+      minAmountOut: oneClickQuote.amountOut,
+      // 1Click doesn't provide separate minAmount
+      fees: {
+        networkFee: "0",
+        // 1Click doesn't provide separate fee breakdown
+        protocolFee: "0",
+        totalFeeUSD: oneClickQuote.amountOutUsd
+      },
+      depositAddress: oneClickQuote.depositAddress,
+      recipientAddress: prepared.stealthAddress?.address ?? params.senderAddress ?? "",
+      refundAddress: params.senderAddress,
+      expiresAt: new Date(oneClickQuote.deadline).getTime() / 1e3,
+      estimatedTime: oneClickQuote.timeEstimate,
+      metadata: {
+        prepared,
+        oneClickQuote,
+        stealthAddress: prepared.stealthAddress,
+        ephemeralPublicKey: prepared.stealthAddress?.ephemeralPublicKey,
+        curve: prepared.curve
+      }
+    };
+    return quote;
+  }
+  /**
+   * Execute swap using a quote
+   */
+  async executeSwap(params) {
+    if (!params.quoteId) {
+      throw new ValidationError("quoteId is required", "quoteId");
+    }
+    const quoteParams = this.quoteCache.get(params.quoteId);
+    if (!quoteParams) {
+      throw new ValidationError(
+        "Quote not found. Please call getQuote() before executeSwap()",
+        "quoteId"
+      );
+    }
+    const swapRequest = {
+      requestId: this.generateRequestId(),
+      privacyLevel: quoteParams.privacyLevel,
+      inputAsset: {
+        chain: quoteParams.fromChain,
+        symbol: quoteParams.fromToken,
+        decimals: 0
+      },
+      outputAsset: {
+        chain: quoteParams.toChain,
+        symbol: quoteParams.toToken,
+        decimals: 0
+      },
+      inputAmount: quoteParams.amount
+    };
+    const adapterResult = await this.adapter.initiateSwap(
+      swapRequest,
+      quoteParams.recipientMetaAddress,
+      quoteParams.senderAddress
+    );
+    if (params.depositTxHash) {
+      await this.adapter.notifyDeposit(
+        adapterResult.depositAddress,
+        params.depositTxHash,
+        params.nearAccount
+      );
+    }
+    const result = {
+      swapId: adapterResult.depositAddress,
+      // Use deposit address as swap ID
+      status: mapOneClickStatus(adapterResult.status),
+      quoteId: params.quoteId,
+      depositAddress: adapterResult.depositAddress,
+      depositTxHash: params.depositTxHash,
+      settlementTxHash: adapterResult.settlementTxHash,
+      actualAmountOut: adapterResult.amountOut,
+      metadata: {
+        adapterResult,
+        stealthRecipient: adapterResult.stealthRecipient,
+        ephemeralPublicKey: adapterResult.ephemeralPublicKey
+      }
+    };
+    return result;
+  }
+  /**
+   * Get current swap status
+   */
+  async getStatus(swapId) {
+    const oneClickStatus = await this.adapter.getStatus(swapId);
+    const status = {
+      swapId,
+      status: mapOneClickStatus(oneClickStatus.status),
+      quoteId: "",
+      // 1Click status doesn't include quoteId
+      depositAddress: swapId,
+      amountIn: oneClickStatus.amountIn ?? "0",
+      amountOut: oneClickStatus.amountOut ?? "0",
+      depositTxHash: oneClickStatus.depositTxHash,
+      settlementTxHash: oneClickStatus.settlementTxHash,
+      errorMessage: oneClickStatus.error,
+      updatedAt: Date.now() / 1e3,
+      // 1Click doesn't provide updatedAt
+      metadata: {
+        oneClickStatus
+      }
+    };
+    return status;
+  }
+  /**
+   * Wait for swap completion (optional)
+   */
+  async waitForCompletion(swapId, options) {
+    await this.adapter.waitForCompletion(swapId, {
+      interval: options?.interval,
+      timeout: options?.timeout,
+      onStatus: options?.onStatusChange ? (oneClickStatus) => {
+        const status = {
+          swapId,
+          status: mapOneClickStatus(oneClickStatus.status),
+          quoteId: "",
+          depositAddress: swapId,
+          amountIn: oneClickStatus.amountIn ?? "0",
+          amountOut: oneClickStatus.amountOut ?? "0",
+          depositTxHash: oneClickStatus.depositTxHash,
+          settlementTxHash: oneClickStatus.settlementTxHash,
+          errorMessage: oneClickStatus.error,
+          updatedAt: Date.now() / 1e3,
+          metadata: { oneClickStatus }
+        };
+        options.onStatusChange?.(status);
+      } : void 0
+    });
+    return this.getStatus(swapId);
+  }
+  /**
+   * Get dry quote (preview without creating deposit address)
+   */
+  async getDryQuote(params) {
+    this.validateQuoteParams(params);
+    const swapRequest = {
+      requestId: this.generateRequestId(),
+      privacyLevel: params.privacyLevel,
+      inputAsset: {
+        chain: params.fromChain,
+        symbol: params.fromToken,
+        decimals: 0
+      },
+      outputAsset: {
+        chain: params.toChain,
+        symbol: params.toToken,
+        decimals: 0
+      },
+      inputAmount: params.amount
+    };
+    const prepared = await this.adapter.prepareSwap(
+      swapRequest,
+      params.recipientMetaAddress,
+      params.senderAddress
+    );
+    const oneClickQuote = await this.adapter.getDryQuote(prepared);
+    const quote = {
+      quoteId: oneClickQuote.quoteId,
+      amountIn: oneClickQuote.amountIn,
+      amountOut: oneClickQuote.amountOut,
+      minAmountOut: oneClickQuote.amountOut,
+      fees: {
+        networkFee: "0",
+        protocolFee: "0",
+        totalFeeUSD: oneClickQuote.amountOutUsd
+      },
+      depositAddress: oneClickQuote.depositAddress,
+      recipientAddress: prepared.stealthAddress?.address ?? params.senderAddress ?? "",
+      refundAddress: params.senderAddress,
+      expiresAt: new Date(oneClickQuote.deadline).getTime() / 1e3,
+      estimatedTime: oneClickQuote.timeEstimate,
+      metadata: {
+        prepared,
+        oneClickQuote,
+        stealthAddress: prepared.stealthAddress,
+        ephemeralPublicKey: prepared.stealthAddress?.ephemeralPublicKey,
+        curve: prepared.curve,
+        isDryQuote: true
+      }
+    };
+    return quote;
+  }
+  /**
+   * Notify backend of deposit transaction
+   */
+  async notifyDeposit(swapId, txHash, metadata) {
+    await this.adapter.notifyDeposit(
+      swapId,
+      // swapId is deposit address
+      txHash,
+      metadata?.nearAccount
+    );
+  }
+  // ─── Private Methods ──────────────────────────────────────────────────────────
+  validateQuoteParams(params) {
+    if (!params.fromChain) {
+      throw new ValidationError("fromChain is required", "fromChain");
+    }
+    if (!params.toChain) {
+      throw new ValidationError("toChain is required", "toChain");
+    }
+    if (!params.fromToken) {
+      throw new ValidationError("fromToken is required", "fromToken");
+    }
+    if (!params.toToken) {
+      throw new ValidationError("toToken is required", "toToken");
+    }
+    if (!params.amount || params.amount <= BigInt(0)) {
+      throw new ValidationError("amount must be greater than 0", "amount");
+    }
+    if (!params.privacyLevel) {
+      throw new ValidationError("privacyLevel is required", "privacyLevel");
+    }
+    if (params.privacyLevel !== import_types8.PrivacyLevel.TRANSPARENT && !params.recipientMetaAddress) {
+      throw new ValidationError(
+        "recipientMetaAddress is required for shielded/compliant privacy modes",
+        "recipientMetaAddress"
+      );
+    }
+    if (params.privacyLevel === import_types8.PrivacyLevel.TRANSPARENT && !params.senderAddress) {
+      throw new ValidationError(
+        "senderAddress is required for transparent mode",
+        "senderAddress"
+      );
+    }
+    if (!this.capabilities.supportedSourceChains.includes(params.fromChain)) {
+      throw new ValidationError(
+        `Source chain ${params.fromChain} is not supported`,
+        "fromChain",
+        { supportedChains: this.capabilities.supportedSourceChains }
+      );
+    }
+    if (!this.capabilities.supportedDestinationChains.includes(params.toChain)) {
+      throw new ValidationError(
+        `Destination chain ${params.toChain} is not supported`,
+        "toChain",
+        { supportedChains: this.capabilities.supportedDestinationChains }
+      );
+    }
+  }
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  }
+};
+function createNEARIntentsBackend(config) {
+  return new NEARIntentsBackend(config);
+}
+
+// src/settlement/backends/zcash-native.ts
+var import_types9 = require("@sip-protocol/types");
+var ZcashNativeBackend = class {
+  name = "zcash-native";
+  capabilities;
+  swapService;
+  config;
+  quotes = /* @__PURE__ */ new Map();
+  swaps = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.swapService = config.swapService;
+    this.config = {
+      quoteValiditySeconds: config.quoteValiditySeconds ?? 300,
+      networkFeeZatoshis: config.networkFeeZatoshis ?? 1e4
+    };
+    this.capabilities = {
+      supportedSourceChains: ["zcash"],
+      supportedDestinationChains: ["zcash"],
+      supportedPrivacyLevels: [
+        import_types9.PrivacyLevel.TRANSPARENT,
+        import_types9.PrivacyLevel.SHIELDED,
+        import_types9.PrivacyLevel.COMPLIANT
+      ],
+      supportsCancellation: false,
+      supportsRefunds: false,
+      averageExecutionTime: 75,
+      // ~75 seconds for Zcash block confirmation
+      features: [
+        "native-zcash",
+        "shielded-addresses",
+        "transparent-addresses",
+        "instant-quotes"
+      ]
+    };
+  }
+  // ─── Quote Methods ─────────────────────────────────────────────────────────
+  /**
+   * Get a quote for ZEC → ZEC transfer
+   */
+  async getQuote(params) {
+    this.validateQuoteParams(params);
+    const { amount, recipientMetaAddress, senderAddress, privacyLevel } = params;
+    const quoteId = this.generateQuoteId();
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + this.config.quoteValiditySeconds;
+    const networkFee = BigInt(this.config.networkFeeZatoshis);
+    const protocolFee = BigInt(0);
+    const totalFee = networkFee;
+    const amountOut = amount - totalFee;
+    if (amountOut <= BigInt(0)) {
+      throw new ValidationError(
+        "Amount too small to cover network fees",
+        "amount",
+        { amount: amount.toString(), networkFee: networkFee.toString() },
+        "SIP_2004" /* INVALID_AMOUNT */
+      );
+    }
+    const minAmountOut = amountOut * BigInt(99) / BigInt(100);
+    let depositAddress;
+    let recipientAddress;
+    if (privacyLevel === import_types9.PrivacyLevel.SHIELDED || privacyLevel === import_types9.PrivacyLevel.COMPLIANT) {
+      if (typeof recipientMetaAddress === "string") {
+        recipientAddress = recipientMetaAddress;
+      } else if (recipientMetaAddress) {
+        recipientAddress = `zs1${this.randomHex(72)}`;
+      } else {
+        throw new ValidationError(
+          "Recipient address required for shielded transfers",
+          "recipientMetaAddress",
+          void 0,
+          "SIP_2000" /* VALIDATION_FAILED */
+        );
+      }
+      depositAddress = `zs1${this.randomHex(72)}`;
+    } else {
+      if (senderAddress) {
+        depositAddress = senderAddress;
+      } else {
+        depositAddress = `t1${this.randomBase58(33)}`;
+      }
+      if (typeof recipientMetaAddress === "string") {
+        recipientAddress = recipientMetaAddress;
+      } else {
+        throw new ValidationError(
+          "Recipient address required",
+          "recipientMetaAddress",
+          void 0,
+          "SIP_2000" /* VALIDATION_FAILED */
+        );
+      }
+    }
+    const quote = {
+      quoteId,
+      amountIn: amount.toString(),
+      amountOut: amountOut.toString(),
+      minAmountOut: minAmountOut.toString(),
+      fees: {
+        networkFee: networkFee.toString(),
+        protocolFee: protocolFee.toString()
+      },
+      depositAddress,
+      recipientAddress,
+      expiresAt,
+      estimatedTime: this.capabilities.averageExecutionTime,
+      metadata: {
+        backend: this.name,
+        privacyLevel,
+        zcashNetwork: "mainnet"
+      }
+    };
+    this.quotes.set(quoteId, quote);
+    return quote;
+  }
+  /**
+   * Get a dry quote (preview without creating deposit address)
+   */
+  async getDryQuote(params) {
+    return this.getQuote(params);
+  }
+  // ─── Swap Execution ────────────────────────────────────────────────────────
+  /**
+   * Execute a ZEC → ZEC swap/transfer
+   */
+  async executeSwap(params) {
+    const { quoteId, depositTxHash } = params;
+    const quote = this.quotes.get(quoteId);
+    if (!quote) {
+      throw new ValidationError(
+        "Quote not found or expired",
+        "quoteId",
+        { quoteId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (now > quote.expiresAt) {
+      throw new ValidationError(
+        "Quote has expired",
+        "quoteId",
+        { quoteId, expiresAt: quote.expiresAt, now },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const swapId = this.generateSwapId();
+    const result = {
+      swapId,
+      status: depositTxHash ? "deposit_confirmed" /* DEPOSIT_CONFIRMED */ : "pending_deposit" /* PENDING_DEPOSIT */,
+      quoteId,
+      depositAddress: quote.depositAddress,
+      depositTxHash,
+      metadata: {
+        backend: this.name,
+        recipientAddress: quote.recipientAddress
+      }
+    };
+    this.swaps.set(swapId, result);
+    if (depositTxHash) {
+      this.simulateSwapExecution(swapId, quote);
+    }
+    return result;
+  }
+  // ─── Status Methods ────────────────────────────────────────────────────────
+  /**
+   * Get swap status
+   */
+  async getStatus(swapId) {
+    const swap = this.swaps.get(swapId);
+    if (!swap) {
+      throw new ValidationError(
+        "Swap not found",
+        "swapId",
+        { swapId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const quote = this.quotes.get(swap.quoteId);
+    if (!quote) {
+      throw new ValidationError(
+        "Quote not found for swap",
+        "quoteId",
+        { quoteId: swap.quoteId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const status = {
+      swapId: swap.swapId,
+      status: swap.status,
+      quoteId: swap.quoteId,
+      depositAddress: swap.depositAddress,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      depositTxHash: swap.depositTxHash,
+      settlementTxHash: swap.settlementTxHash,
+      actualAmountOut: swap.actualAmountOut,
+      errorMessage: swap.errorMessage,
+      updatedAt: Math.floor(Date.now() / 1e3),
+      metadata: swap.metadata
+    };
+    return status;
+  }
+  /**
+   * Wait for swap completion
+   */
+  async waitForCompletion(swapId, options) {
+    const interval = options?.interval ?? 5e3;
+    const timeout = options?.timeout ?? 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const status2 = await this.getStatus(swapId);
+      if (options?.onStatusChange) {
+        options.onStatusChange(status2);
+      }
+      if (status2.status === "success" /* SUCCESS */) {
+        return status2;
+      }
+      if (status2.status === "failed" /* FAILED */ || status2.status === "cancelled" /* CANCELLED */ || status2.status === "refunded" /* REFUNDED */) {
+        return status2;
+      }
+      await this.delay(interval);
+    }
+    const status = await this.getStatus(swapId);
+    return status;
+  }
+  /**
+   * Notify backend of deposit
+   */
+  async notifyDeposit(swapId, txHash, metadata) {
+    const swap = this.swaps.get(swapId);
+    if (!swap) {
+      throw new ValidationError(
+        "Swap not found",
+        "swapId",
+        { swapId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    swap.depositTxHash = txHash;
+    swap.status = "deposit_confirmed" /* DEPOSIT_CONFIRMED */;
+    if (metadata) {
+      swap.metadata = { ...swap.metadata, ...metadata };
+    }
+    this.swaps.set(swapId, swap);
+    const quote = this.quotes.get(swap.quoteId);
+    if (quote) {
+      this.simulateSwapExecution(swapId, quote);
+    }
+  }
+  // ─── Private Helpers ───────────────────────────────────────────────────────
+  validateQuoteParams(params) {
+    if (params.fromChain !== "zcash") {
+      throw new ValidationError(
+        "Source chain must be zcash",
+        "fromChain",
+        { received: params.fromChain, expected: "zcash" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (params.toChain !== "zcash") {
+      throw new ValidationError(
+        "Destination chain must be zcash",
+        "toChain",
+        { received: params.toChain, expected: "zcash" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (params.fromToken !== "ZEC") {
+      throw new ValidationError(
+        "Source token must be ZEC",
+        "fromToken",
+        { received: params.fromToken, expected: "ZEC" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (params.toToken !== "ZEC") {
+      throw new ValidationError(
+        "Destination token must be ZEC",
+        "toToken",
+        { received: params.toToken, expected: "ZEC" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (!params.amount || params.amount <= BigInt(0)) {
+      throw new ValidationError(
+        "Amount must be positive",
+        "amount",
+        { received: params.amount },
+        "SIP_2004" /* INVALID_AMOUNT */
+      );
+    }
+    if (!this.capabilities.supportedPrivacyLevels.includes(params.privacyLevel)) {
+      throw new ValidationError(
+        "Unsupported privacy level",
+        "privacyLevel",
+        { received: params.privacyLevel, supported: this.capabilities.supportedPrivacyLevels },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+  }
+  simulateSwapExecution(swapId, quote) {
+    setTimeout(() => {
+      const swap = this.swaps.get(swapId);
+      if (!swap) return;
+      swap.status = "in_progress" /* IN_PROGRESS */;
+      this.swaps.set(swapId, swap);
+      setTimeout(() => {
+        const finalSwap = this.swaps.get(swapId);
+        if (!finalSwap) return;
+        finalSwap.status = "success" /* SUCCESS */;
+        finalSwap.settlementTxHash = this.randomHex(64);
+        finalSwap.actualAmountOut = quote.amountOut;
+        this.swaps.set(swapId, finalSwap);
+      }, 2e3);
+    }, 1e3);
+  }
+  generateQuoteId() {
+    return `zec_native_quote_${Date.now()}_${this.randomHex(8)}`;
+  }
+  generateSwapId() {
+    return `zec_native_swap_${Date.now()}_${this.randomHex(8)}`;
+  }
+  randomHex(length) {
+    const chars = "0123456789abcdef";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+  }
+  randomBase58(length) {
+    const chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
-function createMockSolver(config) {
-  return new MockSolver(config);
+function createZcashNativeBackend(config) {
+  return new ZcashNativeBackend(config);
 }
 
-// src/index.ts
-var import_types38 = require("@sip-protocol/types");
+// src/settlement/backends/direct-chain.ts
+var import_types10 = require("@sip-protocol/types");
+var import_utils11 = require("@noble/hashes/utils");
+var DEFAULT_GAS_FEES = {
+  ethereum: 21000n * 50n * 1000000000n,
+  // 21k gas * 50 gwei = 0.00105 ETH
+  solana: 5000n,
+  // 5000 lamports = 0.000005 SOL
+  near: 300000000000000000000n,
+  // 0.3 NEAR in yoctoNEAR
+  zcash: 10000n,
+  // 0.0001 ZEC in zatoshi
+  polygon: 21000n * 30n * 1000000000n,
+  // 21k gas * 30 gwei POL
+  arbitrum: 2100000000n,
+  // 21k gas * 0.1 gwei ETH = 2100 gwei = 2.1e9 wei
+  optimism: 21000000n,
+  // 21k gas * 0.001 gwei ETH = 21 gwei = 21e6 wei
+  base: 2100000000n,
+  // 21k gas * 0.1 gwei ETH = 2100 gwei = 2.1e9 wei
+  bitcoin: 10000n
+  // 10000 sats = 0.0001 BTC (estimate for 1 input, 2 outputs)
+};
 
 // src/zcash/rpc-client.ts
-var import_types8 = require("@sip-protocol/types");
+var import_types11 = require("@sip-protocol/types");
 var DEFAULT_CONFIG = {
   host: "127.0.0.1",
   port: 8232,
@@ -3986,19 +5398,19 @@ var ZcashRPCError = class extends Error {
    * Check if error is due to insufficient funds
    */
   isInsufficientFunds() {
-    return this.code === import_types8.ZcashErrorCode.WALLET_INSUFFICIENT_FUNDS;
+    return this.code === import_types11.ZcashErrorCode.WALLET_INSUFFICIENT_FUNDS;
   }
   /**
    * Check if error is due to invalid address
    */
   isInvalidAddress() {
-    return this.code === import_types8.ZcashErrorCode.INVALID_ADDRESS_OR_KEY;
+    return this.code === import_types11.ZcashErrorCode.INVALID_ADDRESS_OR_KEY;
   }
   /**
    * Check if error is due to wallet being locked
    */
   isWalletLocked() {
-    return this.code === import_types8.ZcashErrorCode.WALLET_UNLOCK_NEEDED;
+    return this.code === import_types11.ZcashErrorCode.WALLET_UNLOCK_NEEDED;
   }
 };
 var ZcashRPCClient = class {
@@ -4385,7 +5797,7 @@ function createZcashClient(config) {
 }
 
 // src/zcash/shielded-service.ts
-var import_types9 = require("@sip-protocol/types");
+var import_types12 = require("@sip-protocol/types");
 var ZcashShieldedService = class _ZcashShieldedService {
   client;
   config;
@@ -4571,7 +5983,7 @@ var ZcashShieldedService = class _ZcashShieldedService {
    * Higher-level method that handles privacy level mapping.
    */
   async sendWithPrivacy(to, amount, privacyLevel, memo) {
-    if (privacyLevel === import_types9.PrivacyLevel.TRANSPARENT) {
+    if (privacyLevel === import_types12.PrivacyLevel.TRANSPARENT) {
       throw new ValidationError(
         "Transparent mode not supported for Zcash shielded service. Use standard RPC client.",
         "privacyLevel",
@@ -4665,7 +6077,7 @@ var ZcashShieldedService = class _ZcashShieldedService {
     const viewingKey = await this.exportViewingKey();
     return {
       viewingKey,
-      privacyLevel: import_types9.PrivacyLevel.COMPLIANT,
+      privacyLevel: import_types12.PrivacyLevel.COMPLIANT,
       disclaimer: "This viewing key provides read-only access to transaction history. It cannot be used to spend funds. Share only with authorized auditors."
     };
   }
@@ -4751,11 +6163,11 @@ var ZcashShieldedService = class _ZcashShieldedService {
    */
   mapPrivacyLevelToPolicy(level) {
     switch (level) {
-      case import_types9.PrivacyLevel.TRANSPARENT:
+      case import_types12.PrivacyLevel.TRANSPARENT:
         return "NoPrivacy";
-      case import_types9.PrivacyLevel.SHIELDED:
+      case import_types12.PrivacyLevel.SHIELDED:
         return "FullPrivacy";
-      case import_types9.PrivacyLevel.COMPLIANT:
+      case import_types12.PrivacyLevel.COMPLIANT:
         return "FullPrivacy";
       default:
         return "FullPrivacy";
@@ -4808,7 +6220,7 @@ function createZcashShieldedService(config) {
 }
 
 // src/zcash/swap-service.ts
-var import_types10 = require("@sip-protocol/types");
+var import_types13 = require("@sip-protocol/types");
 var MOCK_PRICES = {
   ETH: 2500,
   SOL: 120,
@@ -4915,7 +6327,7 @@ var ZcashSwapService = class {
       validUntil,
       depositAddress: this.generateMockDepositAddress(sourceChain),
       estimatedTime: this.getEstimatedTime(sourceChain),
-      privacyLevel: import_types10.PrivacyLevel.SHIELDED
+      privacyLevel: import_types13.PrivacyLevel.SHIELDED
     };
     this.quotes.set(quoteId, quote);
     return quote;
@@ -4958,7 +6370,7 @@ var ZcashSwapService = class {
       depositAddress: "",
       // Will be set by bridge
       estimatedTime: this.getEstimatedTime(params.sourceChain),
-      privacyLevel: import_types10.PrivacyLevel.SHIELDED
+      privacyLevel: import_types13.PrivacyLevel.SHIELDED
     };
     this.quotes.set(quote.quoteId, quote);
     return quote;
@@ -5238,15 +6650,15 @@ function createZcashSwapService(config) {
 }
 
 // src/zcash/index.ts
-var import_types11 = require("@sip-protocol/types");
+var import_types14 = require("@sip-protocol/types");
 
 // src/index.ts
-var import_types39 = require("@sip-protocol/types");
+var import_types42 = require("@sip-protocol/types");
 
 // src/payment/payment.ts
-var import_types12 = require("@sip-protocol/types");
+var import_types15 = require("@sip-protocol/types");
 var import_sha2569 = require("@noble/hashes/sha256");
-var import_utils11 = require("@noble/hashes/utils");
+var import_utils12 = require("@noble/hashes/utils");
 var import_chacha2 = require("@noble/ciphers/chacha.js");
 var import_hkdf2 = require("@noble/hashes/hkdf");
 
@@ -5431,7 +6843,7 @@ var PaymentBuilder = class {
   _amount;
   _recipientMetaAddress;
   _recipientAddress;
-  _privacy = import_types12.PrivacyLevel.SHIELDED;
+  _privacy = import_types15.PrivacyLevel.SHIELDED;
   _viewingKey;
   _sourceChain;
   _destinationChain;
@@ -5714,7 +7126,7 @@ async function createShieldedPayment(params, options) {
   } else {
     resolvedToken = token;
   }
-  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && !recipientMetaAddress) {
+  if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && !recipientMetaAddress) {
     throw new ValidationError(
       "recipientMetaAddress is required for shielded/compliant privacy modes",
       "recipientMetaAddress",
@@ -5722,7 +7134,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === import_types12.PrivacyLevel.TRANSPARENT && !recipientAddress) {
+  if (privacy === import_types15.PrivacyLevel.TRANSPARENT && !recipientAddress) {
     throw new ValidationError(
       "recipientAddress is required for transparent mode",
       "recipientAddress",
@@ -5730,7 +7142,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === import_types12.PrivacyLevel.COMPLIANT && !viewingKey) {
+  if (privacy === import_types15.PrivacyLevel.COMPLIANT && !viewingKey) {
     throw new ValidationError(
       "viewingKey is required for compliant mode",
       "viewingKey",
@@ -5742,8 +7154,8 @@ async function createShieldedPayment(params, options) {
   let viewingKeyHash;
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-    const keyBytes = (0, import_utils11.hexToBytes)(keyHex);
-    viewingKeyHash = `0x${(0, import_utils11.bytesToHex)((0, import_sha2569.sha256)(keyBytes))}`;
+    const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
+    viewingKeyHash = `0x${(0, import_utils12.bytesToHex)((0, import_sha2569.sha256)(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -5752,7 +7164,7 @@ async function createShieldedPayment(params, options) {
   const now = Math.floor(Date.now() / 1e3);
   const payment = {
     paymentId,
-    version: import_types12.SIP_VERSION,
+    version: import_types15.SIP_VERSION,
     privacyLevel: privacy,
     createdAt: now,
     expiry: now + ttl,
@@ -5763,7 +7175,7 @@ async function createShieldedPayment(params, options) {
     purpose,
     viewingKeyHash
   };
-  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && recipientMetaAddress) {
+  if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && recipientMetaAddress) {
     const metaAddress = decodeStealthMetaAddress(recipientMetaAddress);
     const { stealthAddress } = generateStealthAddress(metaAddress);
     payment.recipientStealth = stealthAddress;
@@ -5780,10 +7192,10 @@ async function createShieldedPayment(params, options) {
     payment.recipientAddress = recipientAddress;
     payment.memo = memo;
   }
-  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
+  if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-      return (0, import_utils11.hexToBytes)(cleanHex);
+      return (0, import_utils12.hexToBytes)(cleanHex);
     };
     const fundingResult = await proofProvider.generateFundingProof({
       balance: amount,
@@ -5810,17 +7222,17 @@ async function createShieldedPayment(params, options) {
 }
 function encryptMemo(memo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils11.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
   const encKey = (0, import_hkdf2.hkdf)(import_sha2569.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
-    const nonce = (0, import_utils11.randomBytes)(24);
+    const nonce = (0, import_utils12.randomBytes)(24);
     const cipher = (0, import_chacha2.xchacha20poly1305)(encKey, nonce);
     const plaintext = new TextEncoder().encode(memo);
     const ciphertext = cipher.encrypt(plaintext);
     const result = new Uint8Array(nonce.length + ciphertext.length);
     result.set(nonce);
     result.set(ciphertext, nonce.length);
-    return `0x${(0, import_utils11.bytesToHex)(result)}`;
+    return `0x${(0, import_utils12.bytesToHex)(result)}`;
   } finally {
     secureWipe(keyBytes);
     secureWipe(encKey);
@@ -5828,11 +7240,11 @@ function encryptMemo(memo, viewingKey) {
 }
 function decryptMemo(encryptedMemo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils11.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
   const encKey = (0, import_hkdf2.hkdf)(import_sha2569.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
     const dataHex = encryptedMemo.startsWith("0x") ? encryptedMemo.slice(2) : encryptedMemo;
-    const data = (0, import_utils11.hexToBytes)(dataHex);
+    const data = (0, import_utils12.hexToBytes)(dataHex);
     const nonce = data.slice(0, 24);
     const ciphertext = data.slice(24);
     const cipher = (0, import_chacha2.xchacha20poly1305)(encKey, nonce);
@@ -5846,7 +7258,7 @@ function decryptMemo(encryptedMemo, viewingKey) {
 function trackPayment(payment) {
   return {
     ...payment,
-    status: import_types12.PaymentStatus.DRAFT
+    status: import_types15.PaymentStatus.DRAFT
   };
 }
 function isPaymentExpired(payment) {
@@ -5879,10 +7291,10 @@ function getPaymentSummary(payment) {
 }
 
 // src/treasury/treasury.ts
-var import_types13 = require("@sip-protocol/types");
+var import_types16 = require("@sip-protocol/types");
 var import_secp256k13 = require("@noble/curves/secp256k1");
 var import_sha25610 = require("@noble/hashes/sha256");
-var import_utils12 = require("@noble/hashes/utils");
+var import_utils13 = require("@noble/hashes/utils");
 var DEFAULT_PROPOSAL_TTL = 7 * 24 * 60 * 60;
 var Treasury = class _Treasury {
   config;
@@ -5912,7 +7324,7 @@ var Treasury = class _Treasury {
         ...m,
         addedAt: now
       })),
-      defaultPrivacy: params.defaultPrivacy ?? import_types13.PrivacyLevel.SHIELDED,
+      defaultPrivacy: params.defaultPrivacy ?? import_types16.PrivacyLevel.SHIELDED,
       masterViewingKey,
       dailyLimit: params.dailyLimit,
       transactionLimit: params.transactionLimit,
@@ -5991,7 +7403,7 @@ var Treasury = class _Treasury {
       proposalId,
       treasuryId: this.config.treasuryId,
       type: "payment",
-      status: import_types13.ProposalStatus.PENDING,
+      status: import_types16.ProposalStatus.PENDING,
       proposer: "",
       // Should be set by caller
       title: params.title,
@@ -6024,7 +7436,7 @@ var Treasury = class _Treasury {
       proposalId,
       treasuryId: this.config.treasuryId,
       type: "batch_payment",
-      status: import_types13.ProposalStatus.PENDING,
+      status: import_types16.ProposalStatus.PENDING,
       proposer: "",
       title: params.title,
       description: params.description,
@@ -6058,7 +7470,7 @@ var Treasury = class _Treasury {
    * Get pending proposals
    */
   getPendingProposals() {
-    return this.getAllProposals().filter((p) => p.status === import_types13.ProposalStatus.PENDING);
+    return this.getAllProposals().filter((p) => p.status === import_types16.ProposalStatus.PENDING);
   }
   /**
    * Sign a proposal
@@ -6089,7 +7501,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types13.ProposalStatus.PENDING) {
+    if (proposal.status !== import_types16.ProposalStatus.PENDING) {
       throw new ValidationError(
         `proposal is not pending: ${proposal.status}`,
         "proposalId",
@@ -6099,7 +7511,7 @@ var Treasury = class _Treasury {
     }
     const now = Math.floor(Date.now() / 1e3);
     if (now > proposal.expiresAt) {
-      proposal.status = import_types13.ProposalStatus.EXPIRED;
+      proposal.status = import_types16.ProposalStatus.EXPIRED;
       throw new ValidationError(
         "proposal has expired",
         "proposalId",
@@ -6131,9 +7543,9 @@ var Treasury = class _Treasury {
     const approvals = proposal.signatures.filter((s) => s.approved).length;
     const rejections = proposal.signatures.filter((s) => !s.approved).length;
     if (approvals >= proposal.requiredSignatures) {
-      proposal.status = import_types13.ProposalStatus.APPROVED;
+      proposal.status = import_types16.ProposalStatus.APPROVED;
     } else if (rejections > this.config.totalSigners - proposal.requiredSignatures) {
-      proposal.status = import_types13.ProposalStatus.REJECTED;
+      proposal.status = import_types16.ProposalStatus.REJECTED;
     }
     return proposal;
   }
@@ -6150,7 +7562,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types13.ProposalStatus.APPROVED) {
+    if (proposal.status !== import_types16.ProposalStatus.APPROVED) {
       throw new ValidationError(
         `proposal is not approved: ${proposal.status}`,
         "proposalId",
@@ -6163,8 +7575,8 @@ var Treasury = class _Treasury {
       const payment = await createShieldedPayment({
         token: proposal.payment.token,
         amount: proposal.payment.amount,
-        recipientMetaAddress: proposal.payment.privacy !== import_types13.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
-        recipientAddress: proposal.payment.privacy === import_types13.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
+        recipientMetaAddress: proposal.payment.privacy !== import_types16.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
+        recipientAddress: proposal.payment.privacy === import_types16.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
         privacy: proposal.payment.privacy,
         viewingKey: this.config.masterViewingKey?.key,
         sourceChain: this.config.chain,
@@ -6177,8 +7589,8 @@ var Treasury = class _Treasury {
         const payment = await createShieldedPayment({
           token: proposal.batchPayment.token,
           amount: recipient.amount,
-          recipientMetaAddress: proposal.batchPayment.privacy !== import_types13.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
-          recipientAddress: proposal.batchPayment.privacy === import_types13.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
+          recipientMetaAddress: proposal.batchPayment.privacy !== import_types16.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
+          recipientAddress: proposal.batchPayment.privacy === import_types16.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
           privacy: proposal.batchPayment.privacy,
           viewingKey: this.config.masterViewingKey?.key,
           sourceChain: this.config.chain,
@@ -6188,7 +7600,7 @@ var Treasury = class _Treasury {
         payments.push(payment);
       }
     }
-    proposal.status = import_types13.ProposalStatus.EXECUTED;
+    proposal.status = import_types16.ProposalStatus.EXECUTED;
     proposal.executedAt = Math.floor(Date.now() / 1e3);
     proposal.resultPayments = payments;
     return payments;
@@ -6217,7 +7629,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types13.ProposalStatus.PENDING) {
+    if (proposal.status !== import_types16.ProposalStatus.PENDING) {
       throw new ValidationError(
         `proposal is not pending: ${proposal.status}`,
         "proposalId",
@@ -6225,7 +7637,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    proposal.status = import_types13.ProposalStatus.CANCELLED;
+    proposal.status = import_types16.ProposalStatus.CANCELLED;
     return proposal;
   }
   // ─── Auditor Access ──────────────────────────────────────────────────────────
@@ -6322,7 +7734,7 @@ var Treasury = class _Treasury {
   getCommittedAmount(token) {
     let committed = 0n;
     for (const proposal of this.proposals.values()) {
-      if (proposal.status !== import_types13.ProposalStatus.PENDING) continue;
+      if (proposal.status !== import_types16.ProposalStatus.PENDING) continue;
       if (proposal.type === "payment" && proposal.payment) {
         if (proposal.payment.token.symbol === token.symbol && proposal.payment.token.chain === token.chain) {
           committed += proposal.payment.amount;
@@ -6373,12 +7785,12 @@ var Treasury = class _Treasury {
   }
 };
 function generateTreasuryId() {
-  const bytes = (0, import_utils12.randomBytes)(16);
-  return `treasury_${(0, import_utils12.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils13.randomBytes)(16);
+  return `treasury_${(0, import_utils13.bytesToHex)(bytes)}`;
 }
 function generateProposalId() {
-  const bytes = (0, import_utils12.randomBytes)(16);
-  return `prop_${(0, import_utils12.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils13.randomBytes)(16);
+  return `prop_${(0, import_utils13.bytesToHex)(bytes)}`;
 }
 function computeProposalHash(proposal) {
   const data = JSON.stringify({
@@ -6394,7 +7806,7 @@ function computeProposalHash(proposal) {
 }
 function signMessage(messageHash, privateKey) {
   const keyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils13.hexToBytes)(keyHex);
   try {
     const signature = import_secp256k13.secp256k1.sign(messageHash, keyBytes);
     return `0x${signature.toCompactHex()}`;
@@ -6406,8 +7818,8 @@ function verifySignature(messageHash, signature, publicKey) {
   const sigHex = signature.startsWith("0x") ? signature.slice(2) : signature;
   const pubKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
   try {
-    const sigBytes = (0, import_utils12.hexToBytes)(sigHex);
-    const pubKeyBytes = (0, import_utils12.hexToBytes)(pubKeyHex);
+    const sigBytes = (0, import_utils13.hexToBytes)(sigHex);
+    const pubKeyBytes = (0, import_utils13.hexToBytes)(pubKeyHex);
     return import_secp256k13.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
   } catch {
     return false;
@@ -6565,8 +7977,8 @@ function validateBatchProposalParams(params, config) {
 }
 
 // src/compliance/compliance-manager.ts
-var import_types14 = require("@sip-protocol/types");
-var import_utils13 = require("@noble/hashes/utils");
+var import_types17 = require("@sip-protocol/types");
+var import_utils14 = require("@noble/hashes/utils");
 var DEFAULTS2 = {
   riskThreshold: 70,
   highValueThreshold: 10000000000n,
@@ -6933,7 +8345,7 @@ var ComplianceManager = class _ComplianceManager {
       title: params.title,
       description: params.description,
       format: params.format,
-      status: import_types14.ReportStatus.GENERATING,
+      status: import_types17.ReportStatus.GENERATING,
       requestedBy,
       requestedAt: now,
       startDate: params.startDate,
@@ -6962,10 +8374,10 @@ var ComplianceManager = class _ComplianceManager {
       } else if (params.format === "csv") {
         report.content = this.generateCSV(transactions);
       }
-      report.status = import_types14.ReportStatus.COMPLETED;
+      report.status = import_types17.ReportStatus.COMPLETED;
       report.generatedAt = Math.floor(Date.now() / 1e3);
     } catch (error) {
-      report.status = import_types14.ReportStatus.FAILED;
+      report.status = import_types17.ReportStatus.FAILED;
       report.error = error instanceof Error ? error.message : "Unknown error";
     }
     this.addAuditLog(requestedBy, "report_generated", {
@@ -7240,7 +8652,7 @@ var ComplianceManager = class _ComplianceManager {
   }
 };
 function generateId(prefix) {
-  return `${prefix}_${(0, import_utils13.bytesToHex)((0, import_utils13.randomBytes)(12))}`;
+  return `${prefix}_${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(12))}`;
 }
 function validateRegisterAuditorParams(params) {
   if (!params.organization?.trim()) {
@@ -7328,10 +8740,10 @@ function validateReportParams(params) {
 }
 
 // src/wallet/errors.ts
-var import_types15 = require("@sip-protocol/types");
+var import_types18 = require("@sip-protocol/types");
 var WalletError = class extends SIPError {
   walletCode;
-  constructor(message, walletCode = import_types15.WalletErrorCode.UNKNOWN, options) {
+  constructor(message, walletCode = import_types18.WalletErrorCode.UNKNOWN, options) {
     super(message, "SIP_7000" /* WALLET_ERROR */, options);
     this.walletCode = walletCode;
     this.name = "WalletError";
@@ -7341,10 +8753,10 @@ var WalletError = class extends SIPError {
    */
   isConnectionError() {
     const codes = [
-      import_types15.WalletErrorCode.NOT_INSTALLED,
-      import_types15.WalletErrorCode.CONNECTION_REJECTED,
-      import_types15.WalletErrorCode.CONNECTION_FAILED,
-      import_types15.WalletErrorCode.NOT_CONNECTED
+      import_types18.WalletErrorCode.NOT_INSTALLED,
+      import_types18.WalletErrorCode.CONNECTION_REJECTED,
+      import_types18.WalletErrorCode.CONNECTION_FAILED,
+      import_types18.WalletErrorCode.NOT_CONNECTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -7353,9 +8765,9 @@ var WalletError = class extends SIPError {
    */
   isSigningError() {
     const codes = [
-      import_types15.WalletErrorCode.SIGNING_REJECTED,
-      import_types15.WalletErrorCode.SIGNING_FAILED,
-      import_types15.WalletErrorCode.INVALID_MESSAGE
+      import_types18.WalletErrorCode.SIGNING_REJECTED,
+      import_types18.WalletErrorCode.SIGNING_FAILED,
+      import_types18.WalletErrorCode.INVALID_MESSAGE
     ];
     return codes.includes(this.walletCode);
   }
@@ -7364,10 +8776,10 @@ var WalletError = class extends SIPError {
    */
   isTransactionError() {
     const codes = [
-      import_types15.WalletErrorCode.INSUFFICIENT_FUNDS,
-      import_types15.WalletErrorCode.TRANSACTION_REJECTED,
-      import_types15.WalletErrorCode.TRANSACTION_FAILED,
-      import_types15.WalletErrorCode.INVALID_TRANSACTION
+      import_types18.WalletErrorCode.INSUFFICIENT_FUNDS,
+      import_types18.WalletErrorCode.TRANSACTION_REJECTED,
+      import_types18.WalletErrorCode.TRANSACTION_FAILED,
+      import_types18.WalletErrorCode.INVALID_TRANSACTION
     ];
     return codes.includes(this.walletCode);
   }
@@ -7376,9 +8788,9 @@ var WalletError = class extends SIPError {
    */
   isPrivacyError() {
     const codes = [
-      import_types15.WalletErrorCode.STEALTH_NOT_SUPPORTED,
-      import_types15.WalletErrorCode.VIEWING_KEY_NOT_SUPPORTED,
-      import_types15.WalletErrorCode.SHIELDED_NOT_SUPPORTED
+      import_types18.WalletErrorCode.STEALTH_NOT_SUPPORTED,
+      import_types18.WalletErrorCode.VIEWING_KEY_NOT_SUPPORTED,
+      import_types18.WalletErrorCode.SHIELDED_NOT_SUPPORTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -7387,10 +8799,10 @@ var WalletError = class extends SIPError {
    */
   isUserRejection() {
     const codes = [
-      import_types15.WalletErrorCode.CONNECTION_REJECTED,
-      import_types15.WalletErrorCode.SIGNING_REJECTED,
-      import_types15.WalletErrorCode.TRANSACTION_REJECTED,
-      import_types15.WalletErrorCode.CHAIN_SWITCH_REJECTED
+      import_types18.WalletErrorCode.CONNECTION_REJECTED,
+      import_types18.WalletErrorCode.SIGNING_REJECTED,
+      import_types18.WalletErrorCode.TRANSACTION_REJECTED,
+      import_types18.WalletErrorCode.CHAIN_SWITCH_REJECTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -7398,15 +8810,15 @@ var WalletError = class extends SIPError {
 function notConnectedError() {
   return new WalletError(
     "Wallet not connected. Call connect() first.",
-    import_types15.WalletErrorCode.NOT_CONNECTED
+    import_types18.WalletErrorCode.NOT_CONNECTED
   );
 }
-function featureNotSupportedError(feature, code = import_types15.WalletErrorCode.UNKNOWN) {
+function featureNotSupportedError(feature, code = import_types18.WalletErrorCode.UNKNOWN) {
   return new WalletError(`${feature} is not supported by this wallet`, code);
 }
 
 // src/wallet/base-adapter.ts
-var import_types16 = require("@sip-protocol/types");
+var import_types19 = require("@sip-protocol/types");
 var BaseWalletAdapter = class {
   _address = "";
   _publicKey = "";
@@ -7569,12 +8981,12 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
     this._connectionState = "connecting";
     if (this.shouldFailConnect) {
       this.setError(
-        import_types16.WalletErrorCode.CONNECTION_FAILED,
+        import_types19.WalletErrorCode.CONNECTION_FAILED,
         "Mock connection failure"
       );
       throw new WalletError(
         "Mock connection failure",
-        import_types16.WalletErrorCode.CONNECTION_FAILED
+        import_types19.WalletErrorCode.CONNECTION_FAILED
       );
     }
     await new Promise((resolve) => setTimeout(resolve, 10));
@@ -7586,7 +8998,7 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
   async signMessage(message) {
     this.requireConnected();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types16.WalletErrorCode.SIGNING_FAILED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_FAILED);
     }
     const mockSig = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
@@ -7601,7 +9013,7 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
   async signTransaction(tx) {
     this.requireConnected();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types16.WalletErrorCode.SIGNING_FAILED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_FAILED);
     }
     const signature = await this.signMessage(
       new TextEncoder().encode(JSON.stringify(tx.data))
@@ -7783,7 +9195,7 @@ function isPrivateWalletAdapter(adapter) {
 }
 
 // src/wallet/solana/adapter.ts
-var import_types17 = require("@sip-protocol/types");
+var import_types20 = require("@sip-protocol/types");
 
 // src/wallet/solana/types.ts
 function getSolanaProvider(wallet = "phantom") {
@@ -7904,19 +9316,19 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
       }
       if (!this.provider) {
         this.setError(
-          import_types17.WalletErrorCode.NOT_INSTALLED,
+          import_types20.WalletErrorCode.NOT_INSTALLED,
           `${this.walletName} wallet is not installed`
         );
         throw new WalletError(
           `${this.walletName} wallet is not installed`,
-          import_types17.WalletErrorCode.NOT_INSTALLED
+          import_types20.WalletErrorCode.NOT_INSTALLED
         );
       }
       const { publicKey } = await this.provider.connect();
       if (!publicKey) {
         throw new WalletError(
           "No public key returned from wallet",
-          import_types17.WalletErrorCode.CONNECTION_FAILED
+          import_types20.WalletErrorCode.CONNECTION_FAILED
         );
       }
       this.setupEventHandlers();
@@ -7926,11 +9338,11 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Connection failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        this.setError(import_types17.WalletErrorCode.CONNECTION_REJECTED, message);
-        throw new WalletError(message, import_types17.WalletErrorCode.CONNECTION_REJECTED);
+        this.setError(import_types20.WalletErrorCode.CONNECTION_REJECTED, message);
+        throw new WalletError(message, import_types20.WalletErrorCode.CONNECTION_REJECTED);
       }
-      this.setError(import_types17.WalletErrorCode.CONNECTION_FAILED, message);
-      throw error instanceof WalletError ? error : new WalletError(message, import_types17.WalletErrorCode.CONNECTION_FAILED, { cause: error });
+      this.setError(import_types20.WalletErrorCode.CONNECTION_FAILED, message);
+      throw error instanceof WalletError ? error : new WalletError(message, import_types20.WalletErrorCode.CONNECTION_FAILED, { cause: error });
     }
   }
   /**
@@ -7953,7 +9365,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signMessage(message) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const { signature } = await this.provider.signMessage(message);
@@ -7964,9 +9376,9 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message2 = error instanceof Error ? error.message : "Signing failed";
       if (message2.includes("User rejected") || message2.includes("rejected")) {
-        throw new WalletError(message2, import_types17.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message2, import_types20.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message2, import_types17.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message2, import_types20.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -7979,7 +9391,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signTransaction(tx) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const solTx = tx.data;
@@ -7998,9 +9410,9 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Signing failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -8011,7 +9423,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signAndSendTransaction(tx) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const solTx = tx.data;
@@ -8026,12 +9438,12 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Transaction failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.TRANSACTION_REJECTED);
+        throw new WalletError(message, import_types20.WalletErrorCode.TRANSACTION_REJECTED);
       }
       if (message.includes("insufficient") || message.includes("Insufficient")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.INSUFFICIENT_FUNDS);
+        throw new WalletError(message, import_types20.WalletErrorCode.INSUFFICIENT_FUNDS);
       }
-      throw new WalletError(message, import_types17.WalletErrorCode.TRANSACTION_FAILED, {
+      throw new WalletError(message, import_types20.WalletErrorCode.TRANSACTION_FAILED, {
         cause: error
       });
     }
@@ -8044,16 +9456,16 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signAllTransactions(transactions) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       return await this.provider.signAllTransactions(transactions);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Signing failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -8074,7 +9486,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         "Failed to get balance",
-        import_types17.WalletErrorCode.UNKNOWN,
+        import_types20.WalletErrorCode.UNKNOWN,
         { cause: error }
       );
     }
@@ -8087,7 +9499,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "solana") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Solana adapter`,
-        import_types17.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types20.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8205,7 +9617,7 @@ function createSolanaAdapter(config = {}) {
 }
 
 // src/wallet/solana/mock.ts
-var import_types19 = require("@sip-protocol/types");
+var import_types22 = require("@sip-protocol/types");
 var MockPublicKey = class {
   base58;
   bytes;
@@ -8271,8 +9683,8 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this._connectionState = "connecting";
     await this.simulateLatency();
     if (this.shouldFailConnect) {
-      this.setError(import_types19.WalletErrorCode.CONNECTION_FAILED, "Mock connection failure");
-      throw new WalletError("Mock connection failure", import_types19.WalletErrorCode.CONNECTION_FAILED);
+      this.setError(import_types22.WalletErrorCode.CONNECTION_FAILED, "Mock connection failure");
+      throw new WalletError("Mock connection failure", import_types22.WalletErrorCode.CONNECTION_FAILED);
     }
     const hexPubKey = "0x" + Buffer.from(this.mockPublicKey.toBytes()).toString("hex");
     this.setConnected(this.mockAddress, hexPubKey);
@@ -8291,7 +9703,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     const mockSig = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
@@ -8309,7 +9721,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     const solTx = tx.data;
     this.signedTransactions.push(solTx);
@@ -8329,10 +9741,10 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     if (this.shouldFailTransaction) {
-      throw new WalletError("Mock transaction failure", import_types19.WalletErrorCode.TRANSACTION_FAILED);
+      throw new WalletError("Mock transaction failure", import_types22.WalletErrorCode.TRANSACTION_FAILED);
     }
     const txSig = `mock_tx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     this.sentTransactions.push(txSig);
@@ -8352,7 +9764,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     this.signedTransactions.push(...transactions);
     return transactions.map((tx) => {
@@ -8379,7 +9791,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "solana") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Solana adapter`,
-        import_types19.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types22.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8548,7 +9960,7 @@ function createMockSolanaAdapter(config = {}) {
 }
 
 // src/wallet/ethereum/adapter.ts
-var import_types21 = require("@sip-protocol/types");
+var import_types24 = require("@sip-protocol/types");
 
 // src/wallet/ethereum/types.ts
 var EthereumChainId = {
@@ -8690,7 +10102,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           `${this.walletType} wallet not found. Please install the extension.`,
-          import_types21.WalletErrorCode.NOT_INSTALLED
+          import_types24.WalletErrorCode.NOT_INSTALLED
         );
       }
       const accounts = await this.provider.request({
@@ -8700,7 +10112,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           "No accounts returned from wallet",
-          import_types21.WalletErrorCode.CONNECTION_REJECTED
+          import_types24.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       const address = normalizeAddress(accounts[0]);
@@ -8720,12 +10132,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected connection request",
-          import_types21.WalletErrorCode.CONNECTION_REJECTED
+          import_types24.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       throw new WalletError(
         `Failed to connect: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.CONNECTION_FAILED
+        import_types24.WalletErrorCode.CONNECTION_FAILED
       );
     }
   }
@@ -8745,7 +10157,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8763,12 +10175,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected signing request",
-          import_types21.WalletErrorCode.SIGNING_REJECTED
+          import_types24.WalletErrorCode.SIGNING_REJECTED
         );
       }
       throw new WalletError(
         `Failed to sign message: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.SIGNING_FAILED
+        import_types24.WalletErrorCode.SIGNING_FAILED
       );
     }
   }
@@ -8780,7 +10192,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8797,12 +10209,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected signing request",
-          import_types21.WalletErrorCode.SIGNING_REJECTED
+          import_types24.WalletErrorCode.SIGNING_REJECTED
         );
       }
       throw new WalletError(
         `Failed to sign typed data: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.SIGNING_FAILED
+        import_types24.WalletErrorCode.SIGNING_FAILED
       );
     }
   }
@@ -8814,7 +10226,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8842,7 +10254,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected transaction signing",
-          import_types21.WalletErrorCode.SIGNING_REJECTED
+          import_types24.WalletErrorCode.SIGNING_REJECTED
         );
       }
       if (rpcError.code === -32601 || rpcError.message?.includes("not supported")) {
@@ -8860,7 +10272,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       }
       throw new WalletError(
         `Failed to sign transaction: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.TRANSACTION_FAILED
+        import_types24.WalletErrorCode.TRANSACTION_FAILED
       );
     }
   }
@@ -8872,7 +10284,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8894,12 +10306,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected transaction",
-          import_types21.WalletErrorCode.TRANSACTION_REJECTED
+          import_types24.WalletErrorCode.TRANSACTION_REJECTED
         );
       }
       throw new WalletError(
         `Failed to send transaction: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.TRANSACTION_FAILED
+        import_types24.WalletErrorCode.TRANSACTION_FAILED
       );
     }
   }
@@ -8934,7 +10346,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         `Failed to fetch balance: ${String(error)}`,
-        import_types21.WalletErrorCode.UNKNOWN
+        import_types24.WalletErrorCode.UNKNOWN
       );
     }
   }
@@ -8946,7 +10358,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "ethereum") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Ethereum adapter`,
-        import_types21.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types24.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8971,7 +10383,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         `Failed to fetch token balance: ${String(error)}`,
-        import_types21.WalletErrorCode.UNKNOWN
+        import_types24.WalletErrorCode.UNKNOWN
       );
     }
   }
@@ -8983,7 +10395,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8998,18 +10410,18 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected chain switch",
-          import_types21.WalletErrorCode.CHAIN_SWITCH_REJECTED
+          import_types24.WalletErrorCode.CHAIN_SWITCH_REJECTED
         );
       }
       if (rpcError.code === 4902) {
         throw new WalletError(
           `Chain ${chainId} not added to wallet`,
-          import_types21.WalletErrorCode.UNSUPPORTED_CHAIN
+          import_types24.WalletErrorCode.UNSUPPORTED_CHAIN
         );
       }
       throw new WalletError(
         `Failed to switch chain: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.CHAIN_SWITCH_FAILED
+        import_types24.WalletErrorCode.CHAIN_SWITCH_FAILED
       );
     }
   }
@@ -9045,7 +10457,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     }
     throw new WalletError(
       `Transaction ${txHash} not confirmed after ${maxAttempts * 5} seconds`,
-      import_types21.WalletErrorCode.TRANSACTION_FAILED
+      import_types24.WalletErrorCode.TRANSACTION_FAILED
     );
   }
   /**
@@ -9119,7 +10531,7 @@ function createEthereumAdapter(config) {
 }
 
 // src/wallet/ethereum/mock.ts
-var import_types23 = require("@sip-protocol/types");
+var import_types26 = require("@sip-protocol/types");
 var MockEthereumAdapter = class extends BaseWalletAdapter {
   chain = "ethereum";
   name = "mock-ethereum";
@@ -9160,7 +10572,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           "Mock connection rejected",
-          import_types23.WalletErrorCode.CONNECTION_REJECTED
+          import_types26.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       await new Promise((resolve) => setTimeout(resolve, 10));
@@ -9172,7 +10584,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
       this._connectionState = "error";
       throw new WalletError(
         `Mock connection failed: ${String(error)}`,
-        import_types23.WalletErrorCode.CONNECTION_FAILED
+        import_types26.WalletErrorCode.CONNECTION_FAILED
       );
     }
   }
@@ -9190,7 +10602,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types23.WalletErrorCode.SIGNING_REJECTED
+        import_types26.WalletErrorCode.SIGNING_REJECTED
       );
     }
     const msgHex = Buffer.from(message).toString("hex");
@@ -9208,7 +10620,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types23.WalletErrorCode.SIGNING_REJECTED
+        import_types26.WalletErrorCode.SIGNING_REJECTED
       );
     }
     const mockSig = `0x${"1".repeat(130)}`;
@@ -9225,7 +10637,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types23.WalletErrorCode.SIGNING_REJECTED
+        import_types26.WalletErrorCode.SIGNING_REJECTED
       );
     }
     this._signedTransactions.push(tx);
@@ -9250,7 +10662,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailTransaction) {
       throw new WalletError(
         "Mock transaction failed",
-        import_types23.WalletErrorCode.TRANSACTION_FAILED
+        import_types26.WalletErrorCode.TRANSACTION_FAILED
       );
     }
     this._signedTransactions.push(tx);
@@ -9280,7 +10692,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "ethereum") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Ethereum adapter`,
-        import_types23.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types26.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -9559,7 +10971,7 @@ function getAvailableTransports() {
 }
 
 // src/wallet/hardware/ledger.ts
-var import_types26 = require("@sip-protocol/types");
+var import_types29 = require("@sip-protocol/types");
 var LedgerWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "ledger";
@@ -9712,7 +11124,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types26.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -9723,7 +11135,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types26.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -10011,7 +11423,7 @@ function createLedgerAdapter(config) {
 }
 
 // src/wallet/hardware/trezor.ts
-var import_types28 = require("@sip-protocol/types");
+var import_types31 = require("@sip-protocol/types");
 var TrezorWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "trezor";
@@ -10157,7 +11569,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types28.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types31.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10168,7 +11580,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types28.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types31.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -10449,8 +11861,8 @@ function createTrezorAdapter(config) {
 }
 
 // src/wallet/hardware/mock.ts
-var import_types30 = require("@sip-protocol/types");
-var import_utils14 = require("@noble/hashes/utils");
+var import_types33 = require("@sip-protocol/types");
+var import_utils15 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -10597,7 +12009,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10606,7 +12018,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10695,15 +12107,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils14.randomBytes)(20);
+    const bytes = (0, import_utils15.randomBytes)(20);
     bytes[0] = index;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils14.randomBytes)(33);
+    const bytes = (0, import_utils15.randomBytes)(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -10712,7 +12124,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${(0, import_utils14.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils15.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -10836,13 +12248,13 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getAccounts(startIndex = 0, count = 5) {
@@ -10901,15 +12313,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils14.randomBytes)(20);
+    const bytes = (0, import_utils15.randomBytes)(20);
     bytes[0] = index + 100;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils14.randomBytes)(33);
+    const bytes = (0, import_utils15.randomBytes)(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -10918,7 +12330,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${(0, import_utils14.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils15.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -10932,7 +12344,7 @@ function createMockTrezorAdapter(config) {
 }
 
 // src/wallet/index.ts
-var import_types33 = require("@sip-protocol/types");
+var import_types36 = require("@sip-protocol/types");
 
 // src/proofs/browser.ts
 var import_noir_js = require("@noir-lang/noir_js");
@@ -10940,7 +12352,7 @@ var import_bb = require("@aztec/bb.js");
 var import_secp256k14 = require("@noble/curves/secp256k1");
 
 // src/proofs/circuits/funding_proof.json
-var funding_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "13977419962319221401", abi: { parameters: [{ name: "commitment_hash", type: { kind: "field" }, visibility: "public" }, { name: "minimum_required", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "asset_id", type: { kind: "field" }, visibility: "public" }, { name: "balance", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "private" }, { name: "blinding", type: { kind: "field" }, visibility: "private" }], return_type: null, error_types: { "2900908756532713827": { error_kind: "string", string: "Insufficient balance" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" }, "17719928407928969950": { error_kind: "string", string: "Commitment hash mismatch" } } }, bytecode: "H4sIAAAAAAAA/+VYbUhTURg+d7vTTdfmnJlK1g360LJolUEUJaUZ/qgooS9Taq5aoCudlhHV6LuglPplBH0gLUuiCCv6osA+LImItCQ0wUyRTJSJWkG7ds58PV53PzT60Qt3z+65z/ue533u8exeGfQnWIxZm+zZ4V4043PGe6gx8kcCNabGYyw+V6HBQcY4jDMzl+c0WC7E3l2ZVO5yrd0YM7t5WcG9HUVLGjxn2nEdDkkKRi3OZfxd5JC0XNiXBmMAYRAz+IEEqgJLTfS3mh+ibiGuy2hkaAhAykxlZPYKNYn1yvqZmJ5XrJaEReMLeOMDMWppknoYAsRMChyam0ZxGa10DWgkDWWRMkN1GINoklxDoQAxQ3VIuqFB0jX0mcbfgAAwxmHULiwwfYjX5ce2B+RZfo6u/FXgPtf2al7hIvuaOKsjZT3kRu1P7y3bb0mbdDWiU/+iZvai19f21Lw0htW5HlTE9JzZCLlSgnA1Ke7tua9OzFmVvuFRdeP8i5Gnjhgz5q2cfHpnfVLRw0YV5HLn3zyO+7Gmp4t1JNZEPevtzkm98TxhL9u6OWrz0conkyFXLOBCC0T9PvGowxhEaRUJJtj7ofceo9DILuRgpGwhGzAaaZLchQwFiC1kA5K+kI1I2Q0bJBDJ60ePlBkagtFEk+QaCgWIGRqCpBtqQv/GUBVSZmgoRjNNkmsoFCBmaCiSbqhZugbfFqIHYxzG/3mrhdyxiR0l3F7X0xMHJ5S40ppvWkIm3v9mjoi8X+u5VOZOXga56tK2uU2Lp0YzRdapz9YVt7SWXI8b437JlS64cfJ4RbcbcuVomN59L+HLccNy867Pq3N7m4qj81bY45uuHCjfctZp6aiqgtwZVcfertv6YPXdw0UzRoUf2ZR6vbz06bvu9CmV+77felJ4EHLFgjyg8evEgNGIMQSjCWMoRjOlXSTUMrhy6jJh3o/R3iOcuiD3LQpypcwpkevTwRvAov79o68QGrjpCL01WT92dk2MXBwDa5LNqa7Ycwe9b/HQ+eTnNdNmdWTtcOTaMrbZs53j8KiWYpNXMg5JCgauFvn5B5Lp1wGZ8yeTh6Hh6Cc5CvJ9D6yJIJ/Wwoce9f8fAFE5/IOdAXw3ghw+kkA9hrq2VGDeYfaURPJZZfmqUDR4flKLf1jle4zA52oBLlxLGsAR8hUJjDECdWhv4H3gMJotqGZ8fXzBtPC5jhX5h+pTy/aFXY79aoxoy1uQ3/PJQfei8qNd70eDXqAf6A/5m1Dm/+5kMifRpUGD/YL1WYofjVEH5oc6OeQ/ais81bdTZmWZqHw+SM98n1H4e6Y9x2Z12vNtGd6NybbVlpOxM8/htNuyncQJLcgiFeWsSJIfrCx/wGsporTAur4JMbICecwQ5yoK/XHpcTimF7hGapLfCqiX9PEbVAIFlc4UAAA=", debug_symbols: "pZbNbsMgDMffhXMO2HwE8irTVKUtmyJFaZUlk6aq7z6TQpYcYBW9QN3k/4sx2PjGzu44fx664ePyxZq3GzuOXd93n4f+cmqn7jLQvzfG/QCaNVgxqB+TYY2gybJGVgzpDXm/VyzKDtPonFdtOES/tqMbJtYMc99X7Lvt5+Wlr2s7LPPUjvSUV8wNZ5oJ+NH1zv+6V39qnpYajkFsUK9yqHd6SOu1lEGvlSjRG4h6Y4r0cfE1T34/t36I/hsJq149HT/gwgYAcKWKCGBWgq5ThDpD0BCDCHrjA9gdwWQI1kYfkGOSYNMECaACQYIyJQQUdSRgrcoI8CoBxROEbCSNjnthbQkBuYpHEgEhRfDhTiGEkjEQQnNe4gRgvTqhRdKJzKmUysZ1SC03tUUXImwKkUsukLG+AdhkemIGgWjW3BDbGrkPBWaKFBpct9So5JYivpxfWcRzCfYPAl5GPJVi2XBaHmsuWrAlCAE83hsCQJQh/pIMbP0qAtN5mjvfyNfLAyXfne93stpTN+5bE6SHFRPLKJdRLaP210/FqFkB2h/zsOzDAupW/CUF4HOAZoIglTkQwZbBVsHWwfatjw29jz/23+3YtcfeeU+8r/Nwio6ROf1c45PYVV3Hy8md59H5RWxaKxrfKKfQvt/9Qn8B", file_map: { "16": { source: "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        let mut result = if double_predicate {\n            // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n            embedded_curve_add_unsafe(point1, point1)\n        } else {\n            let point1_1 = EmbeddedCurvePoint {\n                x: point1.x + (x_coordinates_match as Field),\n                y: point1.y,\n                is_infinite: false,\n            };\n            let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n            // point1_1 is guaranteed to have a different abscissa than point2:\n            // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n            // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n            // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n            // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n            // therefore we only want to do this if we need the result, otherwise it needs to be eliminated as a dead instruction, lest we want the circuit to fail.\n            embedded_curve_add_unsafe(point1_1, point2_1)\n        };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    // Ensure is_infinite is comptime\n    let point1_1 = EmbeddedCurvePoint { x: point1.x, y: point1.y, is_infinite: false };\n    let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n    embedded_curve_add_unsafe(point1_1, point2_1)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n", path: "std/embedded_curve_ops.nr" }, "17": { source: `use crate::field::field_less_than;
+var funding_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "3859649086066977477", abi: { parameters: [{ name: "minimum_required", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "asset_id", type: { kind: "field" }, visibility: "public" }, { name: "balance", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "private" }, { name: "blinding", type: { kind: "field" }, visibility: "private" }], return_type: { abi_type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "public" }, error_types: { "2900908756532713827": { error_kind: "string", string: "Insufficient balance" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" }, "15835548349546956319": { error_kind: "string", string: "Field failed to decompose into specified 32 limbs" } } }, bytecode: "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", debug_symbols: "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", file_map: { "17": { source: `use crate::field::field_less_than;
 use crate::runtime::is_unconstrained;
 
 // The low and high decomposition of the field modulus
@@ -11143,105 +12555,7 @@ mod tests {
         assert(!lt(TWO_POW_128, TWO_POW_128 - 1));
     }
 }
-`, path: "std/field/bn254.nr" }, "19": { source: '// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated("This function has been moved to std::hash::keccakf1600")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you\'re working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            "Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators("pedersen_hash_length".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n', path: "std/hash/mod.nr" }, "50": { source: `/// Funding Proof Circuit
-///
-/// Proves: "I have sufficient funds to fulfill this intent, without revealing
-/// my exact balance, wallet address, or source of funds."
-///
-/// @see docs/specs/FUNDING-PROOF.md
-
-use std::hash::pedersen_hash;
-use std::hash::pedersen_commitment;
-
-// --- Main Circuit ---
-
-/// Main funding proof entry point
-///
-/// Public inputs: commitment_hash, minimum_required, asset_id
-/// Private inputs: balance, blinding
-///
-/// Constraints:
-/// 1. balance >= minimum_required (range proof via u64)
-/// 2. commitment = Pedersen(balance, blinding)
-/// 3. hash(commitment, asset_id) == commitment_hash
-pub fn main(
-    commitment_hash: pub Field,
-    minimum_required: pub u64,
-    asset_id: pub Field,
-    balance: u64,
-    blinding: Field,
-) {
-    // Constraint 1: Sufficient Funds
-    assert(balance >= minimum_required, "Insufficient balance");
-    
-    // Constraint 2: Compute Pedersen Commitment
-    // Uses Noir's built-in pedersen_commitment which returns (x, y) point
-    let commitment = pedersen_commitment([balance as Field, blinding]);
-    
-    // Constraint 3: Verify Commitment Hash
-    let computed_hash = pedersen_hash([commitment.x, commitment.y, asset_id]);
-    assert(computed_hash == commitment_hash, "Commitment hash mismatch");
-}
-
-// --- Tests ---
-
-#[test]
-fn test_valid_funding_proof() {
-    let balance: u64 = 100;
-    let minimum_required: u64 = 50;
-    let blinding: Field = 12345;
-    let asset_id: Field = 0xABCD;
-
-    // Compute commitment using same method as circuit
-    let commitment = pedersen_commitment([balance as Field, blinding]);
-    let commitment_hash = pedersen_hash([commitment.x, commitment.y, asset_id]);
-
-    // This should pass
-    main(commitment_hash, minimum_required, asset_id, balance, blinding);
-}
-
-#[test(should_fail_with = "Insufficient balance")]
-fn test_insufficient_balance() {
-    let balance: u64 = 50;
-    let minimum_required: u64 = 100;
-    let blinding: Field = 12345;
-    let asset_id: Field = 0xABCD;
-
-    let commitment = pedersen_commitment([balance as Field, blinding]);
-    let commitment_hash = pedersen_hash([commitment.x, commitment.y, asset_id]);
-
-    // This should fail - balance < minimum
-    main(commitment_hash, minimum_required, asset_id, balance, blinding);
-}
-
-#[test(should_fail_with = "Commitment hash mismatch")]
-fn test_wrong_commitment_hash() {
-    let balance: u64 = 100;
-    let minimum_required: u64 = 50;
-    let blinding: Field = 12345;
-    let asset_id: Field = 0xABCD;
-    let wrong_hash: Field = 0xDEADBEEF;
-
-    // This should fail - wrong hash
-    main(wrong_hash, minimum_required, asset_id, balance, blinding);
-}
-
-#[test(should_fail_with = "Commitment hash mismatch")]
-fn test_wrong_blinding() {
-    let balance: u64 = 100;
-    let minimum_required: u64 = 50;
-    let correct_blinding: Field = 12345;
-    let wrong_blinding: Field = 54321;
-    let asset_id: Field = 0xABCD;
-
-    // Compute hash with correct blinding
-    let commitment = pedersen_commitment([balance as Field, correct_blinding]);
-    let commitment_hash = pedersen_hash([commitment.x, commitment.y, asset_id]);
-
-    // Try to prove with wrong blinding - should fail
-    main(commitment_hash, minimum_required, asset_id, balance, wrong_blinding);
-}
-`, path: "/Users/rz/local-dev/sip-protocol/packages/circuits/funding_proof/src/main.nr" } }, expression_width: { Bounded: { width: 4 } } };
+`, path: "std/field/bn254.nr" }, "18": { source: 'pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            "BIT_SIZE must be less than modulus_num_bits",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the \'self\',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            "N must be less than or equal to modulus_le_bytes().len()",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the \'self\',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            "N must be less than or equal to modulus_le_bytes().len()",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, "radix must be greater than 1");\n            static_assert(radix <= 256, "radix must be less than or equal to 256");\n            static_assert(radix & (radix - 1) == 0, "radix must be a power of 2");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, "radix must be greater than 1");\n            static_assert(radix <= 256, "radix must be less than or equal to 256");\n            static_assert(radix & (radix - 1) == 0, "radix must be a power of 2");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            "N must be less than or equal to modulus_le_bytes().len()",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = "radix must be greater than 1")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f"radix must be greater than 1");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = "radix must be greater than 1")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f"radix must be greater than 1");\n        }\n    }\n\n    #[test(should_fail_with = "radix must be a power of 2")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f"radix must be a power of 2");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, "unexpected result");\n        }\n    }\n\n    #[test(should_fail_with = "radix must be less than or equal to 256")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f"radix must be less than or equal to 256")\n        }\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 16 limbs")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 16 limbs")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [u1; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], 1);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [u1; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], 1);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [u1; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [0; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [u1; 8] = 1.to_le_bits();\n        let expected: [u1; 8] = [1, 0, 0, 0, 0, 0, 0, 0];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [u1; 8] = 4.to_le_bits();\n        let expected: [u1; 8] = [0, 0, 1, 0, 0, 0, 0, 0];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), 0);\n        assert_eq(2.sgn0(), 0);\n        assert_eq(4.sgn0(), 0);\n        assert_eq(100.sgn0(), 0);\n\n        assert_eq(1.sgn0(), 1);\n        assert_eq(3.sgn0(), 1);\n        assert_eq(5.sgn0(), 1);\n        assert_eq(101.sgn0(), 1);\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 8 limbs")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can\'t represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u1; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = "Field failed to decompose into specified 4 limbs")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can\'t represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [u1; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            "N must be less than or equal to modulus_le_bits().len()",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [u1; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [u1; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1] > 0);\n            p_minus_1_bits[254 - 1] -= 1;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [u1; 254] = modulus_be_bits().as_array();\n            assert(p_plus_4_bits[254 - 3] < 1);\n            p_plus_4_bits[254 - 3] += 1;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_be_bits();\n            assert_eq(p_plus_4_converted_bits[254 - 3], 1);\n            p_plus_4_converted_bits[254 - 3] = 0;\n            assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bytes produces 254 zeroes\n            let p_bits: [u1; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [0; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [u1; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0] > 0);\n            p_minus_1_bits[0] -= 1;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [u1; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [u1; 254] = modulus_le_bits().as_array();\n            assert(p_plus_4_bits[2] < 1);\n            p_plus_4_bits[2] += 1;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [u1; 254] = p_plus_4.to_le_bits();\n            assert_eq(p_plus_4_converted_bits[2], 1);\n            p_plus_4_converted_bits[2] = 0;\n            assert_eq(p_plus_4_converted_bits, [0; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bytes produces 254 zeroes\n            let p_bits: [u1; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [0; 254]);\n        }\n    }\n}\n', path: "std/field/mod.nr" }, "19": { source: '// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated("This function has been moved to std::hash::keccakf1600")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you\'re working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            "Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators("pedersen_hash_length".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n    assert_eq(input.len(), state_len);\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n', path: "std/hash/mod.nr" }, "50": { source: '/// Funding Proof Circuit\n///\n/// Proves that a user has sufficient balance to cover a transaction\n/// without revealing the actual balance.\n///\n/// Public inputs:\n/// - commitment_hash: Hash of the Pedersen commitment to balance\n/// - minimum_required: Minimum balance required\n/// - asset_id: Asset identifier\n///\n/// Private inputs (witness):\n/// - balance: Actual user balance\n/// - blinding: Blinding factor for commitment\n///\n/// Constraints:\n/// 1. balance >= minimum_required\n/// 2. commitment = pedersen([balance, blinding])\n/// 3. commitment_hash = hash(commitment, asset_id)\n\nuse std::hash::pedersen_hash;\nuse std::hash::blake3;\n\n/// Main entry point for the funding proof circuit\n///\n/// Returns the commitment hash as a public output rather than taking it as input.\n/// This allows the SDK to verify the proof without needing to compute Pedersen hashes.\nfn main(\n    // Public inputs\n    minimum_required: pub u64,\n    asset_id: pub Field,\n\n    // Private inputs (witness)\n    balance: u64,\n    blinding: Field,\n) -> pub [u8; 32] {\n    // Constraint 1: Balance must be at least the minimum required\n    assert(balance >= minimum_required, "Insufficient balance");\n\n    // Constraint 2: Compute the Pedersen commitment to (balance, blinding)\n    let balance_field = balance as Field;\n    let commitment = pedersen_hash([balance_field, blinding]);\n\n    // Constraint 3: Compute and return the commitment hash\n    // We hash: commitment || asset_id to bind the commitment to the asset\n    let commitment_hash = compute_commitment_hash(commitment, asset_id);\n\n    commitment_hash\n}\n\n/// Compute the commitment hash from commitment and asset_id\n/// Uses BLAKE3 for efficiency (built-in to Noir)\nfn compute_commitment_hash(commitment: Field, asset_id: Field) -> [u8; 32] {\n    // Convert commitment to bytes (32 bytes, big-endian)\n    let commitment_bytes: [u8; 32] = commitment.to_be_bytes();\n\n    // Convert asset_id to bytes (32 bytes, big-endian)\n    let asset_bytes: [u8; 32] = asset_id.to_be_bytes();\n\n    // Create preimage: commitment || asset_id (64 bytes)\n    let mut preimage: [u8; 64] = [0; 64];\n    for i in 0..32 {\n        preimage[i] = commitment_bytes[i];\n        preimage[i + 32] = asset_bytes[i];\n    }\n\n    // Hash with BLAKE3\n    blake3(preimage)\n}\n\n// --- Tests ---\n\n#[test]\nfn test_valid_funding_proof() {\n    // Test case: balance = 100, minimum = 50\n    let balance: u64 = 100;\n    let minimum_required: u64 = 50;\n    let blinding = 12345 as Field;\n    let asset_id = 1 as Field;\n\n    // Execute the circuit - it should return the commitment hash\n    let commitment_hash = main(minimum_required, asset_id, balance, blinding);\n\n    // Verify it returned a hash (not all zeros)\n    let mut has_nonzero = false;\n    for i in 0..32 {\n        if commitment_hash[i] != 0 {\n            has_nonzero = true;\n        }\n    }\n    assert(has_nonzero, "Commitment hash should not be all zeros");\n}\n\n#[test]\nfn test_exact_balance_passes() {\n    // Test case: balance exactly equals minimum\n    let balance: u64 = 50;\n    let minimum_required: u64 = 50;\n    let blinding = 67890 as Field;\n    let asset_id = 2 as Field;\n\n    // Should succeed and return a hash\n    let _commitment_hash = main(minimum_required, asset_id, balance, blinding);\n}\n\n#[test(should_fail_with = "Insufficient balance")]\nfn test_insufficient_balance_fails() {\n    // Test case: balance < minimum should fail\n    let balance: u64 = 40;\n    let minimum_required: u64 = 50;\n    let blinding = 11111 as Field;\n    let asset_id = 1 as Field;\n\n    // Should fail because balance < minimum_required\n    let _commitment_hash = main(minimum_required, asset_id, balance, blinding);\n}\n\n#[test]\nfn test_different_blinding_produces_different_hash() {\n    // Test that different blinding factors produce different commitment hashes\n    let balance: u64 = 100;\n    let minimum_required: u64 = 50;\n    let blinding1 = 12345 as Field;\n    let blinding2 = 99999 as Field;\n    let asset_id = 1 as Field;\n\n    let hash1 = main(minimum_required, asset_id, balance, blinding1);\n    let hash2 = main(minimum_required, asset_id, balance, blinding2);\n\n    // Hashes should be different\n    let mut hashes_differ = false;\n    for i in 0..32 {\n        if hash1[i] != hash2[i] {\n            hashes_differ = true;\n        }\n    }\n    assert(hashes_differ, "Different blindings should produce different hashes");\n}\n', path: "/Users/rz/local-dev/circuits/funding_proof/src/main.nr" } }, expression_width: { Bounded: { width: 4 } } };
 
 // src/proofs/circuits/validity_proof.json
 var validity_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "17105369051450454041", abi: { parameters: [{ name: "intent_hash", type: { kind: "field" }, visibility: "public" }, { name: "sender_commitment_x", type: { kind: "field" }, visibility: "public" }, { name: "sender_commitment_y", type: { kind: "field" }, visibility: "public" }, { name: "nullifier", type: { kind: "field" }, visibility: "public" }, { name: "timestamp", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "expiry", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "sender_address", type: { kind: "field" }, visibility: "private" }, { name: "sender_blinding", type: { kind: "field" }, visibility: "private" }, { name: "sender_secret", type: { kind: "field" }, visibility: "private" }, { name: "pub_key_x", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "pub_key_y", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "signature", type: { kind: "array", length: 64, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "message_hash", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "nonce", type: { kind: "field" }, visibility: "private" }], return_type: null, error_types: { "4743545721632785176": { error_kind: "string", string: "Nullifier mismatch" }, "4924752953922582949": { error_kind: "string", string: "Invalid ECDSA signature" }, "5940733937471987676": { error_kind: "string", string: "Intent expired" }, "9872184990886929843": { error_kind: "string", string: "Sender commitment X mismatch" }, "14620555433709191364": { error_kind: "string", string: "Sender commitment Y mismatch" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" } } }, bytecode: "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", debug_symbols: "pZbNjuIwDIDfJeceYsf541VGI1SgM6pUFdSBlVaId9+YxaU9JMuGS+O69dfYsV1f1aHbXb63/fh1/FGbj6vaTf0w9N/b4bhvz/1xTNqr0nwBpzbYKPB/l6A2Ji1RbahRmN6g261RYrY9T13HVgtOop/aqRvPajNehqFRv9rhcn/p59SO9/XcTumpblQ3HtKagF/90LF0a57WOm8aND6MA7rZHPzKHvL2juhh76ypsQ8g9iFU2YvzXme/X/AfCCQAQO4ZAbuOoC0QHIgL4Kx97iGuCK5AiDE8CKgxS/B5AgHYB4HAhhoCGi8E9LaOAO8S0LxAKEYyODmLGGsIqK0kNAJCjgAmjzCWJBDGaV2zCUA/b8KZ7CYKWUk2ih/kaFHZrhIRc4hicfkox2GBcsVVIlinZ8LiQP+D4IOUBgQKOQKWENpJXgKYRSDo5U0EN/eI4HWFGykvYU4JDVk3CnmJGOY2Y5bNfp1VSAVEwLk6gs1WB9q3W1UR8Vqv+gcC3ka81K2K4Yxa6gMjxBqEAS0FYlJy1iGe/QqifxeB+ZZXym+AZ9+lmkJHREksRDIrwme6a/f9tJ7SwGEae9JM5gxXNgv0UFhROO53LHguXRYCu8VC5K3yfKdFAP40C4mLbOUNnywLJBorGicaLxqeEO/miWyIR0bNfxMWQAQUwbBw43BMfbsbOvaIfb6Me3Ew3Z5/n+SJDKqn6bjvDpep42AsptV0/UhnjPHzxgH7Aw==", file_map: { "14": { source: "// docs:start:ecdsa_secp256k1\n/// Verifies a ECDSA signature over the secp256k1 curve.\n/// - inputs:\n///     - x coordinate of public key as 32 bytes\n///     - y coordinate of public key as 32 bytes\n///     - the signature, as a 64 bytes array\n///       The signature internally will be represented as `(r, s)`,\n///       where `r` and `s` are fixed-sized big endian scalar values.\n///       As the `secp256k1` has a 256-bit modulus, we have a 64 byte signature\n///       while `r` and `s` will both be 32 bytes.\n///       We expect `s` to be normalized. This means given the curve's order,\n///       `s` should be less than or equal to `order / 2`.\n///       This is done to prevent malleability.\n///       For more context regarding malleability you can reference BIP 0062.\n///     - the hash of the message, as a vector of bytes\n/// - output: false for failure and true for success\npub fn verify_signature(\n    public_key_x: [u8; 32],\n    public_key_y: [u8; 32],\n    signature: [u8; 64],\n    message_hash: [u8; 32],\n) -> bool\n// docs:end:ecdsa_secp256k1\n{\n    _verify_signature(public_key_x, public_key_y, signature, message_hash, true)\n}\n\n#[foreign(ecdsa_secp256k1)]\npub fn _verify_signature(\n    public_key_x: [u8; 32],\n    public_key_y: [u8; 32],\n    signature: [u8; 64],\n    message_hash: [u8; 32],\n    predicate: bool,\n) -> bool {}\n", path: "std/ecdsa_secp256k1.nr" }, "16": { source: "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n            is_infinite: false,\n        }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        if self.is_infinite {\n            self.is_infinite.hash(state);\n        } else {\n            self.x.hash(state);\n            self.y.hash(state);\n        }\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    if crate::runtime::is_unconstrained() {\n        // `embedded_curve_add_unsafe` requires the inputs not to be the infinity point, so we check it here.\n        // This is because `embedded_curve_add_unsafe` uses the `embedded_curve_add` opcode.\n        // For efficiency, the backend does not check the inputs for the infinity point, but it assumes that they are not the infinity point\n        // so that it can apply the ec addition formula directly.\n        if point1.is_infinite {\n            point2\n        } else if point2.is_infinite {\n            point1\n        } else {\n            embedded_curve_add_unsafe(point1, point2)\n        }\n    } else {\n        // In a constrained context, we also need to check the inputs are not the infinity point because we also use `embedded_curve_add_unsafe`\n        // However we also need to identify the case where the two inputs are the same, because then\n        // the addition formula does not work and we need to use the doubling formula instead.\n        // In unconstrained context, we can check directly if the input values are the same when solving the opcode, so it is not an issue.\n\n        // x_coordinates_match is true if both abscissae are the same\n        let x_coordinates_match = point1.x == point2.x;\n        // y_coordinates_match is true if both ordinates are the same\n        let y_coordinates_match = point1.y == point2.y;\n        // double_predicate is true if both abscissae and ordinates are the same\n        let double_predicate = (x_coordinates_match & y_coordinates_match);\n        // If the abscissae are the same, but not the ordinates, then one point is the opposite of the other\n        let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n\n        // `embedded_curve_add_unsafe` would not perform doubling, even if the inputs point1 and point2 are the same, because it cannot know this without adding some logic (and some constraints)\n        // However we did this logic when we computed `double_predicate`, so we set the result to 2*point1 if point1 and point2 are the same\n        let mut result = if double_predicate {\n            // `embedded_curve_add_unsafe` is doing a doubling if the input is the same variable, because in this case it is guaranteed (at 'compile time') that the input is the same.\n            embedded_curve_add_unsafe(point1, point1)\n        } else {\n            let point1_1 = EmbeddedCurvePoint {\n                x: point1.x + (x_coordinates_match as Field),\n                y: point1.y,\n                is_infinite: false,\n            };\n            let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n            // point1_1 is guaranteed to have a different abscissa than point2:\n            // - if x_coordinates_match is 0, that means point1.x != point2.x, and point1_1.x = point1.x + 0\n            // - if x_coordinates_match is 1, that means point1.x = point2.x, but point1_1.x = point1.x + 1 in this case\n            // Because the abscissa is different, the addition formula is guaranteed to succeed, so we can safely use `embedded_curve_add_unsafe`\n            // Note that this computation may be garbage: if x_coordinates_match is 1, or if one of the input is the point at infinity.\n            // therefore we only want to do this if we need the result, otherwise it needs to be eliminated as a dead instruction, lest we want the circuit to fail.\n            embedded_curve_add_unsafe(point1_1, point2_1)\n        };\n\n        // Same logic as above for unconstrained context, we set the proper result when one of the inputs is the infinity point\n        if point1.is_infinite {\n            result = point2;\n        }\n        if point2.is_infinite {\n            result = point1;\n        }\n\n        // Finally, we set the is_infinity flag of the result:\n        // Opposite points should sum into the infinity point, however, if one of them is point at infinity, their coordinates are not meaningful\n        // so we should not use the fact that the inputs are opposite in this case:\n        let mut result_is_infinity =\n            infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n        // However, if both of them are at infinity, then the result is also at infinity\n        result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n        result\n    }\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    // Ensure is_infinite is comptime\n    let point1_1 = EmbeddedCurvePoint { x: point1.x, y: point1.y, is_infinite: false };\n    let point2_1 = EmbeddedCurvePoint { x: point2.x, y: point2.y, is_infinite: false };\n    embedded_curve_add_unsafe(point1_1, point2_1)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n", path: "std/embedded_curve_ops.nr" }, "17": { source: `use crate::field::field_less_than;
@@ -11921,6 +13235,9 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   framework = "noir";
   _isReady = false;
   config;
+  // Mobile device info (cached)
+  deviceInfo = null;
+  wasmCompatibility = null;
   // Circuit instances
   fundingNoir = null;
   fundingBackend = null;
@@ -11932,17 +13249,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;
@@ -11972,6 +13297,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
    */
@@ -11981,6 +13367,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
    *
@@ -11993,8 +13391,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 */
@@ -12058,8 +13466,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;
     }
   }
   /**
@@ -12081,15 +13550,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
       };
@@ -12098,7 +13562,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,
@@ -12110,10 +13574,12 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
         percent: 100,
         message: "Proof generated successfully"
       });
+      const commitmentHashBytes = returnValue;
+      const commitmentHashHex = bytesToHex7(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",
@@ -12515,6 +13981,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;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ATTESTATION_VERSION,
@@ -12545,6 +14319,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   MockWalletAdapter,
   NATIVE_TOKENS,
   NEARIntentsAdapter,
+  NEARIntentsBackend,
   NetworkError,
   ORACLE_DOMAIN,
   OneClickClient,
@@ -12558,6 +14333,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   ProofError,
   ProofGenerationError,
   ProofNotImplementedError,
+  ProofWorker,
   ProposalStatus,
   ReportStatus,
   SIP,
@@ -12566,13 +14342,18 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS,
   STABLECOIN_INFO,
+  SettlementRegistry,
+  SettlementRegistryError,
+  SmartRouter,
   SolanaWalletAdapter,
+  SwapStatus,
   Treasury,
   TrezorWalletAdapter,
   ValidationError,
   WalletError,
   WalletErrorCode,
   ZcashErrorCode,
+  ZcashNativeBackend,
   ZcashRPCClient,
   ZcashRPCError,
   ZcashShieldedService,
@@ -12585,6 +14366,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   browserBytesToHex,
   browserHexToBytes,
   checkEd25519StealthAddress,
+  checkMobileWASMCompatibility,
   checkStealthAddress,
   commit,
   commitZero,
@@ -12601,15 +14383,19 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   createMockSolver,
   createMockTrezorAdapter,
   createNEARIntentsAdapter,
+  createNEARIntentsBackend,
   createOracleRegistry,
   createProductionSIP,
   createSIP,
   createShieldedIntent,
   createShieldedPayment,
+  createSmartRouter,
   createSolanaAdapter,
   createTrezorAdapter,
   createWalletFactory,
+  createWorkerBlobURL,
   createZcashClient,
+  createZcashNativeBackend,
   createZcashShieldedService,
   createZcashSwapService,
   decodeStealthMetaAddress,
@@ -12623,6 +14409,8 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   deserializeIntent,
   deserializePayment,
   detectEthereumWallets,
+  detectMobileBrowser,
+  detectMobilePlatform,
   detectSolanaWallets,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
@@ -12643,6 +14431,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   getActiveOracles,
   getAvailableTransports,
   getBrowserInfo,
+  getBrowserVersion,
   getChainNumericId,
   getChainsForStablecoin,
   getCurveForChain,
@@ -12652,6 +14441,8 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   getEthereumProvider,
   getGenerators,
   getIntentSummary,
+  getMobileDeviceInfo,
+  getOSVersion,
   getPaymentSummary,
   getPaymentTimeRemaining,
   getPrivacyConfig,
@@ -12677,6 +14468,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   isSIPError,
   isStablecoin,
   isStablecoinOnChain,
+  isTablet,
   isValidAmount,
   isValidChainId,
   isValidCompressedPublicKey,
@@ -12708,7 +14500,10 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   subtractBlindings,
   subtractCommitments,
   supportsSharedArrayBuffer,
+  supportsTouch,
   supportsViewingKey,
+  supportsWASMBulkMemory,
+  supportsWASMSimd,
   supportsWebBluetooth,
   supportsWebHID,
   supportsWebUSB,