@sip-protocol/sdk 0.2.7 → 0.2.9

package/dist/browser.js

@@ -47,7 +47,7 @@ __export(browser_exports, {
   HardwareWalletError: () => HardwareWalletError,
   IntentBuilder: () => IntentBuilder,
   IntentError: () => IntentError,
-  IntentStatus: () => import_types33.IntentStatus,
+  IntentStatus: () => import_types34.IntentStatus,
   LedgerWalletAdapter: () => LedgerWalletAdapter,
   MockEthereumAdapter: () => MockEthereumAdapter,
   MockLedgerAdapter: () => MockLedgerAdapter,
@@ -56,26 +56,26 @@ __export(browser_exports, {
   MockSolver: () => MockSolver,
   MockTrezorAdapter: () => MockTrezorAdapter,
   MockWalletAdapter: () => MockWalletAdapter,
-  NATIVE_TOKENS: () => import_types33.NATIVE_TOKENS,
+  NATIVE_TOKENS: () => import_types34.NATIVE_TOKENS,
   NEARIntentsAdapter: () => NEARIntentsAdapter,
   NetworkError: () => NetworkError,
   ORACLE_DOMAIN: () => ORACLE_DOMAIN,
   OneClickClient: () => OneClickClient,
-  OneClickDepositMode: () => import_types37.OneClickDepositMode,
-  OneClickErrorCode: () => import_types37.OneClickErrorCode,
-  OneClickSwapStatus: () => import_types37.OneClickSwapStatus,
-  OneClickSwapType: () => import_types37.OneClickSwapType,
+  OneClickDepositMode: () => import_types38.OneClickDepositMode,
+  OneClickErrorCode: () => import_types38.OneClickErrorCode,
+  OneClickSwapStatus: () => import_types38.OneClickSwapStatus,
+  OneClickSwapType: () => import_types38.OneClickSwapType,
   PaymentBuilder: () => PaymentBuilder,
-  PaymentStatus: () => import_types34.PaymentStatus,
-  PrivacyLevel: () => import_types33.PrivacyLevel,
+  PaymentStatus: () => import_types35.PaymentStatus,
+  PrivacyLevel: () => import_types34.PrivacyLevel,
   ProofError: () => ProofError,
   ProofGenerationError: () => ProofGenerationError,
   ProofNotImplementedError: () => ProofNotImplementedError,
-  ProposalStatus: () => import_types35.ProposalStatus,
-  ReportStatus: () => import_types36.ReportStatus,
+  ProposalStatus: () => import_types36.ProposalStatus,
+  ReportStatus: () => import_types37.ReportStatus,
   SIP: () => SIP,
   SIPError: () => SIPError,
-  SIP_VERSION: () => import_types33.SIP_VERSION,
+  SIP_VERSION: () => import_types34.SIP_VERSION,
   STABLECOIN_ADDRESSES: () => STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS: () => STABLECOIN_DECIMALS,
   STABLECOIN_INFO: () => STABLECOIN_INFO,
@@ -84,11 +84,12 @@ __export(browser_exports, {
   TrezorWalletAdapter: () => TrezorWalletAdapter,
   ValidationError: () => ValidationError,
   WalletError: () => WalletError,
-  WalletErrorCode: () => import_types32.WalletErrorCode,
-  ZcashErrorCode: () => import_types38.ZcashErrorCode,
+  WalletErrorCode: () => import_types33.WalletErrorCode,
+  ZcashErrorCode: () => import_types39.ZcashErrorCode,
   ZcashRPCClient: () => ZcashRPCClient,
   ZcashRPCError: () => ZcashRPCError,
   ZcashShieldedService: () => ZcashShieldedService,
+  ZcashSwapService: () => ZcashSwapService,
   addBlindings: () => addBlindings,
   addCommitments: () => addCommitments,
   addOracle: () => addOracle,
@@ -123,6 +124,7 @@ __export(browser_exports, {
   createWalletFactory: () => createWalletFactory,
   createZcashClient: () => createZcashClient,
   createZcashShieldedService: () => createZcashShieldedService,
+  createZcashSwapService: () => createZcashSwapService,
   decodeStealthMetaAddress: () => decodeStealthMetaAddress,
   decryptMemo: () => decryptMemo,
   decryptWithViewing: () => decryptWithViewing,
@@ -183,7 +185,7 @@ __export(browser_exports, {
   isExpired: () => isExpired,
   isNonNegativeAmount: () => isNonNegativeAmount,
   isPaymentExpired: () => isPaymentExpired,
-  isPrivate: () => import_types33.isPrivate,
+  isPrivate: () => import_types34.isPrivate,
   isPrivateWalletAdapter: () => isPrivateWalletAdapter,
   isSIPError: () => isSIPError,
   isStablecoin: () => isStablecoin,
@@ -219,7 +221,7 @@ __export(browser_exports, {
   subtractBlindings: () => subtractBlindings,
   subtractCommitments: () => subtractCommitments,
   supportsSharedArrayBuffer: () => supportsSharedArrayBuffer,
-  supportsViewingKey: () => import_types33.supportsViewingKey,
+  supportsViewingKey: () => import_types34.supportsViewingKey,
   supportsWebBluetooth: () => supportsWebBluetooth,
   supportsWebHID: () => supportsWebHID,
   supportsWebUSB: () => supportsWebUSB,
@@ -2457,22 +2459,43 @@ var DEFAULT_ASSET_MAPPINGS = {
   // NEAR assets
   "near:NEAR": "nep141:wrap.near",
   "near:wNEAR": "nep141:wrap.near",
+  "near:USDC": "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
   // Ethereum assets (via OMFT bridge)
   "ethereum:ETH": "nep141:eth.omft.near",
-  "ethereum:USDC": "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
-  "ethereum:USDT": "nep141:usdt.tether-token.near",
+  "ethereum:USDC": "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near",
+  "ethereum:USDT": "nep141:eth-0xdac17f958d2ee523a2206206994597c13d831ec7.omft.near",
   // Solana assets (via OMFT bridge)
   "solana:SOL": "nep141:sol.omft.near",
+  "solana:USDC": "nep141:sol-5ce3bf3a31af18be40ba30f721101b4341690186.omft.near",
+  "solana:USDT": "nep141:sol-c800a4bd850783ccb82c2b2c7e84175443606352.omft.near",
   // Zcash assets
   "zcash:ZEC": "nep141:zec.omft.near",
   // Arbitrum assets
   "arbitrum:ETH": "nep141:arb.omft.near",
+  "arbitrum:ARB": "nep141:arb-0x912ce59144191c1204e64559fe8253a0e49e6548.omft.near",
+  "arbitrum:USDC": "nep141:arb-0xaf88d065e77c8cc2239327c5edb3a432268e5831.omft.near",
   // Base assets
   "base:ETH": "nep141:base.omft.near",
-  // Polygon assets (support both MATIC and POL symbols)
-  "polygon:MATIC": "nep141:matic.omft.near",
-  "polygon:POL": "nep141:matic.omft.near"
+  "base:USDC": "nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near",
+  // Optimism assets (via HOT bridge - uses nep245)
+  "optimism:ETH": "nep245:v2_1.omni.hot.tg:10_11111111111111111111",
+  "optimism:OP": "nep245:v2_1.omni.hot.tg:10_vLAiSt9KfUGKpw5cD3vsSyNYBo7",
+  "optimism:USDC": "nep245:v2_1.omni.hot.tg:10_A2ewyUyDp6qsue1jqZsGypkCxRJ",
+  // Polygon assets (via HOT bridge - uses nep245)
+  "polygon:POL": "nep245:v2_1.omni.hot.tg:137_11111111111111111111",
+  "polygon:MATIC": "nep245:v2_1.omni.hot.tg:137_11111111111111111111",
   // POL is the rebranded MATIC
+  "polygon:USDC": "nep245:v2_1.omni.hot.tg:137_qiStmoQJDQPTebaPjgx5VBxZv6L",
+  // BNB Chain assets (via HOT bridge - uses nep245)
+  "bsc:BNB": "nep245:v2_1.omni.hot.tg:56_11111111111111111111",
+  "bsc:USDC": "nep245:v2_1.omni.hot.tg:56_2w93GqMcEmQFDru84j3HZZWt557r",
+  // Avalanche assets (via HOT bridge - uses nep245)
+  "avalanche:AVAX": "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
+  "avalanche:USDC": "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
+  // Bitcoin
+  "bitcoin:BTC": "nep141:btc.omft.near",
+  // Aptos
+  "aptos:APT": "nep141:aptos.omft.near"
 };
 var CHAIN_BLOCKCHAIN_MAP = {
   near: "near",
@@ -3752,10 +3775,10 @@ function hasEnoughOracles(registry) {
 }
 
 // src/index.ts
-var import_types33 = require("@sip-protocol/types");
 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");
 
 // src/solver/mock-solver.ts
 var import_types7 = require("@sip-protocol/types");
@@ -3940,7 +3963,7 @@ function createMockSolver(config) {
 }
 
 // src/index.ts
-var import_types37 = require("@sip-protocol/types");
+var import_types38 = require("@sip-protocol/types");
 
 // src/zcash/rpc-client.ts
 var import_types8 = require("@sip-protocol/types");
@@ -4784,14 +4807,444 @@ function createZcashShieldedService(config) {
   return new ZcashShieldedService(config);
 }
 
-// src/zcash/index.ts
+// src/zcash/swap-service.ts
 var import_types10 = require("@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: import_types10.PrivacyLevel.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: import_types10.PrivacyLevel.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
+var import_types11 = require("@sip-protocol/types");
 
 // src/index.ts
-var import_types38 = require("@sip-protocol/types");
+var import_types39 = require("@sip-protocol/types");
 
 // src/payment/payment.ts
-var import_types11 = require("@sip-protocol/types");
+var import_types12 = require("@sip-protocol/types");
 var import_sha2569 = require("@noble/hashes/sha256");
 var import_utils11 = require("@noble/hashes/utils");
 var import_chacha2 = require("@noble/ciphers/chacha.js");
@@ -4978,7 +5431,7 @@ var PaymentBuilder = class {
   _amount;
   _recipientMetaAddress;
   _recipientAddress;
-  _privacy = import_types11.PrivacyLevel.SHIELDED;
+  _privacy = import_types12.PrivacyLevel.SHIELDED;
   _viewingKey;
   _sourceChain;
   _destinationChain;
@@ -5261,7 +5714,7 @@ async function createShieldedPayment(params, options) {
   } else {
     resolvedToken = token;
   }
-  if (privacy !== import_types11.PrivacyLevel.TRANSPARENT && !recipientMetaAddress) {
+  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && !recipientMetaAddress) {
     throw new ValidationError(
       "recipientMetaAddress is required for shielded/compliant privacy modes",
       "recipientMetaAddress",
@@ -5269,7 +5722,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === import_types11.PrivacyLevel.TRANSPARENT && !recipientAddress) {
+  if (privacy === import_types12.PrivacyLevel.TRANSPARENT && !recipientAddress) {
     throw new ValidationError(
       "recipientAddress is required for transparent mode",
       "recipientAddress",
@@ -5277,7 +5730,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === import_types11.PrivacyLevel.COMPLIANT && !viewingKey) {
+  if (privacy === import_types12.PrivacyLevel.COMPLIANT && !viewingKey) {
     throw new ValidationError(
       "viewingKey is required for compliant mode",
       "viewingKey",
@@ -5299,7 +5752,7 @@ async function createShieldedPayment(params, options) {
   const now = Math.floor(Date.now() / 1e3);
   const payment = {
     paymentId,
-    version: import_types11.SIP_VERSION,
+    version: import_types12.SIP_VERSION,
     privacyLevel: privacy,
     createdAt: now,
     expiry: now + ttl,
@@ -5310,7 +5763,7 @@ async function createShieldedPayment(params, options) {
     purpose,
     viewingKeyHash
   };
-  if (privacy !== import_types11.PrivacyLevel.TRANSPARENT && recipientMetaAddress) {
+  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && recipientMetaAddress) {
     const metaAddress = decodeStealthMetaAddress(recipientMetaAddress);
     const { stealthAddress } = generateStealthAddress(metaAddress);
     payment.recipientStealth = stealthAddress;
@@ -5327,7 +5780,7 @@ async function createShieldedPayment(params, options) {
     payment.recipientAddress = recipientAddress;
     payment.memo = memo;
   }
-  if (privacy !== import_types11.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
+  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
       return (0, import_utils11.hexToBytes)(cleanHex);
@@ -5393,7 +5846,7 @@ function decryptMemo(encryptedMemo, viewingKey) {
 function trackPayment(payment) {
   return {
     ...payment,
-    status: import_types11.PaymentStatus.DRAFT
+    status: import_types12.PaymentStatus.DRAFT
   };
 }
 function isPaymentExpired(payment) {
@@ -5426,7 +5879,7 @@ function getPaymentSummary(payment) {
 }
 
 // src/treasury/treasury.ts
-var import_types12 = require("@sip-protocol/types");
+var import_types13 = 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");
@@ -5459,7 +5912,7 @@ var Treasury = class _Treasury {
         ...m,
         addedAt: now
       })),
-      defaultPrivacy: params.defaultPrivacy ?? import_types12.PrivacyLevel.SHIELDED,
+      defaultPrivacy: params.defaultPrivacy ?? import_types13.PrivacyLevel.SHIELDED,
       masterViewingKey,
       dailyLimit: params.dailyLimit,
       transactionLimit: params.transactionLimit,
@@ -5538,7 +5991,7 @@ var Treasury = class _Treasury {
       proposalId,
       treasuryId: this.config.treasuryId,
       type: "payment",
-      status: import_types12.ProposalStatus.PENDING,
+      status: import_types13.ProposalStatus.PENDING,
       proposer: "",
       // Should be set by caller
       title: params.title,
@@ -5571,7 +6024,7 @@ var Treasury = class _Treasury {
       proposalId,
       treasuryId: this.config.treasuryId,
       type: "batch_payment",
-      status: import_types12.ProposalStatus.PENDING,
+      status: import_types13.ProposalStatus.PENDING,
       proposer: "",
       title: params.title,
       description: params.description,
@@ -5605,7 +6058,7 @@ var Treasury = class _Treasury {
    * Get pending proposals
    */
   getPendingProposals() {
-    return this.getAllProposals().filter((p) => p.status === import_types12.ProposalStatus.PENDING);
+    return this.getAllProposals().filter((p) => p.status === import_types13.ProposalStatus.PENDING);
   }
   /**
    * Sign a proposal
@@ -5636,7 +6089,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types12.ProposalStatus.PENDING) {
+    if (proposal.status !== import_types13.ProposalStatus.PENDING) {
       throw new ValidationError(
         `proposal is not pending: ${proposal.status}`,
         "proposalId",
@@ -5646,7 +6099,7 @@ var Treasury = class _Treasury {
     }
     const now = Math.floor(Date.now() / 1e3);
     if (now > proposal.expiresAt) {
-      proposal.status = import_types12.ProposalStatus.EXPIRED;
+      proposal.status = import_types13.ProposalStatus.EXPIRED;
       throw new ValidationError(
         "proposal has expired",
         "proposalId",
@@ -5678,9 +6131,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_types12.ProposalStatus.APPROVED;
+      proposal.status = import_types13.ProposalStatus.APPROVED;
     } else if (rejections > this.config.totalSigners - proposal.requiredSignatures) {
-      proposal.status = import_types12.ProposalStatus.REJECTED;
+      proposal.status = import_types13.ProposalStatus.REJECTED;
     }
     return proposal;
   }
@@ -5697,7 +6150,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types12.ProposalStatus.APPROVED) {
+    if (proposal.status !== import_types13.ProposalStatus.APPROVED) {
       throw new ValidationError(
         `proposal is not approved: ${proposal.status}`,
         "proposalId",
@@ -5710,8 +6163,8 @@ var Treasury = class _Treasury {
       const payment = await createShieldedPayment({
         token: proposal.payment.token,
         amount: proposal.payment.amount,
-        recipientMetaAddress: proposal.payment.privacy !== import_types12.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
-        recipientAddress: proposal.payment.privacy === import_types12.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
+        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,
         privacy: proposal.payment.privacy,
         viewingKey: this.config.masterViewingKey?.key,
         sourceChain: this.config.chain,
@@ -5724,8 +6177,8 @@ var Treasury = class _Treasury {
         const payment = await createShieldedPayment({
           token: proposal.batchPayment.token,
           amount: recipient.amount,
-          recipientMetaAddress: proposal.batchPayment.privacy !== import_types12.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
-          recipientAddress: proposal.batchPayment.privacy === import_types12.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
+          recipientMetaAddress: proposal.batchPayment.privacy !== import_types13.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
+          recipientAddress: proposal.batchPayment.privacy === import_types13.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
           privacy: proposal.batchPayment.privacy,
           viewingKey: this.config.masterViewingKey?.key,
           sourceChain: this.config.chain,
@@ -5735,7 +6188,7 @@ var Treasury = class _Treasury {
         payments.push(payment);
       }
     }
-    proposal.status = import_types12.ProposalStatus.EXECUTED;
+    proposal.status = import_types13.ProposalStatus.EXECUTED;
     proposal.executedAt = Math.floor(Date.now() / 1e3);
     proposal.resultPayments = payments;
     return payments;
@@ -5764,7 +6217,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types12.ProposalStatus.PENDING) {
+    if (proposal.status !== import_types13.ProposalStatus.PENDING) {
       throw new ValidationError(
         `proposal is not pending: ${proposal.status}`,
         "proposalId",
@@ -5772,7 +6225,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    proposal.status = import_types12.ProposalStatus.CANCELLED;
+    proposal.status = import_types13.ProposalStatus.CANCELLED;
     return proposal;
   }
   // ─── Auditor Access ──────────────────────────────────────────────────────────
@@ -5869,7 +6322,7 @@ var Treasury = class _Treasury {
   getCommittedAmount(token) {
     let committed = 0n;
     for (const proposal of this.proposals.values()) {
-      if (proposal.status !== import_types12.ProposalStatus.PENDING) continue;
+      if (proposal.status !== import_types13.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;
@@ -6112,7 +6565,7 @@ function validateBatchProposalParams(params, config) {
 }
 
 // src/compliance/compliance-manager.ts
-var import_types13 = require("@sip-protocol/types");
+var import_types14 = require("@sip-protocol/types");
 var import_utils13 = require("@noble/hashes/utils");
 var DEFAULTS2 = {
   riskThreshold: 70,
@@ -6480,7 +6933,7 @@ var ComplianceManager = class _ComplianceManager {
       title: params.title,
       description: params.description,
       format: params.format,
-      status: import_types13.ReportStatus.GENERATING,
+      status: import_types14.ReportStatus.GENERATING,
       requestedBy,
       requestedAt: now,
       startDate: params.startDate,
@@ -6509,10 +6962,10 @@ var ComplianceManager = class _ComplianceManager {
       } else if (params.format === "csv") {
         report.content = this.generateCSV(transactions);
       }
-      report.status = import_types13.ReportStatus.COMPLETED;
+      report.status = import_types14.ReportStatus.COMPLETED;
       report.generatedAt = Math.floor(Date.now() / 1e3);
     } catch (error) {
-      report.status = import_types13.ReportStatus.FAILED;
+      report.status = import_types14.ReportStatus.FAILED;
       report.error = error instanceof Error ? error.message : "Unknown error";
     }
     this.addAuditLog(requestedBy, "report_generated", {
@@ -6875,10 +7328,10 @@ function validateReportParams(params) {
 }
 
 // src/wallet/errors.ts
-var import_types14 = require("@sip-protocol/types");
+var import_types15 = require("@sip-protocol/types");
 var WalletError = class extends SIPError {
   walletCode;
-  constructor(message, walletCode = import_types14.WalletErrorCode.UNKNOWN, options) {
+  constructor(message, walletCode = import_types15.WalletErrorCode.UNKNOWN, options) {
     super(message, "SIP_7000" /* WALLET_ERROR */, options);
     this.walletCode = walletCode;
     this.name = "WalletError";
@@ -6888,10 +7341,10 @@ var WalletError = class extends SIPError {
    */
   isConnectionError() {
     const codes = [
-      import_types14.WalletErrorCode.NOT_INSTALLED,
-      import_types14.WalletErrorCode.CONNECTION_REJECTED,
-      import_types14.WalletErrorCode.CONNECTION_FAILED,
-      import_types14.WalletErrorCode.NOT_CONNECTED
+      import_types15.WalletErrorCode.NOT_INSTALLED,
+      import_types15.WalletErrorCode.CONNECTION_REJECTED,
+      import_types15.WalletErrorCode.CONNECTION_FAILED,
+      import_types15.WalletErrorCode.NOT_CONNECTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -6900,9 +7353,9 @@ var WalletError = class extends SIPError {
    */
   isSigningError() {
     const codes = [
-      import_types14.WalletErrorCode.SIGNING_REJECTED,
-      import_types14.WalletErrorCode.SIGNING_FAILED,
-      import_types14.WalletErrorCode.INVALID_MESSAGE
+      import_types15.WalletErrorCode.SIGNING_REJECTED,
+      import_types15.WalletErrorCode.SIGNING_FAILED,
+      import_types15.WalletErrorCode.INVALID_MESSAGE
     ];
     return codes.includes(this.walletCode);
   }
@@ -6911,10 +7364,10 @@ var WalletError = class extends SIPError {
    */
   isTransactionError() {
     const codes = [
-      import_types14.WalletErrorCode.INSUFFICIENT_FUNDS,
-      import_types14.WalletErrorCode.TRANSACTION_REJECTED,
-      import_types14.WalletErrorCode.TRANSACTION_FAILED,
-      import_types14.WalletErrorCode.INVALID_TRANSACTION
+      import_types15.WalletErrorCode.INSUFFICIENT_FUNDS,
+      import_types15.WalletErrorCode.TRANSACTION_REJECTED,
+      import_types15.WalletErrorCode.TRANSACTION_FAILED,
+      import_types15.WalletErrorCode.INVALID_TRANSACTION
     ];
     return codes.includes(this.walletCode);
   }
@@ -6923,9 +7376,9 @@ var WalletError = class extends SIPError {
    */
   isPrivacyError() {
     const codes = [
-      import_types14.WalletErrorCode.STEALTH_NOT_SUPPORTED,
-      import_types14.WalletErrorCode.VIEWING_KEY_NOT_SUPPORTED,
-      import_types14.WalletErrorCode.SHIELDED_NOT_SUPPORTED
+      import_types15.WalletErrorCode.STEALTH_NOT_SUPPORTED,
+      import_types15.WalletErrorCode.VIEWING_KEY_NOT_SUPPORTED,
+      import_types15.WalletErrorCode.SHIELDED_NOT_SUPPORTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -6934,10 +7387,10 @@ var WalletError = class extends SIPError {
    */
   isUserRejection() {
     const codes = [
-      import_types14.WalletErrorCode.CONNECTION_REJECTED,
-      import_types14.WalletErrorCode.SIGNING_REJECTED,
-      import_types14.WalletErrorCode.TRANSACTION_REJECTED,
-      import_types14.WalletErrorCode.CHAIN_SWITCH_REJECTED
+      import_types15.WalletErrorCode.CONNECTION_REJECTED,
+      import_types15.WalletErrorCode.SIGNING_REJECTED,
+      import_types15.WalletErrorCode.TRANSACTION_REJECTED,
+      import_types15.WalletErrorCode.CHAIN_SWITCH_REJECTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -6945,15 +7398,15 @@ var WalletError = class extends SIPError {
 function notConnectedError() {
   return new WalletError(
     "Wallet not connected. Call connect() first.",
-    import_types14.WalletErrorCode.NOT_CONNECTED
+    import_types15.WalletErrorCode.NOT_CONNECTED
   );
 }
-function featureNotSupportedError(feature, code = import_types14.WalletErrorCode.UNKNOWN) {
+function featureNotSupportedError(feature, code = import_types15.WalletErrorCode.UNKNOWN) {
   return new WalletError(`${feature} is not supported by this wallet`, code);
 }
 
 // src/wallet/base-adapter.ts
-var import_types15 = require("@sip-protocol/types");
+var import_types16 = require("@sip-protocol/types");
 var BaseWalletAdapter = class {
   _address = "";
   _publicKey = "";
@@ -7116,12 +7569,12 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
     this._connectionState = "connecting";
     if (this.shouldFailConnect) {
       this.setError(
-        import_types15.WalletErrorCode.CONNECTION_FAILED,
+        import_types16.WalletErrorCode.CONNECTION_FAILED,
         "Mock connection failure"
       );
       throw new WalletError(
         "Mock connection failure",
-        import_types15.WalletErrorCode.CONNECTION_FAILED
+        import_types16.WalletErrorCode.CONNECTION_FAILED
       );
     }
     await new Promise((resolve) => setTimeout(resolve, 10));
@@ -7133,7 +7586,7 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
   async signMessage(message) {
     this.requireConnected();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types15.WalletErrorCode.SIGNING_FAILED);
+      throw new WalletError("Mock signing failure", import_types16.WalletErrorCode.SIGNING_FAILED);
     }
     const mockSig = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
@@ -7148,7 +7601,7 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
   async signTransaction(tx) {
     this.requireConnected();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types15.WalletErrorCode.SIGNING_FAILED);
+      throw new WalletError("Mock signing failure", import_types16.WalletErrorCode.SIGNING_FAILED);
     }
     const signature = await this.signMessage(
       new TextEncoder().encode(JSON.stringify(tx.data))
@@ -7330,7 +7783,7 @@ function isPrivateWalletAdapter(adapter) {
 }
 
 // src/wallet/solana/adapter.ts
-var import_types16 = require("@sip-protocol/types");
+var import_types17 = require("@sip-protocol/types");
 
 // src/wallet/solana/types.ts
 function getSolanaProvider(wallet = "phantom") {
@@ -7451,19 +7904,19 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
       }
       if (!this.provider) {
         this.setError(
-          import_types16.WalletErrorCode.NOT_INSTALLED,
+          import_types17.WalletErrorCode.NOT_INSTALLED,
           `${this.walletName} wallet is not installed`
         );
         throw new WalletError(
           `${this.walletName} wallet is not installed`,
-          import_types16.WalletErrorCode.NOT_INSTALLED
+          import_types17.WalletErrorCode.NOT_INSTALLED
         );
       }
       const { publicKey } = await this.provider.connect();
       if (!publicKey) {
         throw new WalletError(
           "No public key returned from wallet",
-          import_types16.WalletErrorCode.CONNECTION_FAILED
+          import_types17.WalletErrorCode.CONNECTION_FAILED
         );
       }
       this.setupEventHandlers();
@@ -7473,11 +7926,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_types16.WalletErrorCode.CONNECTION_REJECTED, message);
-        throw new WalletError(message, import_types16.WalletErrorCode.CONNECTION_REJECTED);
+        this.setError(import_types17.WalletErrorCode.CONNECTION_REJECTED, message);
+        throw new WalletError(message, import_types17.WalletErrorCode.CONNECTION_REJECTED);
       }
-      this.setError(import_types16.WalletErrorCode.CONNECTION_FAILED, message);
-      throw error instanceof WalletError ? error : new WalletError(message, import_types16.WalletErrorCode.CONNECTION_FAILED, { cause: error });
+      this.setError(import_types17.WalletErrorCode.CONNECTION_FAILED, message);
+      throw error instanceof WalletError ? error : new WalletError(message, import_types17.WalletErrorCode.CONNECTION_FAILED, { cause: error });
     }
   }
   /**
@@ -7500,7 +7953,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signMessage(message) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types16.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const { signature } = await this.provider.signMessage(message);
@@ -7511,9 +7964,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_types16.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message2, import_types17.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message2, import_types16.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message2, import_types17.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -7526,7 +7979,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signTransaction(tx) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types16.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const solTx = tx.data;
@@ -7545,9 +7998,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_types16.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message, import_types16.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -7558,7 +8011,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signAndSendTransaction(tx) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types16.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const solTx = tx.data;
@@ -7573,12 +8026,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_types16.WalletErrorCode.TRANSACTION_REJECTED);
+        throw new WalletError(message, import_types17.WalletErrorCode.TRANSACTION_REJECTED);
       }
       if (message.includes("insufficient") || message.includes("Insufficient")) {
-        throw new WalletError(message, import_types16.WalletErrorCode.INSUFFICIENT_FUNDS);
+        throw new WalletError(message, import_types17.WalletErrorCode.INSUFFICIENT_FUNDS);
       }
-      throw new WalletError(message, import_types16.WalletErrorCode.TRANSACTION_FAILED, {
+      throw new WalletError(message, import_types17.WalletErrorCode.TRANSACTION_FAILED, {
         cause: error
       });
     }
@@ -7591,16 +8044,16 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signAllTransactions(transactions) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types16.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types17.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_types16.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message, import_types16.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -7621,7 +8074,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         "Failed to get balance",
-        import_types16.WalletErrorCode.UNKNOWN,
+        import_types17.WalletErrorCode.UNKNOWN,
         { cause: error }
       );
     }
@@ -7634,7 +8087,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "solana") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Solana adapter`,
-        import_types16.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types17.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -7752,7 +8205,7 @@ function createSolanaAdapter(config = {}) {
 }
 
 // src/wallet/solana/mock.ts
-var import_types18 = require("@sip-protocol/types");
+var import_types19 = require("@sip-protocol/types");
 var MockPublicKey = class {
   base58;
   bytes;
@@ -7818,8 +8271,8 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this._connectionState = "connecting";
     await this.simulateLatency();
     if (this.shouldFailConnect) {
-      this.setError(import_types18.WalletErrorCode.CONNECTION_FAILED, "Mock connection failure");
-      throw new WalletError("Mock connection failure", import_types18.WalletErrorCode.CONNECTION_FAILED);
+      this.setError(import_types19.WalletErrorCode.CONNECTION_FAILED, "Mock connection failure");
+      throw new WalletError("Mock connection failure", import_types19.WalletErrorCode.CONNECTION_FAILED);
     }
     const hexPubKey = "0x" + Buffer.from(this.mockPublicKey.toBytes()).toString("hex");
     this.setConnected(this.mockAddress, hexPubKey);
@@ -7838,7 +8291,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types18.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
     }
     const mockSig = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
@@ -7856,7 +8309,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types18.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
     }
     const solTx = tx.data;
     this.signedTransactions.push(solTx);
@@ -7876,10 +8329,10 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types18.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
     }
     if (this.shouldFailTransaction) {
-      throw new WalletError("Mock transaction failure", import_types18.WalletErrorCode.TRANSACTION_FAILED);
+      throw new WalletError("Mock transaction failure", import_types19.WalletErrorCode.TRANSACTION_FAILED);
     }
     const txSig = `mock_tx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     this.sentTransactions.push(txSig);
@@ -7899,7 +8352,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types18.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
     }
     this.signedTransactions.push(...transactions);
     return transactions.map((tx) => {
@@ -7926,7 +8379,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "solana") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Solana adapter`,
-        import_types18.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types19.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8095,7 +8548,7 @@ function createMockSolanaAdapter(config = {}) {
 }
 
 // src/wallet/ethereum/adapter.ts
-var import_types20 = require("@sip-protocol/types");
+var import_types21 = require("@sip-protocol/types");
 
 // src/wallet/ethereum/types.ts
 var EthereumChainId = {
@@ -8237,7 +8690,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           `${this.walletType} wallet not found. Please install the extension.`,
-          import_types20.WalletErrorCode.NOT_INSTALLED
+          import_types21.WalletErrorCode.NOT_INSTALLED
         );
       }
       const accounts = await this.provider.request({
@@ -8247,7 +8700,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           "No accounts returned from wallet",
-          import_types20.WalletErrorCode.CONNECTION_REJECTED
+          import_types21.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       const address = normalizeAddress(accounts[0]);
@@ -8267,12 +8720,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected connection request",
-          import_types20.WalletErrorCode.CONNECTION_REJECTED
+          import_types21.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       throw new WalletError(
         `Failed to connect: ${rpcError.message || String(error)}`,
-        import_types20.WalletErrorCode.CONNECTION_FAILED
+        import_types21.WalletErrorCode.CONNECTION_FAILED
       );
     }
   }
@@ -8292,7 +8745,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types20.WalletErrorCode.NOT_CONNECTED
+        import_types21.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8310,12 +8763,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected signing request",
-          import_types20.WalletErrorCode.SIGNING_REJECTED
+          import_types21.WalletErrorCode.SIGNING_REJECTED
         );
       }
       throw new WalletError(
         `Failed to sign message: ${rpcError.message || String(error)}`,
-        import_types20.WalletErrorCode.SIGNING_FAILED
+        import_types21.WalletErrorCode.SIGNING_FAILED
       );
     }
   }
@@ -8327,7 +8780,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types20.WalletErrorCode.NOT_CONNECTED
+        import_types21.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8344,12 +8797,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected signing request",
-          import_types20.WalletErrorCode.SIGNING_REJECTED
+          import_types21.WalletErrorCode.SIGNING_REJECTED
         );
       }
       throw new WalletError(
         `Failed to sign typed data: ${rpcError.message || String(error)}`,
-        import_types20.WalletErrorCode.SIGNING_FAILED
+        import_types21.WalletErrorCode.SIGNING_FAILED
       );
     }
   }
@@ -8361,7 +8814,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types20.WalletErrorCode.NOT_CONNECTED
+        import_types21.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8389,7 +8842,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected transaction signing",
-          import_types20.WalletErrorCode.SIGNING_REJECTED
+          import_types21.WalletErrorCode.SIGNING_REJECTED
         );
       }
       if (rpcError.code === -32601 || rpcError.message?.includes("not supported")) {
@@ -8407,7 +8860,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       }
       throw new WalletError(
         `Failed to sign transaction: ${rpcError.message || String(error)}`,
-        import_types20.WalletErrorCode.TRANSACTION_FAILED
+        import_types21.WalletErrorCode.TRANSACTION_FAILED
       );
     }
   }
@@ -8419,7 +8872,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types20.WalletErrorCode.NOT_CONNECTED
+        import_types21.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8441,12 +8894,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected transaction",
-          import_types20.WalletErrorCode.TRANSACTION_REJECTED
+          import_types21.WalletErrorCode.TRANSACTION_REJECTED
         );
       }
       throw new WalletError(
         `Failed to send transaction: ${rpcError.message || String(error)}`,
-        import_types20.WalletErrorCode.TRANSACTION_FAILED
+        import_types21.WalletErrorCode.TRANSACTION_FAILED
       );
     }
   }
@@ -8481,7 +8934,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         `Failed to fetch balance: ${String(error)}`,
-        import_types20.WalletErrorCode.UNKNOWN
+        import_types21.WalletErrorCode.UNKNOWN
       );
     }
   }
@@ -8493,7 +8946,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "ethereum") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Ethereum adapter`,
-        import_types20.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types21.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8518,7 +8971,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         `Failed to fetch token balance: ${String(error)}`,
-        import_types20.WalletErrorCode.UNKNOWN
+        import_types21.WalletErrorCode.UNKNOWN
       );
     }
   }
@@ -8530,7 +8983,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types20.WalletErrorCode.NOT_CONNECTED
+        import_types21.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -8545,18 +8998,18 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected chain switch",
-          import_types20.WalletErrorCode.CHAIN_SWITCH_REJECTED
+          import_types21.WalletErrorCode.CHAIN_SWITCH_REJECTED
         );
       }
       if (rpcError.code === 4902) {
         throw new WalletError(
           `Chain ${chainId} not added to wallet`,
-          import_types20.WalletErrorCode.UNSUPPORTED_CHAIN
+          import_types21.WalletErrorCode.UNSUPPORTED_CHAIN
         );
       }
       throw new WalletError(
         `Failed to switch chain: ${rpcError.message || String(error)}`,
-        import_types20.WalletErrorCode.CHAIN_SWITCH_FAILED
+        import_types21.WalletErrorCode.CHAIN_SWITCH_FAILED
       );
     }
   }
@@ -8592,7 +9045,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     }
     throw new WalletError(
       `Transaction ${txHash} not confirmed after ${maxAttempts * 5} seconds`,
-      import_types20.WalletErrorCode.TRANSACTION_FAILED
+      import_types21.WalletErrorCode.TRANSACTION_FAILED
     );
   }
   /**
@@ -8666,7 +9119,7 @@ function createEthereumAdapter(config) {
 }
 
 // src/wallet/ethereum/mock.ts
-var import_types22 = require("@sip-protocol/types");
+var import_types23 = require("@sip-protocol/types");
 var MockEthereumAdapter = class extends BaseWalletAdapter {
   chain = "ethereum";
   name = "mock-ethereum";
@@ -8707,7 +9160,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           "Mock connection rejected",
-          import_types22.WalletErrorCode.CONNECTION_REJECTED
+          import_types23.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       await new Promise((resolve) => setTimeout(resolve, 10));
@@ -8719,7 +9172,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
       this._connectionState = "error";
       throw new WalletError(
         `Mock connection failed: ${String(error)}`,
-        import_types22.WalletErrorCode.CONNECTION_FAILED
+        import_types23.WalletErrorCode.CONNECTION_FAILED
       );
     }
   }
@@ -8737,7 +9190,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types22.WalletErrorCode.SIGNING_REJECTED
+        import_types23.WalletErrorCode.SIGNING_REJECTED
       );
     }
     const msgHex = Buffer.from(message).toString("hex");
@@ -8755,7 +9208,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types22.WalletErrorCode.SIGNING_REJECTED
+        import_types23.WalletErrorCode.SIGNING_REJECTED
       );
     }
     const mockSig = `0x${"1".repeat(130)}`;
@@ -8772,7 +9225,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types22.WalletErrorCode.SIGNING_REJECTED
+        import_types23.WalletErrorCode.SIGNING_REJECTED
       );
     }
     this._signedTransactions.push(tx);
@@ -8797,7 +9250,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailTransaction) {
       throw new WalletError(
         "Mock transaction failed",
-        import_types22.WalletErrorCode.TRANSACTION_FAILED
+        import_types23.WalletErrorCode.TRANSACTION_FAILED
       );
     }
     this._signedTransactions.push(tx);
@@ -8827,7 +9280,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "ethereum") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Ethereum adapter`,
-        import_types22.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types23.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -9106,7 +9559,7 @@ function getAvailableTransports() {
 }
 
 // src/wallet/hardware/ledger.ts
-var import_types25 = require("@sip-protocol/types");
+var import_types26 = require("@sip-protocol/types");
 var LedgerWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "ledger";
@@ -9259,7 +9712,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types25.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types26.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -9270,7 +9723,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types25.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types26.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -9558,7 +10011,7 @@ function createLedgerAdapter(config) {
 }
 
 // src/wallet/hardware/trezor.ts
-var import_types27 = require("@sip-protocol/types");
+var import_types28 = require("@sip-protocol/types");
 var TrezorWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "trezor";
@@ -9704,7 +10157,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types27.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types28.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -9715,7 +10168,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types27.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types28.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -9996,7 +10449,7 @@ function createTrezorAdapter(config) {
 }
 
 // src/wallet/hardware/mock.ts
-var import_types29 = require("@sip-protocol/types");
+var import_types30 = require("@sip-protocol/types");
 var import_utils14 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
@@ -10144,7 +10597,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10153,7 +10606,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10383,13 +10836,13 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getAccounts(startIndex = 0, count = 5) {
@@ -10479,7 +10932,7 @@ function createMockTrezorAdapter(config) {
 }
 
 // src/wallet/index.ts
-var import_types32 = require("@sip-protocol/types");
+var import_types33 = require("@sip-protocol/types");
 
 // src/proofs/browser.ts
 var import_noir_js = require("@noir-lang/noir_js");
@@ -12123,6 +12576,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   ZcashRPCClient,
   ZcashRPCError,
   ZcashShieldedService,
+  ZcashSwapService,
   addBlindings,
   addCommitments,
   addOracle,
@@ -12157,6 +12611,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   createWalletFactory,
   createZcashClient,
   createZcashShieldedService,
+  createZcashSwapService,
   decodeStealthMetaAddress,
   decryptMemo,
   decryptWithViewing,