@sip-protocol/sdk 0.2.8 → 0.2.10

package/dist/{chunk-UPTISVCY.mjs → chunk-AV37IZST.mjs}

@@ -3031,6 +3031,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);
@@ -3347,7 +3621,7 @@ function hasEnoughOracles(registry) {
 
 // src/index.ts
 import {
-  PrivacyLevel as PrivacyLevel7,
+  PrivacyLevel as PrivacyLevel8,
   IntentStatus as IntentStatus4,
   SIP_VERSION as SIP_VERSION3,
   NATIVE_TOKENS,
@@ -4396,6 +4670,436 @@ function createZcashShieldedService(config) {
   return new ZcashShieldedService(config);
 }
 
+// src/zcash/swap-service.ts
+import { PrivacyLevel as PrivacyLevel4 } from "@sip-protocol/types";
+var MOCK_PRICES = {
+  ETH: 2500,
+  SOL: 120,
+  NEAR: 5,
+  MATIC: 0.8,
+  USDC: 1,
+  USDT: 1,
+  ZEC: 35
+};
+var TOKEN_DECIMALS = {
+  ETH: 18,
+  SOL: 9,
+  NEAR: 24,
+  MATIC: 18,
+  USDC: 6,
+  USDT: 6,
+  ZEC: 8
+  // zatoshis
+};
+var ZcashSwapService = class {
+  config;
+  zcashService;
+  bridgeProvider;
+  priceFeed;
+  quotes = /* @__PURE__ */ new Map();
+  swaps = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      mode: config.mode,
+      defaultSlippage: config.defaultSlippage ?? 100,
+      // 1%
+      quoteValiditySeconds: config.quoteValiditySeconds ?? 60
+    };
+    this.zcashService = config.zcashService;
+    this.bridgeProvider = config.bridgeProvider;
+    this.priceFeed = config.priceFeed;
+  }
+  // ─── Quote Methods ───────────────────────────────────────────────────────────
+  /**
+   * Get a quote for swapping to ZEC
+   */
+  async getQuote(params) {
+    this.validateQuoteParams(params);
+    if (this.zcashService) {
+      const addressInfo = await this.zcashService.validateAddress(params.recipientZAddress);
+      if (!addressInfo.isvalid) {
+        throw new ValidationError(
+          "Invalid Zcash address",
+          "recipientZAddress",
+          { received: params.recipientZAddress },
+          "SIP_2007" /* INVALID_ADDRESS */
+        );
+      }
+    } else {
+      if (!this.isValidZAddressFormat(params.recipientZAddress)) {
+        throw new ValidationError(
+          "Invalid Zcash address format. Expected z-address (zs1...) or unified address (u1...)",
+          "recipientZAddress",
+          { received: params.recipientZAddress },
+          "SIP_2007" /* INVALID_ADDRESS */
+        );
+      }
+    }
+    if (this.config.mode === "production" && this.bridgeProvider) {
+      return this.getProductionQuote(params);
+    }
+    return this.getDemoQuote(params);
+  }
+  /**
+   * Get quote in demo mode (uses mock prices)
+   */
+  async getDemoQuote(params) {
+    const { sourceChain, sourceToken, amount, recipientZAddress, slippage } = params;
+    const sourcePrice = this.priceFeed ? await this.priceFeed.getPrice(sourceToken) : MOCK_PRICES[sourceToken] ?? 1;
+    const zecPrice = this.priceFeed ? await this.priceFeed.getZecPrice() : MOCK_PRICES.ZEC;
+    const sourceDecimals = TOKEN_DECIMALS[sourceToken] ?? 18;
+    const amountInUsd = Number(amount) / 10 ** sourceDecimals * sourcePrice;
+    const swapFeeUsd = amountInUsd * 5e-3;
+    const networkFeeUsd = 2;
+    const totalFeeUsd = swapFeeUsd + networkFeeUsd;
+    const netAmountUsd = amountInUsd - totalFeeUsd;
+    const zecAmount = netAmountUsd / zecPrice;
+    const zecZatoshis = BigInt(Math.floor(zecAmount * 1e8));
+    const slippageBps = slippage ?? this.config.defaultSlippage;
+    const minimumOutput = zecZatoshis * BigInt(1e4 - slippageBps) / 10000n;
+    const swapFee = BigInt(Math.floor(swapFeeUsd / sourcePrice * 10 ** sourceDecimals));
+    const networkFee = BigInt(Math.floor(networkFeeUsd / sourcePrice * 10 ** sourceDecimals));
+    const quoteId = `zec_quote_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    const validUntil = Math.floor(Date.now() / 1e3) + this.config.quoteValiditySeconds;
+    const quote = {
+      quoteId,
+      sourceChain,
+      sourceToken,
+      amountIn: amount,
+      amountInFormatted: this.formatAmount(amount, sourceDecimals),
+      amountOut: zecZatoshis,
+      amountOutFormatted: this.formatAmount(zecZatoshis, 8),
+      exchangeRate: zecPrice / sourcePrice,
+      networkFee,
+      swapFee,
+      totalFee: networkFee + swapFee,
+      slippage: slippageBps,
+      minimumOutput,
+      validUntil,
+      depositAddress: this.generateMockDepositAddress(sourceChain),
+      estimatedTime: this.getEstimatedTime(sourceChain),
+      privacyLevel: PrivacyLevel4.SHIELDED
+    };
+    this.quotes.set(quoteId, quote);
+    return quote;
+  }
+  /**
+   * Get quote in production mode (uses bridge provider)
+   */
+  async getProductionQuote(params) {
+    if (!this.bridgeProvider) {
+      throw new IntentError(
+        "Bridge provider not configured for production mode",
+        "SIP_5004" /* INTENT_INVALID_STATE */
+      );
+    }
+    const bridgeQuote = await this.bridgeProvider.getQuote({
+      sourceChain: params.sourceChain,
+      sourceToken: params.sourceToken,
+      amount: params.amount,
+      recipientAddress: params.recipientZAddress
+    });
+    const sourceDecimals = TOKEN_DECIMALS[params.sourceToken] ?? 18;
+    const slippageBps = params.slippage ?? this.config.defaultSlippage;
+    const minimumOutput = bridgeQuote.amountOut * BigInt(1e4 - slippageBps) / 10000n;
+    const quote = {
+      quoteId: bridgeQuote.quoteId,
+      sourceChain: params.sourceChain,
+      sourceToken: params.sourceToken,
+      amountIn: bridgeQuote.amountIn,
+      amountInFormatted: this.formatAmount(bridgeQuote.amountIn, sourceDecimals),
+      amountOut: bridgeQuote.amountOut,
+      amountOutFormatted: this.formatAmount(bridgeQuote.amountOut, 8),
+      exchangeRate: bridgeQuote.exchangeRate,
+      networkFee: 0n,
+      // Included in bridge fee
+      swapFee: bridgeQuote.fee,
+      totalFee: bridgeQuote.fee,
+      slippage: slippageBps,
+      minimumOutput,
+      validUntil: bridgeQuote.validUntil,
+      depositAddress: "",
+      // Will be set by bridge
+      estimatedTime: this.getEstimatedTime(params.sourceChain),
+      privacyLevel: PrivacyLevel4.SHIELDED
+    };
+    this.quotes.set(quote.quoteId, quote);
+    return quote;
+  }
+  // ─── Swap Execution ──────────────────────────────────────────────────────────
+  /**
+   * Execute a swap to Zcash shielded pool
+   */
+  async executeSwapToShielded(params) {
+    let quote;
+    if (params.quoteId) {
+      quote = this.quotes.get(params.quoteId);
+      if (!quote) {
+        throw new ValidationError(
+          "Quote not found or expired",
+          "quoteId",
+          { received: params.quoteId },
+          "SIP_2000" /* VALIDATION_FAILED */
+        );
+      }
+    }
+    if (!quote) {
+      quote = await this.getQuote({
+        sourceChain: params.sourceChain,
+        sourceToken: params.sourceToken,
+        amount: params.amount,
+        recipientZAddress: params.recipientZAddress,
+        slippage: params.slippage
+      });
+    }
+    if (quote.validUntil < Math.floor(Date.now() / 1e3)) {
+      throw new IntentError(
+        "Quote has expired",
+        "SIP_5001" /* INTENT_EXPIRED */,
+        { context: { quoteId: quote.quoteId, validUntil: quote.validUntil } }
+      );
+    }
+    const requestId = `zec_swap_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    const result = {
+      requestId,
+      quoteId: quote.quoteId,
+      status: "pending_deposit",
+      amountIn: params.amount,
+      recipientZAddress: params.recipientZAddress,
+      timestamp: Math.floor(Date.now() / 1e3)
+    };
+    this.swaps.set(requestId, result);
+    if (this.config.mode === "production" && this.bridgeProvider) {
+      return this.executeProductionSwap(result, quote, params);
+    }
+    return this.executeDemoSwap(result, quote, params);
+  }
+  /**
+   * Execute swap in demo mode
+   */
+  async executeDemoSwap(result, quote, params) {
+    result.status = "deposit_confirmed";
+    result.sourceTxHash = `0x${this.randomHex(64)}`;
+    this.swaps.set(result.requestId, { ...result });
+    await this.delay(100);
+    result.status = "swapping";
+    this.swaps.set(result.requestId, { ...result });
+    await this.delay(100);
+    result.status = "sending_zec";
+    this.swaps.set(result.requestId, { ...result });
+    if (this.zcashService) {
+      try {
+        const zecAmount = Number(quote.amountOut) / 1e8;
+        const sendResult = await this.zcashService.sendShielded({
+          to: params.recipientZAddress,
+          amount: zecAmount,
+          memo: params.memo ?? `SIP Swap: ${params.sourceToken} \u2192 ZEC`
+        });
+        result.status = "completed";
+        result.zcashTxId = sendResult.txid;
+        result.amountOut = quote.amountOut;
+      } catch (error) {
+        result.status = "completed";
+        result.zcashTxId = this.randomHex(64);
+        result.amountOut = quote.amountOut;
+      }
+    } else {
+      result.status = "completed";
+      result.zcashTxId = this.randomHex(64);
+      result.amountOut = quote.amountOut;
+    }
+    this.swaps.set(result.requestId, { ...result });
+    return result;
+  }
+  /**
+   * Execute swap in production mode
+   */
+  async executeProductionSwap(result, quote, params) {
+    if (!this.bridgeProvider) {
+      throw new IntentError(
+        "Bridge provider not configured",
+        "SIP_5004" /* INTENT_INVALID_STATE */
+      );
+    }
+    try {
+      const bridgeResult = await this.bridgeProvider.executeSwap({
+        sourceChain: params.sourceChain,
+        sourceToken: params.sourceToken,
+        amount: params.amount,
+        recipientAddress: params.recipientZAddress,
+        quoteId: quote.quoteId,
+        depositAddress: quote.depositAddress
+      });
+      result.sourceTxHash = bridgeResult.txHash;
+      result.status = bridgeResult.status === "completed" ? "completed" : "swapping";
+      if (bridgeResult.amountReceived) {
+        result.amountOut = bridgeResult.amountReceived;
+      }
+    } catch (error) {
+      result.status = "failed";
+      result.error = error instanceof Error ? error.message : "Bridge execution failed";
+    }
+    this.swaps.set(result.requestId, { ...result });
+    return result;
+  }
+  // ─── Status Methods ──────────────────────────────────────────────────────────
+  /**
+   * Get swap status
+   */
+  async getSwapStatus(requestId) {
+    return this.swaps.get(requestId) ?? null;
+  }
+  /**
+   * Wait for swap completion
+   */
+  async waitForCompletion(requestId, timeout = 3e5, pollInterval = 5e3) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const status = await this.getSwapStatus(requestId);
+      if (!status) {
+        throw new IntentError(
+          "Swap not found",
+          "SIP_5003" /* INTENT_NOT_FOUND */,
+          { context: { requestId } }
+        );
+      }
+      if (status.status === "completed") {
+        return status;
+      }
+      if (status.status === "failed" || status.status === "expired") {
+        throw new IntentError(
+          `Swap ${status.status}: ${status.error ?? "Unknown error"}`,
+          "SIP_5000" /* INTENT_FAILED */,
+          { context: { requestId, status } }
+        );
+      }
+      await this.delay(pollInterval);
+    }
+    throw new NetworkError(
+      "Swap completion timeout",
+      "SIP_6001" /* NETWORK_TIMEOUT */,
+      { context: { requestId, timeout } }
+    );
+  }
+  // ─── Utility Methods ─────────────────────────────────────────────────────────
+  /**
+   * Get supported source chains
+   */
+  async getSupportedChains() {
+    if (this.bridgeProvider) {
+      return this.bridgeProvider.getSupportedChains();
+    }
+    return ["ethereum", "solana", "near", "polygon", "arbitrum", "base"];
+  }
+  /**
+   * Get supported source tokens for a chain
+   */
+  getSupportedTokens(chain) {
+    const tokensByChain = {
+      ethereum: ["ETH", "USDC", "USDT"],
+      solana: ["SOL", "USDC", "USDT"],
+      near: ["NEAR", "USDC", "USDT"],
+      polygon: ["MATIC", "USDC", "USDT"],
+      arbitrum: ["ETH", "USDC", "USDT"],
+      base: ["ETH", "USDC"]
+    };
+    return tokensByChain[chain] ?? [];
+  }
+  /**
+   * Check if a swap route is supported
+   */
+  isRouteSupported(chain, token) {
+    return this.getSupportedTokens(chain).includes(token);
+  }
+  // ─── Private Helpers ─────────────────────────────────────────────────────────
+  validateQuoteParams(params) {
+    if (!params.sourceChain) {
+      throw new ValidationError("Source chain is required", "sourceChain", void 0, "SIP_2000" /* VALIDATION_FAILED */);
+    }
+    if (!params.sourceToken) {
+      throw new ValidationError("Source token is required", "sourceToken", void 0, "SIP_2000" /* VALIDATION_FAILED */);
+    }
+    if (!params.amount || params.amount <= 0n) {
+      throw new ValidationError("Amount must be positive", "amount", { received: params.amount }, "SIP_2004" /* INVALID_AMOUNT */);
+    }
+    if (!params.recipientZAddress) {
+      throw new ValidationError("Recipient z-address is required", "recipientZAddress", void 0, "SIP_2000" /* VALIDATION_FAILED */);
+    }
+    if (!this.isRouteSupported(params.sourceChain, params.sourceToken)) {
+      throw new ValidationError(
+        `Unsupported swap route: ${params.sourceChain}:${params.sourceToken} \u2192 ZEC`,
+        "sourceToken",
+        { chain: params.sourceChain, token: params.sourceToken },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+  }
+  isValidZAddressFormat(address) {
+    return address.startsWith("zs1") || address.startsWith("u1") || address.startsWith("ztestsapling") || address.startsWith("utest");
+  }
+  generateMockDepositAddress(chain) {
+    switch (chain) {
+      case "ethereum":
+      case "polygon":
+      case "arbitrum":
+      case "base":
+        return `0x${this.randomHex(40)}`;
+      case "solana":
+        return this.randomBase58(44);
+      case "near":
+        return `deposit_${this.randomHex(8)}.near`;
+      default:
+        return `0x${this.randomHex(40)}`;
+    }
+  }
+  getEstimatedTime(chain) {
+    const times = {
+      ethereum: 900,
+      // ~15 min (confirmations + processing)
+      solana: 300,
+      // ~5 min
+      near: 300,
+      // ~5 min
+      polygon: 600,
+      // ~10 min
+      arbitrum: 600,
+      // ~10 min
+      base: 600
+      // ~10 min
+    };
+    return times[chain] ?? 600;
+  }
+  formatAmount(amount, decimals) {
+    const divisor = 10 ** decimals;
+    const whole = amount / BigInt(divisor);
+    const fraction = amount % BigInt(divisor);
+    const fractionStr = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+    return fractionStr ? `${whole}.${fractionStr}` : whole.toString();
+  }
+  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 createZcashSwapService(config) {
+  return new ZcashSwapService(config);
+}
+
 // src/zcash/index.ts
 import { ZcashErrorCode as ZcashErrorCode2 } from "@sip-protocol/types";
 
@@ -4405,7 +5109,7 @@ import { ZcashErrorCode as ZcashErrorCode3 } from "@sip-protocol/types";
 // src/payment/payment.ts
 import {
   SIP_VERSION as SIP_VERSION2,
-  PrivacyLevel as PrivacyLevel4,
+  PrivacyLevel as PrivacyLevel5,
   PaymentStatus
 } from "@sip-protocol/types";
 import { sha256 as sha2569 } from "@noble/hashes/sha256";
@@ -4594,7 +5298,7 @@ var PaymentBuilder = class {
   _amount;
   _recipientMetaAddress;
   _recipientAddress;
-  _privacy = PrivacyLevel4.SHIELDED;
+  _privacy = PrivacyLevel5.SHIELDED;
   _viewingKey;
   _sourceChain;
   _destinationChain;
@@ -4877,7 +5581,7 @@ async function createShieldedPayment(params, options) {
   } else {
     resolvedToken = token;
   }
-  if (privacy !== PrivacyLevel4.TRANSPARENT && !recipientMetaAddress) {
+  if (privacy !== PrivacyLevel5.TRANSPARENT && !recipientMetaAddress) {
     throw new ValidationError(
       "recipientMetaAddress is required for shielded/compliant privacy modes",
       "recipientMetaAddress",
@@ -4885,7 +5589,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === PrivacyLevel4.TRANSPARENT && !recipientAddress) {
+  if (privacy === PrivacyLevel5.TRANSPARENT && !recipientAddress) {
     throw new ValidationError(
       "recipientAddress is required for transparent mode",
       "recipientAddress",
@@ -4893,7 +5597,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === PrivacyLevel4.COMPLIANT && !viewingKey) {
+  if (privacy === PrivacyLevel5.COMPLIANT && !viewingKey) {
     throw new ValidationError(
       "viewingKey is required for compliant mode",
       "viewingKey",
@@ -4926,7 +5630,7 @@ async function createShieldedPayment(params, options) {
     purpose,
     viewingKeyHash
   };
-  if (privacy !== PrivacyLevel4.TRANSPARENT && recipientMetaAddress) {
+  if (privacy !== PrivacyLevel5.TRANSPARENT && recipientMetaAddress) {
     const metaAddress = decodeStealthMetaAddress(recipientMetaAddress);
     const { stealthAddress } = generateStealthAddress(metaAddress);
     payment.recipientStealth = stealthAddress;
@@ -4943,7 +5647,7 @@ async function createShieldedPayment(params, options) {
     payment.recipientAddress = recipientAddress;
     payment.memo = memo;
   }
-  if (privacy !== PrivacyLevel4.TRANSPARENT && proofProvider?.isReady) {
+  if (privacy !== PrivacyLevel5.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
       return hexToBytes8(cleanHex);
@@ -5044,7 +5748,7 @@ function getPaymentSummary(payment) {
 // src/treasury/treasury.ts
 import {
   ProposalStatus,
-  PrivacyLevel as PrivacyLevel5
+  PrivacyLevel as PrivacyLevel6
 } from "@sip-protocol/types";
 import { secp256k1 as secp256k13 } from "@noble/curves/secp256k1";
 import { sha256 as sha25610 } from "@noble/hashes/sha256";
@@ -5078,7 +5782,7 @@ var Treasury = class _Treasury {
         ...m,
         addedAt: now
       })),
-      defaultPrivacy: params.defaultPrivacy ?? PrivacyLevel5.SHIELDED,
+      defaultPrivacy: params.defaultPrivacy ?? PrivacyLevel6.SHIELDED,
       masterViewingKey,
       dailyLimit: params.dailyLimit,
       transactionLimit: params.transactionLimit,
@@ -5329,8 +6033,8 @@ var Treasury = class _Treasury {
       const payment = await createShieldedPayment({
         token: proposal.payment.token,
         amount: proposal.payment.amount,
-        recipientMetaAddress: proposal.payment.privacy !== PrivacyLevel5.TRANSPARENT ? proposal.payment.recipient : void 0,
-        recipientAddress: proposal.payment.privacy === PrivacyLevel5.TRANSPARENT ? proposal.payment.recipient : void 0,
+        recipientMetaAddress: proposal.payment.privacy !== PrivacyLevel6.TRANSPARENT ? proposal.payment.recipient : void 0,
+        recipientAddress: proposal.payment.privacy === PrivacyLevel6.TRANSPARENT ? proposal.payment.recipient : void 0,
         privacy: proposal.payment.privacy,
         viewingKey: this.config.masterViewingKey?.key,
         sourceChain: this.config.chain,
@@ -5343,8 +6047,8 @@ var Treasury = class _Treasury {
         const payment = await createShieldedPayment({
           token: proposal.batchPayment.token,
           amount: recipient.amount,
-          recipientMetaAddress: proposal.batchPayment.privacy !== PrivacyLevel5.TRANSPARENT ? recipient.address : void 0,
-          recipientAddress: proposal.batchPayment.privacy === PrivacyLevel5.TRANSPARENT ? recipient.address : void 0,
+          recipientMetaAddress: proposal.batchPayment.privacy !== PrivacyLevel6.TRANSPARENT ? recipient.address : void 0,
+          recipientAddress: proposal.batchPayment.privacy === PrivacyLevel6.TRANSPARENT ? recipient.address : void 0,
           privacy: proposal.batchPayment.privacy,
           viewingKey: this.config.masterViewingKey?.key,
           sourceChain: this.config.chain,
@@ -10182,6 +10886,16 @@ export {
   createSIP,
   createProductionSIP,
   MockProofProvider,
+  detectMobilePlatform,
+  detectMobileBrowser,
+  getBrowserVersion,
+  getOSVersion,
+  isTablet,
+  supportsTouch,
+  getMobileDeviceInfo,
+  supportsWASMSimd,
+  supportsWASMBulkMemory,
+  checkMobileWASMCompatibility,
   hexToBytes5 as hexToBytes,
   bytesToHex7 as bytesToHex,
   isBrowser,
@@ -10214,6 +10928,8 @@ export {
   createZcashClient,
   ZcashShieldedService,
   createZcashShieldedService,
+  ZcashSwapService,
+  createZcashSwapService,
   STABLECOIN_INFO,
   STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS,
@@ -10287,7 +11003,7 @@ export {
   createMockLedgerAdapter,
   createMockTrezorAdapter,
   WalletErrorCode10 as WalletErrorCode,
-  PrivacyLevel7 as PrivacyLevel,
+  PrivacyLevel8 as PrivacyLevel,
   IntentStatus4 as IntentStatus,
   SIP_VERSION3 as SIP_VERSION,
   NATIVE_TOKENS,