@sip-protocol/sdk 0.2.10 → 0.3.1

package/dist/browser.js

@@ -47,7 +47,7 @@ __export(browser_exports, {
   HardwareWalletError: () => HardwareWalletError,
   IntentBuilder: () => IntentBuilder,
   IntentError: () => IntentError,
-  IntentStatus: () => import_types34.IntentStatus,
+  IntentStatus: () => import_types37.IntentStatus,
   LedgerWalletAdapter: () => LedgerWalletAdapter,
   MockEthereumAdapter: () => MockEthereumAdapter,
   MockLedgerAdapter: () => MockLedgerAdapter,
@@ -56,37 +56,43 @@ __export(browser_exports, {
   MockSolver: () => MockSolver,
   MockTrezorAdapter: () => MockTrezorAdapter,
   MockWalletAdapter: () => MockWalletAdapter,
-  NATIVE_TOKENS: () => import_types34.NATIVE_TOKENS,
+  NATIVE_TOKENS: () => import_types37.NATIVE_TOKENS,
   NEARIntentsAdapter: () => NEARIntentsAdapter,
+  NEARIntentsBackend: () => NEARIntentsBackend,
   NetworkError: () => NetworkError,
   ORACLE_DOMAIN: () => ORACLE_DOMAIN,
   OneClickClient: () => OneClickClient,
-  OneClickDepositMode: () => import_types38.OneClickDepositMode,
-  OneClickErrorCode: () => import_types38.OneClickErrorCode,
-  OneClickSwapStatus: () => import_types38.OneClickSwapStatus,
-  OneClickSwapType: () => import_types38.OneClickSwapType,
+  OneClickDepositMode: () => import_types41.OneClickDepositMode,
+  OneClickErrorCode: () => import_types41.OneClickErrorCode,
+  OneClickSwapStatus: () => import_types41.OneClickSwapStatus,
+  OneClickSwapType: () => import_types41.OneClickSwapType,
   PaymentBuilder: () => PaymentBuilder,
-  PaymentStatus: () => import_types35.PaymentStatus,
-  PrivacyLevel: () => import_types34.PrivacyLevel,
+  PaymentStatus: () => import_types38.PaymentStatus,
+  PrivacyLevel: () => import_types37.PrivacyLevel,
   ProofError: () => ProofError,
   ProofGenerationError: () => ProofGenerationError,
   ProofNotImplementedError: () => ProofNotImplementedError,
   ProofWorker: () => ProofWorker,
-  ProposalStatus: () => import_types36.ProposalStatus,
-  ReportStatus: () => import_types37.ReportStatus,
+  ProposalStatus: () => import_types39.ProposalStatus,
+  ReportStatus: () => import_types40.ReportStatus,
   SIP: () => SIP,
   SIPError: () => SIPError,
-  SIP_VERSION: () => import_types34.SIP_VERSION,
+  SIP_VERSION: () => import_types37.SIP_VERSION,
   STABLECOIN_ADDRESSES: () => STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS: () => STABLECOIN_DECIMALS,
   STABLECOIN_INFO: () => STABLECOIN_INFO,
+  SettlementRegistry: () => SettlementRegistry,
+  SettlementRegistryError: () => SettlementRegistryError,
+  SmartRouter: () => SmartRouter,
   SolanaWalletAdapter: () => SolanaWalletAdapter,
+  SwapStatus: () => SwapStatus,
   Treasury: () => Treasury,
   TrezorWalletAdapter: () => TrezorWalletAdapter,
   ValidationError: () => ValidationError,
   WalletError: () => WalletError,
-  WalletErrorCode: () => import_types33.WalletErrorCode,
-  ZcashErrorCode: () => import_types39.ZcashErrorCode,
+  WalletErrorCode: () => import_types36.WalletErrorCode,
+  ZcashErrorCode: () => import_types42.ZcashErrorCode,
+  ZcashNativeBackend: () => ZcashNativeBackend,
   ZcashRPCClient: () => ZcashRPCClient,
   ZcashRPCError: () => ZcashRPCError,
   ZcashShieldedService: () => ZcashShieldedService,
@@ -116,16 +122,19 @@ __export(browser_exports, {
   createMockSolver: () => createMockSolver,
   createMockTrezorAdapter: () => createMockTrezorAdapter,
   createNEARIntentsAdapter: () => createNEARIntentsAdapter,
+  createNEARIntentsBackend: () => createNEARIntentsBackend,
   createOracleRegistry: () => createOracleRegistry,
   createProductionSIP: () => createProductionSIP,
   createSIP: () => createSIP,
   createShieldedIntent: () => createShieldedIntent,
   createShieldedPayment: () => createShieldedPayment,
+  createSmartRouter: () => createSmartRouter,
   createSolanaAdapter: () => createSolanaAdapter,
   createTrezorAdapter: () => createTrezorAdapter,
   createWalletFactory: () => createWalletFactory,
   createWorkerBlobURL: () => createWorkerBlobURL,
   createZcashClient: () => createZcashClient,
+  createZcashNativeBackend: () => createZcashNativeBackend,
   createZcashShieldedService: () => createZcashShieldedService,
   createZcashSwapService: () => createZcashSwapService,
   decodeStealthMetaAddress: () => decodeStealthMetaAddress,
@@ -193,7 +202,7 @@ __export(browser_exports, {
   isExpired: () => isExpired,
   isNonNegativeAmount: () => isNonNegativeAmount,
   isPaymentExpired: () => isPaymentExpired,
-  isPrivate: () => import_types34.isPrivate,
+  isPrivate: () => import_types37.isPrivate,
   isPrivateWalletAdapter: () => isPrivateWalletAdapter,
   isSIPError: () => isSIPError,
   isStablecoin: () => isStablecoin,
@@ -231,7 +240,7 @@ __export(browser_exports, {
   subtractCommitments: () => subtractCommitments,
   supportsSharedArrayBuffer: () => supportsSharedArrayBuffer,
   supportsTouch: () => supportsTouch,
-  supportsViewingKey: () => import_types34.supportsViewingKey,
+  supportsViewingKey: () => import_types37.supportsViewingKey,
   supportsWASMBulkMemory: () => supportsWASMBulkMemory,
   supportsWASMSimd: () => supportsWASMSimd,
   supportsWebBluetooth: () => supportsWebBluetooth,
@@ -4061,10 +4070,10 @@ function hasEnoughOracles(registry) {
 }
 
 // src/index.ts
-var import_types34 = require("@sip-protocol/types");
-var import_types35 = require("@sip-protocol/types");
-var import_types36 = require("@sip-protocol/types");
 var import_types37 = require("@sip-protocol/types");
+var import_types38 = require("@sip-protocol/types");
+var import_types39 = require("@sip-protocol/types");
+var import_types40 = require("@sip-protocol/types");
 
 // src/solver/mock-solver.ts
 var import_types7 = require("@sip-protocol/types");
@@ -4166,93 +4175,1210 @@ var MockSolver = class {
       validUntil: now + 60,
       estimatedGas: 200000n
     };
-    return quote;
+    return quote;
+  }
+  /**
+   * Fulfill an intent with the given quote
+   *
+   * In production, this would:
+   * 1. Lock collateral
+   * 2. Execute the swap on destination chain
+   * 3. Generate fulfillment proof
+   * 4. Release collateral after verification
+   *
+   * Privacy preserved:
+   * - Funds go to stealth address (unlinkable)
+   * - Solver never learns recipient's real identity
+   */
+  async fulfill(intent, quote) {
+    const status = {
+      intentId: intent.intentId,
+      status: "executing"
+    };
+    this.pendingFulfillments.set(intent.intentId, status);
+    await this.delay(this.executionDelay);
+    if (Math.random() < this.failureRate) {
+      status.status = "failed";
+      status.error = "Simulated failure for testing";
+      return {
+        intentId: intent.intentId,
+        status: import_types7.IntentStatus.FAILED,
+        fulfilledAt: Math.floor(Date.now() / 1e3),
+        error: status.error
+      };
+    }
+    const txHash = `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(32))}`;
+    status.status = "completed";
+    status.txHash = txHash;
+    return {
+      intentId: intent.intentId,
+      status: import_types7.IntentStatus.FULFILLED,
+      outputAmount: quote.outputAmount,
+      txHash: intent.privacyLevel === "transparent" ? txHash : void 0,
+      fulfillmentProof: {
+        type: "fulfillment",
+        proof: `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(128))}`,
+        publicInputs: [
+          `0x${(0, import_utils10.bytesToHex)(new TextEncoder().encode(intent.intentId))}`,
+          `0x${(0, import_utils10.bytesToHex)(new TextEncoder().encode(quote.quoteId))}`
+        ]
+      },
+      fulfilledAt: Math.floor(Date.now() / 1e3)
+    };
+  }
+  /**
+   * Cancel a pending fulfillment
+   */
+  async cancel(intentId) {
+    const status = this.pendingFulfillments.get(intentId);
+    if (!status || status.status !== "pending") {
+      return false;
+    }
+    status.status = "cancelled";
+    return true;
+  }
+  /**
+   * Get fulfillment status
+   */
+  async getStatus(intentId) {
+    return this.pendingFulfillments.get(intentId) ?? null;
+  }
+  /**
+   * Reset solver state (for testing)
+   */
+  reset() {
+    this.pendingFulfillments.clear();
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createMockSolver(config) {
+  return new MockSolver(config);
+}
+
+// src/index.ts
+var import_types41 = require("@sip-protocol/types");
+
+// src/settlement/interface.ts
+var SwapStatus = /* @__PURE__ */ ((SwapStatus2) => {
+  SwapStatus2["PENDING_DEPOSIT"] = "pending_deposit";
+  SwapStatus2["DEPOSIT_CONFIRMED"] = "deposit_confirmed";
+  SwapStatus2["IN_PROGRESS"] = "in_progress";
+  SwapStatus2["SUCCESS"] = "success";
+  SwapStatus2["FAILED"] = "failed";
+  SwapStatus2["CANCELLED"] = "cancelled";
+  SwapStatus2["REFUNDING"] = "refunding";
+  SwapStatus2["REFUNDED"] = "refunded";
+  return SwapStatus2;
+})(SwapStatus || {});
+
+// src/settlement/registry.ts
+var SettlementRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SettlementRegistryError";
+  }
+};
+var SettlementRegistry = class {
+  backends = /* @__PURE__ */ new Map();
+  /**
+   * Register a settlement backend
+   *
+   * @param backend - Settlement backend to register
+   * @throws {SettlementRegistryError} If backend with same name already exists
+   *
+   * @example
+   * ```typescript
+   * registry.register(nearIntentsBackend)
+   * ```
+   */
+  register(backend) {
+    if (this.backends.has(backend.name)) {
+      throw new SettlementRegistryError(
+        `Backend '${backend.name}' is already registered`
+      );
+    }
+    this.backends.set(backend.name, backend);
+  }
+  /**
+   * Get a settlement backend by name
+   *
+   * @param name - Backend name
+   * @returns Settlement backend
+   * @throws {SettlementRegistryError} If backend is not found
+   *
+   * @example
+   * ```typescript
+   * const backend = registry.get('near-intents')
+   * ```
+   */
+  get(name) {
+    const backend = this.backends.get(name);
+    if (!backend) {
+      throw new SettlementRegistryError(`Backend '${name}' not found`);
+    }
+    return backend;
+  }
+  /**
+   * List all registered backend names
+   *
+   * @returns Array of backend names
+   *
+   * @example
+   * ```typescript
+   * const names = registry.list()
+   * // ['near-intents', 'zcash', 'thorchain']
+   * ```
+   */
+  list() {
+    return Array.from(this.backends.keys());
+  }
+  /**
+   * Get the best backend for a specific route
+   *
+   * Selection criteria (in order of priority):
+   * 1. Backends that support both source and destination chains
+   * 2. Backends with faster average execution time
+   * 3. First registered backend (if no execution time info)
+   *
+   * @param fromChain - Source chain
+   * @param toChain - Destination chain
+   * @returns Best settlement backend for the route
+   * @throws {SettlementRegistryError} If no backend supports the route
+   *
+   * @example
+   * ```typescript
+   * const backend = registry.getBestForRoute('ethereum', 'solana')
+   * const quote = await backend.getQuote({ ... })
+   * ```
+   */
+  getBestForRoute(fromChain, toChain) {
+    const supportedBackends = [];
+    for (const backend of Array.from(this.backends.values())) {
+      const { supportedSourceChains, supportedDestinationChains } = backend.capabilities;
+      const supportsSource = supportedSourceChains.includes(fromChain);
+      const supportsDestination = supportedDestinationChains.includes(toChain);
+      if (supportsSource && supportsDestination) {
+        supportedBackends.push(backend);
+      }
+    }
+    if (supportedBackends.length === 0) {
+      throw new SettlementRegistryError(
+        `No backend supports route from '${fromChain}' to '${toChain}'`
+      );
+    }
+    if (supportedBackends.length === 1) {
+      return supportedBackends[0];
+    }
+    supportedBackends.sort((a, b) => {
+      const timeA = a.capabilities.averageExecutionTime ?? Infinity;
+      const timeB = b.capabilities.averageExecutionTime ?? Infinity;
+      return timeA - timeB;
+    });
+    return supportedBackends[0];
+  }
+  /**
+   * Get all supported routes across all registered backends
+   *
+   * @returns Array of supported routes
+   *
+   * @example
+   * ```typescript
+   * const routes = registry.getSupportedRoutes()
+   * // [
+   * //   { fromChain: 'ethereum', toChain: 'solana', backend: 'near-intents' },
+   * //   { fromChain: 'solana', toChain: 'ethereum', backend: 'near-intents' },
+   * //   { fromChain: 'ethereum', toChain: 'zcash', backend: 'zcash' },
+   * //   ...
+   * // ]
+   * ```
+   */
+  getSupportedRoutes() {
+    const routes = [];
+    for (const backend of Array.from(this.backends.values())) {
+      const { supportedSourceChains, supportedDestinationChains } = backend.capabilities;
+      for (const fromChain of supportedSourceChains) {
+        for (const toChain of supportedDestinationChains) {
+          routes.push({
+            fromChain,
+            toChain,
+            backend: backend.name
+          });
+        }
+      }
+    }
+    return routes;
+  }
+  /**
+   * Check if a backend is registered
+   *
+   * @param name - Backend name
+   * @returns True if backend is registered
+   *
+   * @example
+   * ```typescript
+   * if (registry.has('near-intents')) {
+   *   const backend = registry.get('near-intents')
+   * }
+   * ```
+   */
+  has(name) {
+    return this.backends.has(name);
+  }
+  /**
+   * Unregister a settlement backend
+   *
+   * @param name - Backend name to unregister
+   * @returns True if backend was unregistered, false if not found
+   *
+   * @example
+   * ```typescript
+   * registry.unregister('near-intents')
+   * ```
+   */
+  unregister(name) {
+    return this.backends.delete(name);
+  }
+  /**
+   * Clear all registered backends
+   *
+   * @example
+   * ```typescript
+   * registry.clear()
+   * ```
+   */
+  clear() {
+    this.backends.clear();
+  }
+  /**
+   * Get number of registered backends
+   *
+   * @returns Number of registered backends
+   *
+   * @example
+   * ```typescript
+   * const count = registry.size()
+   * ```
+   */
+  size() {
+    return this.backends.size;
+  }
+};
+
+// src/settlement/router.ts
+var SmartRouter = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Find best routes for a swap
+   *
+   * Queries all compatible backends in parallel and returns sorted routes.
+   *
+   * @param params - Route finding parameters
+   * @returns Sorted routes (best first)
+   * @throws {ValidationError} If no backends support the route
+   */
+  async findBestRoute(params) {
+    const {
+      from,
+      to,
+      amount,
+      privacyLevel,
+      preferSpeed = false,
+      preferLowFees = true,
+      recipientMetaAddress,
+      senderAddress,
+      slippageTolerance,
+      deadline
+    } = params;
+    if (amount <= 0n) {
+      throw new ValidationError("Amount must be greater than zero");
+    }
+    const allBackends = this.registry.list().map((name) => this.registry.get(name));
+    const compatibleBackends = allBackends.filter((backend) => {
+      const { supportedSourceChains, supportedDestinationChains, supportedPrivacyLevels } = backend.capabilities;
+      const supportsRoute = supportedSourceChains.includes(from.chain) && supportedDestinationChains.includes(to.chain);
+      const supportsPrivacy = supportedPrivacyLevels.includes(privacyLevel);
+      return supportsRoute && supportsPrivacy;
+    });
+    if (compatibleBackends.length === 0) {
+      throw new ValidationError(
+        `No backend supports route from ${from.chain} to ${to.chain} with privacy level ${privacyLevel}`
+      );
+    }
+    const quoteParams = {
+      fromChain: from.chain,
+      toChain: to.chain,
+      fromToken: from.token,
+      toToken: to.token,
+      amount,
+      privacyLevel,
+      recipientMetaAddress,
+      senderAddress,
+      slippageTolerance,
+      deadline
+    };
+    const quotePromises = compatibleBackends.map(async (backend) => {
+      try {
+        const quote = await backend.getQuote(quoteParams);
+        return {
+          backend: backend.name,
+          quote,
+          backendInstance: backend,
+          success: true
+        };
+      } catch (error) {
+        return {
+          backend: backend.name,
+          error: error instanceof Error ? error.message : "Unknown error",
+          success: false
+        };
+      }
+    });
+    const results = await Promise.all(quotePromises);
+    const successfulRoutes = results.filter((r) => r.success).map((r) => ({
+      backend: r.backend,
+      quote: r.quote,
+      backendInstance: r.backendInstance,
+      score: 0
+      // Will be calculated below
+    }));
+    if (successfulRoutes.length === 0) {
+      const errors = results.filter((r) => !r.success).map((r) => `${r.backend}: ${r.error}`).join(", ");
+      throw new NetworkError(
+        `All backends failed to provide quotes: ${errors}`
+      );
+    }
+    this.rankRoutes(successfulRoutes, { preferSpeed, preferLowFees });
+    successfulRoutes.sort((a, b) => b.score - a.score);
+    return successfulRoutes;
+  }
+  /**
+   * Compare quotes from multiple routes side-by-side
+   *
+   * @param routes - Routes to compare (from findBestRoute)
+   * @returns Comparison with best routes by different criteria
+   */
+  compareQuotes(routes) {
+    if (routes.length === 0) {
+      return {
+        routes: [],
+        bestByCost: null,
+        bestBySpeed: null,
+        bestByPrivacy: null,
+        metadata: {
+          totalQueried: 0,
+          failures: [],
+          queriedAt: Date.now()
+        }
+      };
+    }
+    const bestByCost = [...routes].sort((a, b) => {
+      const costA = this.calculateTotalCost(a.quote);
+      const costB = this.calculateTotalCost(b.quote);
+      return costA - costB;
+    })[0];
+    const bestBySpeed = [...routes].sort((a, b) => {
+      const timeA = a.quote.estimatedTime ?? Infinity;
+      const timeB = b.quote.estimatedTime ?? Infinity;
+      return timeA - timeB;
+    })[0];
+    const bestByPrivacy = [...routes].find((route) => {
+      const { supportedPrivacyLevels } = route.backendInstance.capabilities;
+      return supportedPrivacyLevels.includes("shielded") || supportedPrivacyLevels.includes("compliant");
+    }) || routes[0];
+    return {
+      routes,
+      bestByCost,
+      bestBySpeed,
+      bestByPrivacy,
+      metadata: {
+        totalQueried: routes.length,
+        failures: [],
+        // Could track from findBestRoute
+        queriedAt: Date.now()
+      }
+    };
+  }
+  /**
+   * Rank routes by score
+   *
+   * Scoring algorithm:
+   * - Base score: 100
+   * - Cost: Lower fees = higher score (up to +50)
+   * - Speed: Faster execution = higher score (up to +30)
+   * - Privacy: Better privacy support = higher score (up to +20)
+   *
+   * @private
+   */
+  rankRoutes(routes, preferences) {
+    const { preferSpeed, preferLowFees } = preferences;
+    const costs = routes.map((r) => this.calculateTotalCost(r.quote));
+    const times = routes.map((r) => r.quote.estimatedTime ?? Infinity);
+    const minCost = Math.min(...costs);
+    const maxCost = Math.max(...costs);
+    const minTime = Math.min(...times.filter((t) => t !== Infinity));
+    const maxTime = Math.max(...times.filter((t) => t !== Infinity));
+    routes.forEach((route, index) => {
+      let score = 100;
+      if (maxCost > minCost) {
+        const costNormalized = 1 - (costs[index] - minCost) / (maxCost - minCost);
+        const costWeight = preferLowFees ? 50 : 30;
+        score += costNormalized * costWeight;
+      }
+      const time = times[index];
+      if (time !== Infinity && maxTime > minTime) {
+        const speedNormalized = 1 - (time - minTime) / (maxTime - minTime);
+        const speedWeight = preferSpeed ? 50 : 30;
+        score += speedNormalized * speedWeight;
+      }
+      const { supportedPrivacyLevels } = route.backendInstance.capabilities;
+      if (supportedPrivacyLevels.includes("shielded")) {
+        score += 20;
+      } else if (supportedPrivacyLevels.includes("compliant")) {
+        score += 10;
+      }
+      route.score = score;
+    });
+  }
+  /**
+   * Calculate total cost from quote
+   *
+   * Returns total fee in USD if available, otherwise estimates from fees
+   *
+   * @private
+   */
+  calculateTotalCost(quote) {
+    if (quote.fees.totalFeeUSD) {
+      return parseFloat(quote.fees.totalFeeUSD);
+    }
+    const networkFee = parseFloat(quote.fees.networkFee) || 0;
+    const protocolFee = parseFloat(quote.fees.protocolFee) || 0;
+    return networkFee + protocolFee;
+  }
+};
+function createSmartRouter(registry) {
+  return new SmartRouter(registry);
+}
+
+// src/settlement/backends/near-intents.ts
+var import_types8 = require("@sip-protocol/types");
+function mapOneClickStatus(status) {
+  switch (status) {
+    case import_types8.OneClickSwapStatus.PENDING_DEPOSIT:
+      return "pending_deposit" /* PENDING_DEPOSIT */;
+    case import_types8.OneClickSwapStatus.PROCESSING:
+      return "in_progress" /* IN_PROGRESS */;
+    case import_types8.OneClickSwapStatus.SUCCESS:
+      return "success" /* SUCCESS */;
+    case import_types8.OneClickSwapStatus.FAILED:
+      return "failed" /* FAILED */;
+    case import_types8.OneClickSwapStatus.INCOMPLETE_DEPOSIT:
+      return "failed" /* FAILED */;
+    case import_types8.OneClickSwapStatus.REFUNDED:
+      return "refunded" /* REFUNDED */;
+    default:
+      return "pending_deposit" /* PENDING_DEPOSIT */;
+  }
+}
+var NEARIntentsBackend = class {
+  name = "near-intents";
+  capabilities;
+  adapter;
+  quoteCache;
+  constructor(config = {}) {
+    this.adapter = new NEARIntentsAdapter(config);
+    this.quoteCache = /* @__PURE__ */ new Map();
+    this.capabilities = {
+      supportedSourceChains: [
+        "near",
+        "ethereum",
+        "solana",
+        "polygon",
+        "arbitrum",
+        "optimism",
+        "base",
+        "bitcoin",
+        "zcash"
+      ],
+      supportedDestinationChains: [
+        "near",
+        "ethereum",
+        "solana",
+        "polygon",
+        "arbitrum",
+        "optimism",
+        "base",
+        "bitcoin",
+        "zcash"
+      ],
+      supportedPrivacyLevels: [
+        import_types8.PrivacyLevel.TRANSPARENT,
+        import_types8.PrivacyLevel.SHIELDED,
+        import_types8.PrivacyLevel.COMPLIANT
+      ],
+      supportsCancellation: false,
+      supportsRefunds: true,
+      averageExecutionTime: 300,
+      // 5 minutes
+      features: ["stealth-addresses", "cross-chain", "near-intents"]
+    };
+  }
+  /**
+   * Get quote for a cross-chain swap
+   */
+  async getQuote(params) {
+    this.validateQuoteParams(params);
+    const swapRequest = {
+      requestId: this.generateRequestId(),
+      privacyLevel: params.privacyLevel,
+      inputAsset: {
+        chain: params.fromChain,
+        symbol: params.fromToken,
+        decimals: 0
+        // Will be inferred by adapter
+      },
+      outputAsset: {
+        chain: params.toChain,
+        symbol: params.toToken,
+        decimals: 0
+        // Will be inferred by adapter
+      },
+      inputAmount: params.amount,
+      minOutputAmount: params.slippageTolerance ? params.amount - params.amount * BigInt(params.slippageTolerance) / BigInt(1e4) : void 0
+    };
+    const prepared = await this.adapter.prepareSwap(
+      swapRequest,
+      params.recipientMetaAddress,
+      params.senderAddress
+    );
+    const oneClickQuote = await this.adapter.getQuote(prepared);
+    this.quoteCache.set(oneClickQuote.quoteId, params);
+    const quote = {
+      quoteId: oneClickQuote.quoteId,
+      amountIn: oneClickQuote.amountIn,
+      amountOut: oneClickQuote.amountOut,
+      minAmountOut: oneClickQuote.amountOut,
+      // 1Click doesn't provide separate minAmount
+      fees: {
+        networkFee: "0",
+        // 1Click doesn't provide separate fee breakdown
+        protocolFee: "0",
+        totalFeeUSD: oneClickQuote.amountOutUsd
+      },
+      depositAddress: oneClickQuote.depositAddress,
+      recipientAddress: prepared.stealthAddress?.address ?? params.senderAddress ?? "",
+      refundAddress: params.senderAddress,
+      expiresAt: new Date(oneClickQuote.deadline).getTime() / 1e3,
+      estimatedTime: oneClickQuote.timeEstimate,
+      metadata: {
+        prepared,
+        oneClickQuote,
+        stealthAddress: prepared.stealthAddress,
+        ephemeralPublicKey: prepared.stealthAddress?.ephemeralPublicKey,
+        curve: prepared.curve
+      }
+    };
+    return quote;
+  }
+  /**
+   * Execute swap using a quote
+   */
+  async executeSwap(params) {
+    if (!params.quoteId) {
+      throw new ValidationError("quoteId is required", "quoteId");
+    }
+    const quoteParams = this.quoteCache.get(params.quoteId);
+    if (!quoteParams) {
+      throw new ValidationError(
+        "Quote not found. Please call getQuote() before executeSwap()",
+        "quoteId"
+      );
+    }
+    const swapRequest = {
+      requestId: this.generateRequestId(),
+      privacyLevel: quoteParams.privacyLevel,
+      inputAsset: {
+        chain: quoteParams.fromChain,
+        symbol: quoteParams.fromToken,
+        decimals: 0
+      },
+      outputAsset: {
+        chain: quoteParams.toChain,
+        symbol: quoteParams.toToken,
+        decimals: 0
+      },
+      inputAmount: quoteParams.amount
+    };
+    const adapterResult = await this.adapter.initiateSwap(
+      swapRequest,
+      quoteParams.recipientMetaAddress,
+      quoteParams.senderAddress
+    );
+    if (params.depositTxHash) {
+      await this.adapter.notifyDeposit(
+        adapterResult.depositAddress,
+        params.depositTxHash,
+        params.nearAccount
+      );
+    }
+    const result = {
+      swapId: adapterResult.depositAddress,
+      // Use deposit address as swap ID
+      status: mapOneClickStatus(adapterResult.status),
+      quoteId: params.quoteId,
+      depositAddress: adapterResult.depositAddress,
+      depositTxHash: params.depositTxHash,
+      settlementTxHash: adapterResult.settlementTxHash,
+      actualAmountOut: adapterResult.amountOut,
+      metadata: {
+        adapterResult,
+        stealthRecipient: adapterResult.stealthRecipient,
+        ephemeralPublicKey: adapterResult.ephemeralPublicKey
+      }
+    };
+    return result;
+  }
+  /**
+   * Get current swap status
+   */
+  async getStatus(swapId) {
+    const oneClickStatus = await this.adapter.getStatus(swapId);
+    const status = {
+      swapId,
+      status: mapOneClickStatus(oneClickStatus.status),
+      quoteId: "",
+      // 1Click status doesn't include quoteId
+      depositAddress: swapId,
+      amountIn: oneClickStatus.amountIn ?? "0",
+      amountOut: oneClickStatus.amountOut ?? "0",
+      depositTxHash: oneClickStatus.depositTxHash,
+      settlementTxHash: oneClickStatus.settlementTxHash,
+      errorMessage: oneClickStatus.error,
+      updatedAt: Date.now() / 1e3,
+      // 1Click doesn't provide updatedAt
+      metadata: {
+        oneClickStatus
+      }
+    };
+    return status;
+  }
+  /**
+   * Wait for swap completion (optional)
+   */
+  async waitForCompletion(swapId, options) {
+    await this.adapter.waitForCompletion(swapId, {
+      interval: options?.interval,
+      timeout: options?.timeout,
+      onStatus: options?.onStatusChange ? (oneClickStatus) => {
+        const status = {
+          swapId,
+          status: mapOneClickStatus(oneClickStatus.status),
+          quoteId: "",
+          depositAddress: swapId,
+          amountIn: oneClickStatus.amountIn ?? "0",
+          amountOut: oneClickStatus.amountOut ?? "0",
+          depositTxHash: oneClickStatus.depositTxHash,
+          settlementTxHash: oneClickStatus.settlementTxHash,
+          errorMessage: oneClickStatus.error,
+          updatedAt: Date.now() / 1e3,
+          metadata: { oneClickStatus }
+        };
+        options.onStatusChange?.(status);
+      } : void 0
+    });
+    return this.getStatus(swapId);
+  }
+  /**
+   * Get dry quote (preview without creating deposit address)
+   */
+  async getDryQuote(params) {
+    this.validateQuoteParams(params);
+    const swapRequest = {
+      requestId: this.generateRequestId(),
+      privacyLevel: params.privacyLevel,
+      inputAsset: {
+        chain: params.fromChain,
+        symbol: params.fromToken,
+        decimals: 0
+      },
+      outputAsset: {
+        chain: params.toChain,
+        symbol: params.toToken,
+        decimals: 0
+      },
+      inputAmount: params.amount
+    };
+    const prepared = await this.adapter.prepareSwap(
+      swapRequest,
+      params.recipientMetaAddress,
+      params.senderAddress
+    );
+    const oneClickQuote = await this.adapter.getDryQuote(prepared);
+    const quote = {
+      quoteId: oneClickQuote.quoteId,
+      amountIn: oneClickQuote.amountIn,
+      amountOut: oneClickQuote.amountOut,
+      minAmountOut: oneClickQuote.amountOut,
+      fees: {
+        networkFee: "0",
+        protocolFee: "0",
+        totalFeeUSD: oneClickQuote.amountOutUsd
+      },
+      depositAddress: oneClickQuote.depositAddress,
+      recipientAddress: prepared.stealthAddress?.address ?? params.senderAddress ?? "",
+      refundAddress: params.senderAddress,
+      expiresAt: new Date(oneClickQuote.deadline).getTime() / 1e3,
+      estimatedTime: oneClickQuote.timeEstimate,
+      metadata: {
+        prepared,
+        oneClickQuote,
+        stealthAddress: prepared.stealthAddress,
+        ephemeralPublicKey: prepared.stealthAddress?.ephemeralPublicKey,
+        curve: prepared.curve,
+        isDryQuote: true
+      }
+    };
+    return quote;
+  }
+  /**
+   * Notify backend of deposit transaction
+   */
+  async notifyDeposit(swapId, txHash, metadata) {
+    await this.adapter.notifyDeposit(
+      swapId,
+      // swapId is deposit address
+      txHash,
+      metadata?.nearAccount
+    );
+  }
+  // ─── Private Methods ──────────────────────────────────────────────────────────
+  validateQuoteParams(params) {
+    if (!params.fromChain) {
+      throw new ValidationError("fromChain is required", "fromChain");
+    }
+    if (!params.toChain) {
+      throw new ValidationError("toChain is required", "toChain");
+    }
+    if (!params.fromToken) {
+      throw new ValidationError("fromToken is required", "fromToken");
+    }
+    if (!params.toToken) {
+      throw new ValidationError("toToken is required", "toToken");
+    }
+    if (!params.amount || params.amount <= BigInt(0)) {
+      throw new ValidationError("amount must be greater than 0", "amount");
+    }
+    if (!params.privacyLevel) {
+      throw new ValidationError("privacyLevel is required", "privacyLevel");
+    }
+    if (params.privacyLevel !== import_types8.PrivacyLevel.TRANSPARENT && !params.recipientMetaAddress) {
+      throw new ValidationError(
+        "recipientMetaAddress is required for shielded/compliant privacy modes",
+        "recipientMetaAddress"
+      );
+    }
+    if (params.privacyLevel === import_types8.PrivacyLevel.TRANSPARENT && !params.senderAddress) {
+      throw new ValidationError(
+        "senderAddress is required for transparent mode",
+        "senderAddress"
+      );
+    }
+    if (!this.capabilities.supportedSourceChains.includes(params.fromChain)) {
+      throw new ValidationError(
+        `Source chain ${params.fromChain} is not supported`,
+        "fromChain",
+        { supportedChains: this.capabilities.supportedSourceChains }
+      );
+    }
+    if (!this.capabilities.supportedDestinationChains.includes(params.toChain)) {
+      throw new ValidationError(
+        `Destination chain ${params.toChain} is not supported`,
+        "toChain",
+        { supportedChains: this.capabilities.supportedDestinationChains }
+      );
+    }
+  }
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  }
+};
+function createNEARIntentsBackend(config) {
+  return new NEARIntentsBackend(config);
+}
+
+// src/settlement/backends/zcash-native.ts
+var import_types9 = require("@sip-protocol/types");
+var ZcashNativeBackend = class {
+  name = "zcash-native";
+  capabilities;
+  swapService;
+  config;
+  quotes = /* @__PURE__ */ new Map();
+  swaps = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.swapService = config.swapService;
+    this.config = {
+      quoteValiditySeconds: config.quoteValiditySeconds ?? 300,
+      networkFeeZatoshis: config.networkFeeZatoshis ?? 1e4
+    };
+    this.capabilities = {
+      supportedSourceChains: ["zcash"],
+      supportedDestinationChains: ["zcash"],
+      supportedPrivacyLevels: [
+        import_types9.PrivacyLevel.TRANSPARENT,
+        import_types9.PrivacyLevel.SHIELDED,
+        import_types9.PrivacyLevel.COMPLIANT
+      ],
+      supportsCancellation: false,
+      supportsRefunds: false,
+      averageExecutionTime: 75,
+      // ~75 seconds for Zcash block confirmation
+      features: [
+        "native-zcash",
+        "shielded-addresses",
+        "transparent-addresses",
+        "instant-quotes"
+      ]
+    };
+  }
+  // ─── Quote Methods ─────────────────────────────────────────────────────────
+  /**
+   * Get a quote for ZEC → ZEC transfer
+   */
+  async getQuote(params) {
+    this.validateQuoteParams(params);
+    const { amount, recipientMetaAddress, senderAddress, privacyLevel } = params;
+    const quoteId = this.generateQuoteId();
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + this.config.quoteValiditySeconds;
+    const networkFee = BigInt(this.config.networkFeeZatoshis);
+    const protocolFee = BigInt(0);
+    const totalFee = networkFee;
+    const amountOut = amount - totalFee;
+    if (amountOut <= BigInt(0)) {
+      throw new ValidationError(
+        "Amount too small to cover network fees",
+        "amount",
+        { amount: amount.toString(), networkFee: networkFee.toString() },
+        "SIP_2004" /* INVALID_AMOUNT */
+      );
+    }
+    const minAmountOut = amountOut * BigInt(99) / BigInt(100);
+    let depositAddress;
+    let recipientAddress;
+    if (privacyLevel === import_types9.PrivacyLevel.SHIELDED || privacyLevel === import_types9.PrivacyLevel.COMPLIANT) {
+      if (typeof recipientMetaAddress === "string") {
+        recipientAddress = recipientMetaAddress;
+      } else if (recipientMetaAddress) {
+        recipientAddress = `zs1${this.randomHex(72)}`;
+      } else {
+        throw new ValidationError(
+          "Recipient address required for shielded transfers",
+          "recipientMetaAddress",
+          void 0,
+          "SIP_2000" /* VALIDATION_FAILED */
+        );
+      }
+      depositAddress = `zs1${this.randomHex(72)}`;
+    } else {
+      if (senderAddress) {
+        depositAddress = senderAddress;
+      } else {
+        depositAddress = `t1${this.randomBase58(33)}`;
+      }
+      if (typeof recipientMetaAddress === "string") {
+        recipientAddress = recipientMetaAddress;
+      } else {
+        throw new ValidationError(
+          "Recipient address required",
+          "recipientMetaAddress",
+          void 0,
+          "SIP_2000" /* VALIDATION_FAILED */
+        );
+      }
+    }
+    const quote = {
+      quoteId,
+      amountIn: amount.toString(),
+      amountOut: amountOut.toString(),
+      minAmountOut: minAmountOut.toString(),
+      fees: {
+        networkFee: networkFee.toString(),
+        protocolFee: protocolFee.toString()
+      },
+      depositAddress,
+      recipientAddress,
+      expiresAt,
+      estimatedTime: this.capabilities.averageExecutionTime,
+      metadata: {
+        backend: this.name,
+        privacyLevel,
+        zcashNetwork: "mainnet"
+      }
+    };
+    this.quotes.set(quoteId, quote);
+    return quote;
+  }
+  /**
+   * Get a dry quote (preview without creating deposit address)
+   */
+  async getDryQuote(params) {
+    return this.getQuote(params);
+  }
+  // ─── Swap Execution ────────────────────────────────────────────────────────
+  /**
+   * Execute a ZEC → ZEC swap/transfer
+   */
+  async executeSwap(params) {
+    const { quoteId, depositTxHash } = params;
+    const quote = this.quotes.get(quoteId);
+    if (!quote) {
+      throw new ValidationError(
+        "Quote not found or expired",
+        "quoteId",
+        { quoteId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (now > quote.expiresAt) {
+      throw new ValidationError(
+        "Quote has expired",
+        "quoteId",
+        { quoteId, expiresAt: quote.expiresAt, now },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const swapId = this.generateSwapId();
+    const result = {
+      swapId,
+      status: depositTxHash ? "deposit_confirmed" /* DEPOSIT_CONFIRMED */ : "pending_deposit" /* PENDING_DEPOSIT */,
+      quoteId,
+      depositAddress: quote.depositAddress,
+      depositTxHash,
+      metadata: {
+        backend: this.name,
+        recipientAddress: quote.recipientAddress
+      }
+    };
+    this.swaps.set(swapId, result);
+    if (depositTxHash) {
+      this.simulateSwapExecution(swapId, quote);
+    }
+    return result;
   }
+  // ─── Status Methods ────────────────────────────────────────────────────────
   /**
-   * Fulfill an intent with the given quote
-   *
-   * In production, this would:
-   * 1. Lock collateral
-   * 2. Execute the swap on destination chain
-   * 3. Generate fulfillment proof
-   * 4. Release collateral after verification
-   *
-   * Privacy preserved:
-   * - Funds go to stealth address (unlinkable)
-   * - Solver never learns recipient's real identity
+   * Get swap status
    */
-  async fulfill(intent, quote) {
-    const status = {
-      intentId: intent.intentId,
-      status: "executing"
-    };
-    this.pendingFulfillments.set(intent.intentId, status);
-    await this.delay(this.executionDelay);
-    if (Math.random() < this.failureRate) {
-      status.status = "failed";
-      status.error = "Simulated failure for testing";
-      return {
-        intentId: intent.intentId,
-        status: import_types7.IntentStatus.FAILED,
-        fulfilledAt: Math.floor(Date.now() / 1e3),
-        error: status.error
-      };
+  async getStatus(swapId) {
+    const swap = this.swaps.get(swapId);
+    if (!swap) {
+      throw new ValidationError(
+        "Swap not found",
+        "swapId",
+        { swapId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
     }
-    const txHash = `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(32))}`;
-    status.status = "completed";
-    status.txHash = txHash;
-    return {
-      intentId: intent.intentId,
-      status: import_types7.IntentStatus.FULFILLED,
-      outputAmount: quote.outputAmount,
-      txHash: intent.privacyLevel === "transparent" ? txHash : void 0,
-      fulfillmentProof: {
-        type: "fulfillment",
-        proof: `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(128))}`,
-        publicInputs: [
-          `0x${(0, import_utils10.bytesToHex)(new TextEncoder().encode(intent.intentId))}`,
-          `0x${(0, import_utils10.bytesToHex)(new TextEncoder().encode(quote.quoteId))}`
-        ]
-      },
-      fulfilledAt: Math.floor(Date.now() / 1e3)
+    const quote = this.quotes.get(swap.quoteId);
+    if (!quote) {
+      throw new ValidationError(
+        "Quote not found for swap",
+        "quoteId",
+        { quoteId: swap.quoteId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    const status = {
+      swapId: swap.swapId,
+      status: swap.status,
+      quoteId: swap.quoteId,
+      depositAddress: swap.depositAddress,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      depositTxHash: swap.depositTxHash,
+      settlementTxHash: swap.settlementTxHash,
+      actualAmountOut: swap.actualAmountOut,
+      errorMessage: swap.errorMessage,
+      updatedAt: Math.floor(Date.now() / 1e3),
+      metadata: swap.metadata
     };
+    return status;
   }
   /**
-   * Cancel a pending fulfillment
+   * Wait for swap completion
    */
-  async cancel(intentId) {
-    const status = this.pendingFulfillments.get(intentId);
-    if (!status || status.status !== "pending") {
-      return false;
+  async waitForCompletion(swapId, options) {
+    const interval = options?.interval ?? 5e3;
+    const timeout = options?.timeout ?? 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const status2 = await this.getStatus(swapId);
+      if (options?.onStatusChange) {
+        options.onStatusChange(status2);
+      }
+      if (status2.status === "success" /* SUCCESS */) {
+        return status2;
+      }
+      if (status2.status === "failed" /* FAILED */ || status2.status === "cancelled" /* CANCELLED */ || status2.status === "refunded" /* REFUNDED */) {
+        return status2;
+      }
+      await this.delay(interval);
     }
-    status.status = "cancelled";
-    return true;
+    const status = await this.getStatus(swapId);
+    return status;
   }
   /**
-   * Get fulfillment status
+   * Notify backend of deposit
    */
-  async getStatus(intentId) {
-    return this.pendingFulfillments.get(intentId) ?? null;
+  async notifyDeposit(swapId, txHash, metadata) {
+    const swap = this.swaps.get(swapId);
+    if (!swap) {
+      throw new ValidationError(
+        "Swap not found",
+        "swapId",
+        { swapId },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    swap.depositTxHash = txHash;
+    swap.status = "deposit_confirmed" /* DEPOSIT_CONFIRMED */;
+    if (metadata) {
+      swap.metadata = { ...swap.metadata, ...metadata };
+    }
+    this.swaps.set(swapId, swap);
+    const quote = this.quotes.get(swap.quoteId);
+    if (quote) {
+      this.simulateSwapExecution(swapId, quote);
+    }
   }
-  /**
-   * Reset solver state (for testing)
-   */
-  reset() {
-    this.pendingFulfillments.clear();
+  // ─── Private Helpers ───────────────────────────────────────────────────────
+  validateQuoteParams(params) {
+    if (params.fromChain !== "zcash") {
+      throw new ValidationError(
+        "Source chain must be zcash",
+        "fromChain",
+        { received: params.fromChain, expected: "zcash" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (params.toChain !== "zcash") {
+      throw new ValidationError(
+        "Destination chain must be zcash",
+        "toChain",
+        { received: params.toChain, expected: "zcash" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (params.fromToken !== "ZEC") {
+      throw new ValidationError(
+        "Source token must be ZEC",
+        "fromToken",
+        { received: params.fromToken, expected: "ZEC" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (params.toToken !== "ZEC") {
+      throw new ValidationError(
+        "Destination token must be ZEC",
+        "toToken",
+        { received: params.toToken, expected: "ZEC" },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+    if (!params.amount || params.amount <= BigInt(0)) {
+      throw new ValidationError(
+        "Amount must be positive",
+        "amount",
+        { received: params.amount },
+        "SIP_2004" /* INVALID_AMOUNT */
+      );
+    }
+    if (!this.capabilities.supportedPrivacyLevels.includes(params.privacyLevel)) {
+      throw new ValidationError(
+        "Unsupported privacy level",
+        "privacyLevel",
+        { received: params.privacyLevel, supported: this.capabilities.supportedPrivacyLevels },
+        "SIP_2000" /* VALIDATION_FAILED */
+      );
+    }
+  }
+  simulateSwapExecution(swapId, quote) {
+    setTimeout(() => {
+      const swap = this.swaps.get(swapId);
+      if (!swap) return;
+      swap.status = "in_progress" /* IN_PROGRESS */;
+      this.swaps.set(swapId, swap);
+      setTimeout(() => {
+        const finalSwap = this.swaps.get(swapId);
+        if (!finalSwap) return;
+        finalSwap.status = "success" /* SUCCESS */;
+        finalSwap.settlementTxHash = this.randomHex(64);
+        finalSwap.actualAmountOut = quote.amountOut;
+        this.swaps.set(swapId, finalSwap);
+      }, 2e3);
+    }, 1e3);
+  }
+  generateQuoteId() {
+    return `zec_native_quote_${Date.now()}_${this.randomHex(8)}`;
+  }
+  generateSwapId() {
+    return `zec_native_swap_${Date.now()}_${this.randomHex(8)}`;
+  }
+  randomHex(length) {
+    const chars = "0123456789abcdef";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+  }
+  randomBase58(length) {
+    const chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
-function createMockSolver(config) {
-  return new MockSolver(config);
+function createZcashNativeBackend(config) {
+  return new ZcashNativeBackend(config);
 }
 
-// src/index.ts
-var import_types38 = require("@sip-protocol/types");
+// src/settlement/backends/direct-chain.ts
+var import_types10 = require("@sip-protocol/types");
+var import_utils11 = require("@noble/hashes/utils");
+var DEFAULT_GAS_FEES = {
+  ethereum: 21000n * 50n * 1000000000n,
+  // 21k gas * 50 gwei = 0.00105 ETH
+  solana: 5000n,
+  // 5000 lamports = 0.000005 SOL
+  near: 300000000000000000000n,
+  // 0.3 NEAR in yoctoNEAR
+  zcash: 10000n,
+  // 0.0001 ZEC in zatoshi
+  polygon: 21000n * 30n * 1000000000n,
+  // 21k gas * 30 gwei POL
+  arbitrum: 2100000000n,
+  // 21k gas * 0.1 gwei ETH = 2100 gwei = 2.1e9 wei
+  optimism: 21000000n,
+  // 21k gas * 0.001 gwei ETH = 21 gwei = 21e6 wei
+  base: 2100000000n,
+  // 21k gas * 0.1 gwei ETH = 2100 gwei = 2.1e9 wei
+  bitcoin: 10000n
+  // 10000 sats = 0.0001 BTC (estimate for 1 input, 2 outputs)
+};
 
 // src/zcash/rpc-client.ts
-var import_types8 = require("@sip-protocol/types");
+var import_types11 = require("@sip-protocol/types");
 var DEFAULT_CONFIG = {
   host: "127.0.0.1",
   port: 8232,
@@ -4272,19 +5398,19 @@ var ZcashRPCError = class extends Error {
    * Check if error is due to insufficient funds
    */
   isInsufficientFunds() {
-    return this.code === import_types8.ZcashErrorCode.WALLET_INSUFFICIENT_FUNDS;
+    return this.code === import_types11.ZcashErrorCode.WALLET_INSUFFICIENT_FUNDS;
   }
   /**
    * Check if error is due to invalid address
    */
   isInvalidAddress() {
-    return this.code === import_types8.ZcashErrorCode.INVALID_ADDRESS_OR_KEY;
+    return this.code === import_types11.ZcashErrorCode.INVALID_ADDRESS_OR_KEY;
   }
   /**
    * Check if error is due to wallet being locked
    */
   isWalletLocked() {
-    return this.code === import_types8.ZcashErrorCode.WALLET_UNLOCK_NEEDED;
+    return this.code === import_types11.ZcashErrorCode.WALLET_UNLOCK_NEEDED;
   }
 };
 var ZcashRPCClient = class {
@@ -4671,7 +5797,7 @@ function createZcashClient(config) {
 }
 
 // src/zcash/shielded-service.ts
-var import_types9 = require("@sip-protocol/types");
+var import_types12 = require("@sip-protocol/types");
 var ZcashShieldedService = class _ZcashShieldedService {
   client;
   config;
@@ -4857,7 +5983,7 @@ var ZcashShieldedService = class _ZcashShieldedService {
    * Higher-level method that handles privacy level mapping.
    */
   async sendWithPrivacy(to, amount, privacyLevel, memo) {
-    if (privacyLevel === import_types9.PrivacyLevel.TRANSPARENT) {
+    if (privacyLevel === import_types12.PrivacyLevel.TRANSPARENT) {
       throw new ValidationError(
         "Transparent mode not supported for Zcash shielded service. Use standard RPC client.",
         "privacyLevel",
@@ -4951,7 +6077,7 @@ var ZcashShieldedService = class _ZcashShieldedService {
     const viewingKey = await this.exportViewingKey();
     return {
       viewingKey,
-      privacyLevel: import_types9.PrivacyLevel.COMPLIANT,
+      privacyLevel: import_types12.PrivacyLevel.COMPLIANT,
       disclaimer: "This viewing key provides read-only access to transaction history. It cannot be used to spend funds. Share only with authorized auditors."
     };
   }
@@ -5037,11 +6163,11 @@ var ZcashShieldedService = class _ZcashShieldedService {
    */
   mapPrivacyLevelToPolicy(level) {
     switch (level) {
-      case import_types9.PrivacyLevel.TRANSPARENT:
+      case import_types12.PrivacyLevel.TRANSPARENT:
         return "NoPrivacy";
-      case import_types9.PrivacyLevel.SHIELDED:
+      case import_types12.PrivacyLevel.SHIELDED:
         return "FullPrivacy";
-      case import_types9.PrivacyLevel.COMPLIANT:
+      case import_types12.PrivacyLevel.COMPLIANT:
         return "FullPrivacy";
       default:
         return "FullPrivacy";
@@ -5094,7 +6220,7 @@ function createZcashShieldedService(config) {
 }
 
 // src/zcash/swap-service.ts
-var import_types10 = require("@sip-protocol/types");
+var import_types13 = require("@sip-protocol/types");
 var MOCK_PRICES = {
   ETH: 2500,
   SOL: 120,
@@ -5122,6 +6248,12 @@ var ZcashSwapService = class {
   quotes = /* @__PURE__ */ new Map();
   swaps = /* @__PURE__ */ new Map();
   constructor(config) {
+    if (config.mode === "production" && !config.bridgeProvider) {
+      throw new IntentError(
+        "Bridge provider required for production mode",
+        "SIP_5004" /* INTENT_INVALID_STATE */
+      );
+    }
     this.config = {
       mode: config.mode,
       defaultSlippage: config.defaultSlippage ?? 100,
@@ -5201,7 +6333,7 @@ var ZcashSwapService = class {
       validUntil,
       depositAddress: this.generateMockDepositAddress(sourceChain),
       estimatedTime: this.getEstimatedTime(sourceChain),
-      privacyLevel: import_types10.PrivacyLevel.SHIELDED
+      privacyLevel: import_types13.PrivacyLevel.SHIELDED
     };
     this.quotes.set(quoteId, quote);
     return quote;
@@ -5244,7 +6376,7 @@ var ZcashSwapService = class {
       depositAddress: "",
       // Will be set by bridge
       estimatedTime: this.getEstimatedTime(params.sourceChain),
-      privacyLevel: import_types10.PrivacyLevel.SHIELDED
+      privacyLevel: import_types13.PrivacyLevel.SHIELDED
     };
     this.quotes.set(quote.quoteId, quote);
     return quote;
@@ -5524,15 +6656,15 @@ function createZcashSwapService(config) {
 }
 
 // src/zcash/index.ts
-var import_types11 = require("@sip-protocol/types");
+var import_types14 = require("@sip-protocol/types");
 
 // src/index.ts
-var import_types39 = require("@sip-protocol/types");
+var import_types42 = require("@sip-protocol/types");
 
 // src/payment/payment.ts
-var import_types12 = require("@sip-protocol/types");
+var import_types15 = require("@sip-protocol/types");
 var import_sha2569 = require("@noble/hashes/sha256");
-var import_utils11 = require("@noble/hashes/utils");
+var import_utils12 = require("@noble/hashes/utils");
 var import_chacha2 = require("@noble/ciphers/chacha.js");
 var import_hkdf2 = require("@noble/hashes/hkdf");
 
@@ -5717,7 +6849,7 @@ var PaymentBuilder = class {
   _amount;
   _recipientMetaAddress;
   _recipientAddress;
-  _privacy = import_types12.PrivacyLevel.SHIELDED;
+  _privacy = import_types15.PrivacyLevel.SHIELDED;
   _viewingKey;
   _sourceChain;
   _destinationChain;
@@ -6000,7 +7132,7 @@ async function createShieldedPayment(params, options) {
   } else {
     resolvedToken = token;
   }
-  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && !recipientMetaAddress) {
+  if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && !recipientMetaAddress) {
     throw new ValidationError(
       "recipientMetaAddress is required for shielded/compliant privacy modes",
       "recipientMetaAddress",
@@ -6008,7 +7140,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === import_types12.PrivacyLevel.TRANSPARENT && !recipientAddress) {
+  if (privacy === import_types15.PrivacyLevel.TRANSPARENT && !recipientAddress) {
     throw new ValidationError(
       "recipientAddress is required for transparent mode",
       "recipientAddress",
@@ -6016,7 +7148,7 @@ async function createShieldedPayment(params, options) {
       "SIP_2008" /* MISSING_REQUIRED */
     );
   }
-  if (privacy === import_types12.PrivacyLevel.COMPLIANT && !viewingKey) {
+  if (privacy === import_types15.PrivacyLevel.COMPLIANT && !viewingKey) {
     throw new ValidationError(
       "viewingKey is required for compliant mode",
       "viewingKey",
@@ -6028,8 +7160,8 @@ async function createShieldedPayment(params, options) {
   let viewingKeyHash;
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-    const keyBytes = (0, import_utils11.hexToBytes)(keyHex);
-    viewingKeyHash = `0x${(0, import_utils11.bytesToHex)((0, import_sha2569.sha256)(keyBytes))}`;
+    const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
+    viewingKeyHash = `0x${(0, import_utils12.bytesToHex)((0, import_sha2569.sha256)(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -6038,7 +7170,7 @@ async function createShieldedPayment(params, options) {
   const now = Math.floor(Date.now() / 1e3);
   const payment = {
     paymentId,
-    version: import_types12.SIP_VERSION,
+    version: import_types15.SIP_VERSION,
     privacyLevel: privacy,
     createdAt: now,
     expiry: now + ttl,
@@ -6049,7 +7181,7 @@ async function createShieldedPayment(params, options) {
     purpose,
     viewingKeyHash
   };
-  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && recipientMetaAddress) {
+  if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && recipientMetaAddress) {
     const metaAddress = decodeStealthMetaAddress(recipientMetaAddress);
     const { stealthAddress } = generateStealthAddress(metaAddress);
     payment.recipientStealth = stealthAddress;
@@ -6066,10 +7198,10 @@ async function createShieldedPayment(params, options) {
     payment.recipientAddress = recipientAddress;
     payment.memo = memo;
   }
-  if (privacy !== import_types12.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
+  if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-      return (0, import_utils11.hexToBytes)(cleanHex);
+      return (0, import_utils12.hexToBytes)(cleanHex);
     };
     const fundingResult = await proofProvider.generateFundingProof({
       balance: amount,
@@ -6096,17 +7228,17 @@ async function createShieldedPayment(params, options) {
 }
 function encryptMemo(memo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils11.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
   const encKey = (0, import_hkdf2.hkdf)(import_sha2569.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
-    const nonce = (0, import_utils11.randomBytes)(24);
+    const nonce = (0, import_utils12.randomBytes)(24);
     const cipher = (0, import_chacha2.xchacha20poly1305)(encKey, nonce);
     const plaintext = new TextEncoder().encode(memo);
     const ciphertext = cipher.encrypt(plaintext);
     const result = new Uint8Array(nonce.length + ciphertext.length);
     result.set(nonce);
     result.set(ciphertext, nonce.length);
-    return `0x${(0, import_utils11.bytesToHex)(result)}`;
+    return `0x${(0, import_utils12.bytesToHex)(result)}`;
   } finally {
     secureWipe(keyBytes);
     secureWipe(encKey);
@@ -6114,11 +7246,11 @@ function encryptMemo(memo, viewingKey) {
 }
 function decryptMemo(encryptedMemo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils11.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
   const encKey = (0, import_hkdf2.hkdf)(import_sha2569.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
     const dataHex = encryptedMemo.startsWith("0x") ? encryptedMemo.slice(2) : encryptedMemo;
-    const data = (0, import_utils11.hexToBytes)(dataHex);
+    const data = (0, import_utils12.hexToBytes)(dataHex);
     const nonce = data.slice(0, 24);
     const ciphertext = data.slice(24);
     const cipher = (0, import_chacha2.xchacha20poly1305)(encKey, nonce);
@@ -6132,7 +7264,7 @@ function decryptMemo(encryptedMemo, viewingKey) {
 function trackPayment(payment) {
   return {
     ...payment,
-    status: import_types12.PaymentStatus.DRAFT
+    status: import_types15.PaymentStatus.DRAFT
   };
 }
 function isPaymentExpired(payment) {
@@ -6165,10 +7297,10 @@ function getPaymentSummary(payment) {
 }
 
 // src/treasury/treasury.ts
-var import_types13 = require("@sip-protocol/types");
+var import_types16 = require("@sip-protocol/types");
 var import_secp256k13 = require("@noble/curves/secp256k1");
 var import_sha25610 = require("@noble/hashes/sha256");
-var import_utils12 = require("@noble/hashes/utils");
+var import_utils13 = require("@noble/hashes/utils");
 var DEFAULT_PROPOSAL_TTL = 7 * 24 * 60 * 60;
 var Treasury = class _Treasury {
   config;
@@ -6198,7 +7330,7 @@ var Treasury = class _Treasury {
         ...m,
         addedAt: now
       })),
-      defaultPrivacy: params.defaultPrivacy ?? import_types13.PrivacyLevel.SHIELDED,
+      defaultPrivacy: params.defaultPrivacy ?? import_types16.PrivacyLevel.SHIELDED,
       masterViewingKey,
       dailyLimit: params.dailyLimit,
       transactionLimit: params.transactionLimit,
@@ -6277,7 +7409,7 @@ var Treasury = class _Treasury {
       proposalId,
       treasuryId: this.config.treasuryId,
       type: "payment",
-      status: import_types13.ProposalStatus.PENDING,
+      status: import_types16.ProposalStatus.PENDING,
       proposer: "",
       // Should be set by caller
       title: params.title,
@@ -6310,7 +7442,7 @@ var Treasury = class _Treasury {
       proposalId,
       treasuryId: this.config.treasuryId,
       type: "batch_payment",
-      status: import_types13.ProposalStatus.PENDING,
+      status: import_types16.ProposalStatus.PENDING,
       proposer: "",
       title: params.title,
       description: params.description,
@@ -6344,7 +7476,7 @@ var Treasury = class _Treasury {
    * Get pending proposals
    */
   getPendingProposals() {
-    return this.getAllProposals().filter((p) => p.status === import_types13.ProposalStatus.PENDING);
+    return this.getAllProposals().filter((p) => p.status === import_types16.ProposalStatus.PENDING);
   }
   /**
    * Sign a proposal
@@ -6375,7 +7507,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types13.ProposalStatus.PENDING) {
+    if (proposal.status !== import_types16.ProposalStatus.PENDING) {
       throw new ValidationError(
         `proposal is not pending: ${proposal.status}`,
         "proposalId",
@@ -6385,7 +7517,7 @@ var Treasury = class _Treasury {
     }
     const now = Math.floor(Date.now() / 1e3);
     if (now > proposal.expiresAt) {
-      proposal.status = import_types13.ProposalStatus.EXPIRED;
+      proposal.status = import_types16.ProposalStatus.EXPIRED;
       throw new ValidationError(
         "proposal has expired",
         "proposalId",
@@ -6417,9 +7549,9 @@ var Treasury = class _Treasury {
     const approvals = proposal.signatures.filter((s) => s.approved).length;
     const rejections = proposal.signatures.filter((s) => !s.approved).length;
     if (approvals >= proposal.requiredSignatures) {
-      proposal.status = import_types13.ProposalStatus.APPROVED;
+      proposal.status = import_types16.ProposalStatus.APPROVED;
     } else if (rejections > this.config.totalSigners - proposal.requiredSignatures) {
-      proposal.status = import_types13.ProposalStatus.REJECTED;
+      proposal.status = import_types16.ProposalStatus.REJECTED;
     }
     return proposal;
   }
@@ -6436,7 +7568,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types13.ProposalStatus.APPROVED) {
+    if (proposal.status !== import_types16.ProposalStatus.APPROVED) {
       throw new ValidationError(
         `proposal is not approved: ${proposal.status}`,
         "proposalId",
@@ -6449,8 +7581,8 @@ var Treasury = class _Treasury {
       const payment = await createShieldedPayment({
         token: proposal.payment.token,
         amount: proposal.payment.amount,
-        recipientMetaAddress: proposal.payment.privacy !== import_types13.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
-        recipientAddress: proposal.payment.privacy === import_types13.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
+        recipientMetaAddress: proposal.payment.privacy !== import_types16.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
+        recipientAddress: proposal.payment.privacy === import_types16.PrivacyLevel.TRANSPARENT ? proposal.payment.recipient : void 0,
         privacy: proposal.payment.privacy,
         viewingKey: this.config.masterViewingKey?.key,
         sourceChain: this.config.chain,
@@ -6463,8 +7595,8 @@ var Treasury = class _Treasury {
         const payment = await createShieldedPayment({
           token: proposal.batchPayment.token,
           amount: recipient.amount,
-          recipientMetaAddress: proposal.batchPayment.privacy !== import_types13.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
-          recipientAddress: proposal.batchPayment.privacy === import_types13.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
+          recipientMetaAddress: proposal.batchPayment.privacy !== import_types16.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
+          recipientAddress: proposal.batchPayment.privacy === import_types16.PrivacyLevel.TRANSPARENT ? recipient.address : void 0,
           privacy: proposal.batchPayment.privacy,
           viewingKey: this.config.masterViewingKey?.key,
           sourceChain: this.config.chain,
@@ -6474,7 +7606,7 @@ var Treasury = class _Treasury {
         payments.push(payment);
       }
     }
-    proposal.status = import_types13.ProposalStatus.EXECUTED;
+    proposal.status = import_types16.ProposalStatus.EXECUTED;
     proposal.executedAt = Math.floor(Date.now() / 1e3);
     proposal.resultPayments = payments;
     return payments;
@@ -6503,7 +7635,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    if (proposal.status !== import_types13.ProposalStatus.PENDING) {
+    if (proposal.status !== import_types16.ProposalStatus.PENDING) {
       throw new ValidationError(
         `proposal is not pending: ${proposal.status}`,
         "proposalId",
@@ -6511,7 +7643,7 @@ var Treasury = class _Treasury {
         "SIP_2001" /* INVALID_INPUT */
       );
     }
-    proposal.status = import_types13.ProposalStatus.CANCELLED;
+    proposal.status = import_types16.ProposalStatus.CANCELLED;
     return proposal;
   }
   // ─── Auditor Access ──────────────────────────────────────────────────────────
@@ -6608,7 +7740,7 @@ var Treasury = class _Treasury {
   getCommittedAmount(token) {
     let committed = 0n;
     for (const proposal of this.proposals.values()) {
-      if (proposal.status !== import_types13.ProposalStatus.PENDING) continue;
+      if (proposal.status !== import_types16.ProposalStatus.PENDING) continue;
       if (proposal.type === "payment" && proposal.payment) {
         if (proposal.payment.token.symbol === token.symbol && proposal.payment.token.chain === token.chain) {
           committed += proposal.payment.amount;
@@ -6659,12 +7791,12 @@ var Treasury = class _Treasury {
   }
 };
 function generateTreasuryId() {
-  const bytes = (0, import_utils12.randomBytes)(16);
-  return `treasury_${(0, import_utils12.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils13.randomBytes)(16);
+  return `treasury_${(0, import_utils13.bytesToHex)(bytes)}`;
 }
 function generateProposalId() {
-  const bytes = (0, import_utils12.randomBytes)(16);
-  return `prop_${(0, import_utils12.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils13.randomBytes)(16);
+  return `prop_${(0, import_utils13.bytesToHex)(bytes)}`;
 }
 function computeProposalHash(proposal) {
   const data = JSON.stringify({
@@ -6680,7 +7812,7 @@ function computeProposalHash(proposal) {
 }
 function signMessage(messageHash, privateKey) {
   const keyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils13.hexToBytes)(keyHex);
   try {
     const signature = import_secp256k13.secp256k1.sign(messageHash, keyBytes);
     return `0x${signature.toCompactHex()}`;
@@ -6692,8 +7824,8 @@ function verifySignature(messageHash, signature, publicKey) {
   const sigHex = signature.startsWith("0x") ? signature.slice(2) : signature;
   const pubKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
   try {
-    const sigBytes = (0, import_utils12.hexToBytes)(sigHex);
-    const pubKeyBytes = (0, import_utils12.hexToBytes)(pubKeyHex);
+    const sigBytes = (0, import_utils13.hexToBytes)(sigHex);
+    const pubKeyBytes = (0, import_utils13.hexToBytes)(pubKeyHex);
     return import_secp256k13.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
   } catch {
     return false;
@@ -6851,8 +7983,8 @@ function validateBatchProposalParams(params, config) {
 }
 
 // src/compliance/compliance-manager.ts
-var import_types14 = require("@sip-protocol/types");
-var import_utils13 = require("@noble/hashes/utils");
+var import_types17 = require("@sip-protocol/types");
+var import_utils14 = require("@noble/hashes/utils");
 var DEFAULTS2 = {
   riskThreshold: 70,
   highValueThreshold: 10000000000n,
@@ -7219,7 +8351,7 @@ var ComplianceManager = class _ComplianceManager {
       title: params.title,
       description: params.description,
       format: params.format,
-      status: import_types14.ReportStatus.GENERATING,
+      status: import_types17.ReportStatus.GENERATING,
       requestedBy,
       requestedAt: now,
       startDate: params.startDate,
@@ -7248,10 +8380,10 @@ var ComplianceManager = class _ComplianceManager {
       } else if (params.format === "csv") {
         report.content = this.generateCSV(transactions);
       }
-      report.status = import_types14.ReportStatus.COMPLETED;
+      report.status = import_types17.ReportStatus.COMPLETED;
       report.generatedAt = Math.floor(Date.now() / 1e3);
     } catch (error) {
-      report.status = import_types14.ReportStatus.FAILED;
+      report.status = import_types17.ReportStatus.FAILED;
       report.error = error instanceof Error ? error.message : "Unknown error";
     }
     this.addAuditLog(requestedBy, "report_generated", {
@@ -7526,7 +8658,7 @@ var ComplianceManager = class _ComplianceManager {
   }
 };
 function generateId(prefix) {
-  return `${prefix}_${(0, import_utils13.bytesToHex)((0, import_utils13.randomBytes)(12))}`;
+  return `${prefix}_${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(12))}`;
 }
 function validateRegisterAuditorParams(params) {
   if (!params.organization?.trim()) {
@@ -7614,10 +8746,10 @@ function validateReportParams(params) {
 }
 
 // src/wallet/errors.ts
-var import_types15 = require("@sip-protocol/types");
+var import_types18 = require("@sip-protocol/types");
 var WalletError = class extends SIPError {
   walletCode;
-  constructor(message, walletCode = import_types15.WalletErrorCode.UNKNOWN, options) {
+  constructor(message, walletCode = import_types18.WalletErrorCode.UNKNOWN, options) {
     super(message, "SIP_7000" /* WALLET_ERROR */, options);
     this.walletCode = walletCode;
     this.name = "WalletError";
@@ -7627,10 +8759,10 @@ var WalletError = class extends SIPError {
    */
   isConnectionError() {
     const codes = [
-      import_types15.WalletErrorCode.NOT_INSTALLED,
-      import_types15.WalletErrorCode.CONNECTION_REJECTED,
-      import_types15.WalletErrorCode.CONNECTION_FAILED,
-      import_types15.WalletErrorCode.NOT_CONNECTED
+      import_types18.WalletErrorCode.NOT_INSTALLED,
+      import_types18.WalletErrorCode.CONNECTION_REJECTED,
+      import_types18.WalletErrorCode.CONNECTION_FAILED,
+      import_types18.WalletErrorCode.NOT_CONNECTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -7639,9 +8771,9 @@ var WalletError = class extends SIPError {
    */
   isSigningError() {
     const codes = [
-      import_types15.WalletErrorCode.SIGNING_REJECTED,
-      import_types15.WalletErrorCode.SIGNING_FAILED,
-      import_types15.WalletErrorCode.INVALID_MESSAGE
+      import_types18.WalletErrorCode.SIGNING_REJECTED,
+      import_types18.WalletErrorCode.SIGNING_FAILED,
+      import_types18.WalletErrorCode.INVALID_MESSAGE
     ];
     return codes.includes(this.walletCode);
   }
@@ -7650,10 +8782,10 @@ var WalletError = class extends SIPError {
    */
   isTransactionError() {
     const codes = [
-      import_types15.WalletErrorCode.INSUFFICIENT_FUNDS,
-      import_types15.WalletErrorCode.TRANSACTION_REJECTED,
-      import_types15.WalletErrorCode.TRANSACTION_FAILED,
-      import_types15.WalletErrorCode.INVALID_TRANSACTION
+      import_types18.WalletErrorCode.INSUFFICIENT_FUNDS,
+      import_types18.WalletErrorCode.TRANSACTION_REJECTED,
+      import_types18.WalletErrorCode.TRANSACTION_FAILED,
+      import_types18.WalletErrorCode.INVALID_TRANSACTION
     ];
     return codes.includes(this.walletCode);
   }
@@ -7662,9 +8794,9 @@ var WalletError = class extends SIPError {
    */
   isPrivacyError() {
     const codes = [
-      import_types15.WalletErrorCode.STEALTH_NOT_SUPPORTED,
-      import_types15.WalletErrorCode.VIEWING_KEY_NOT_SUPPORTED,
-      import_types15.WalletErrorCode.SHIELDED_NOT_SUPPORTED
+      import_types18.WalletErrorCode.STEALTH_NOT_SUPPORTED,
+      import_types18.WalletErrorCode.VIEWING_KEY_NOT_SUPPORTED,
+      import_types18.WalletErrorCode.SHIELDED_NOT_SUPPORTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -7673,10 +8805,10 @@ var WalletError = class extends SIPError {
    */
   isUserRejection() {
     const codes = [
-      import_types15.WalletErrorCode.CONNECTION_REJECTED,
-      import_types15.WalletErrorCode.SIGNING_REJECTED,
-      import_types15.WalletErrorCode.TRANSACTION_REJECTED,
-      import_types15.WalletErrorCode.CHAIN_SWITCH_REJECTED
+      import_types18.WalletErrorCode.CONNECTION_REJECTED,
+      import_types18.WalletErrorCode.SIGNING_REJECTED,
+      import_types18.WalletErrorCode.TRANSACTION_REJECTED,
+      import_types18.WalletErrorCode.CHAIN_SWITCH_REJECTED
     ];
     return codes.includes(this.walletCode);
   }
@@ -7684,15 +8816,15 @@ var WalletError = class extends SIPError {
 function notConnectedError() {
   return new WalletError(
     "Wallet not connected. Call connect() first.",
-    import_types15.WalletErrorCode.NOT_CONNECTED
+    import_types18.WalletErrorCode.NOT_CONNECTED
   );
 }
-function featureNotSupportedError(feature, code = import_types15.WalletErrorCode.UNKNOWN) {
+function featureNotSupportedError(feature, code = import_types18.WalletErrorCode.UNKNOWN) {
   return new WalletError(`${feature} is not supported by this wallet`, code);
 }
 
 // src/wallet/base-adapter.ts
-var import_types16 = require("@sip-protocol/types");
+var import_types19 = require("@sip-protocol/types");
 var BaseWalletAdapter = class {
   _address = "";
   _publicKey = "";
@@ -7855,12 +8987,12 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
     this._connectionState = "connecting";
     if (this.shouldFailConnect) {
       this.setError(
-        import_types16.WalletErrorCode.CONNECTION_FAILED,
+        import_types19.WalletErrorCode.CONNECTION_FAILED,
         "Mock connection failure"
       );
       throw new WalletError(
         "Mock connection failure",
-        import_types16.WalletErrorCode.CONNECTION_FAILED
+        import_types19.WalletErrorCode.CONNECTION_FAILED
       );
     }
     await new Promise((resolve) => setTimeout(resolve, 10));
@@ -7872,7 +9004,7 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
   async signMessage(message) {
     this.requireConnected();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types16.WalletErrorCode.SIGNING_FAILED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_FAILED);
     }
     const mockSig = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
@@ -7887,7 +9019,7 @@ var MockWalletAdapter = class extends BaseWalletAdapter {
   async signTransaction(tx) {
     this.requireConnected();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types16.WalletErrorCode.SIGNING_FAILED);
+      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_FAILED);
     }
     const signature = await this.signMessage(
       new TextEncoder().encode(JSON.stringify(tx.data))
@@ -8069,7 +9201,7 @@ function isPrivateWalletAdapter(adapter) {
 }
 
 // src/wallet/solana/adapter.ts
-var import_types17 = require("@sip-protocol/types");
+var import_types20 = require("@sip-protocol/types");
 
 // src/wallet/solana/types.ts
 function getSolanaProvider(wallet = "phantom") {
@@ -8190,19 +9322,19 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
       }
       if (!this.provider) {
         this.setError(
-          import_types17.WalletErrorCode.NOT_INSTALLED,
+          import_types20.WalletErrorCode.NOT_INSTALLED,
           `${this.walletName} wallet is not installed`
         );
         throw new WalletError(
           `${this.walletName} wallet is not installed`,
-          import_types17.WalletErrorCode.NOT_INSTALLED
+          import_types20.WalletErrorCode.NOT_INSTALLED
         );
       }
       const { publicKey } = await this.provider.connect();
       if (!publicKey) {
         throw new WalletError(
           "No public key returned from wallet",
-          import_types17.WalletErrorCode.CONNECTION_FAILED
+          import_types20.WalletErrorCode.CONNECTION_FAILED
         );
       }
       this.setupEventHandlers();
@@ -8212,11 +9344,11 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Connection failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        this.setError(import_types17.WalletErrorCode.CONNECTION_REJECTED, message);
-        throw new WalletError(message, import_types17.WalletErrorCode.CONNECTION_REJECTED);
+        this.setError(import_types20.WalletErrorCode.CONNECTION_REJECTED, message);
+        throw new WalletError(message, import_types20.WalletErrorCode.CONNECTION_REJECTED);
       }
-      this.setError(import_types17.WalletErrorCode.CONNECTION_FAILED, message);
-      throw error instanceof WalletError ? error : new WalletError(message, import_types17.WalletErrorCode.CONNECTION_FAILED, { cause: error });
+      this.setError(import_types20.WalletErrorCode.CONNECTION_FAILED, message);
+      throw error instanceof WalletError ? error : new WalletError(message, import_types20.WalletErrorCode.CONNECTION_FAILED, { cause: error });
     }
   }
   /**
@@ -8239,7 +9371,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signMessage(message) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const { signature } = await this.provider.signMessage(message);
@@ -8250,9 +9382,9 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message2 = error instanceof Error ? error.message : "Signing failed";
       if (message2.includes("User rejected") || message2.includes("rejected")) {
-        throw new WalletError(message2, import_types17.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message2, import_types20.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message2, import_types17.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message2, import_types20.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -8265,7 +9397,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signTransaction(tx) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const solTx = tx.data;
@@ -8284,9 +9416,9 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Signing failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -8297,7 +9429,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signAndSendTransaction(tx) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       const solTx = tx.data;
@@ -8312,12 +9444,12 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       const message = error instanceof Error ? error.message : "Transaction failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.TRANSACTION_REJECTED);
+        throw new WalletError(message, import_types20.WalletErrorCode.TRANSACTION_REJECTED);
       }
       if (message.includes("insufficient") || message.includes("Insufficient")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.INSUFFICIENT_FUNDS);
+        throw new WalletError(message, import_types20.WalletErrorCode.INSUFFICIENT_FUNDS);
       }
-      throw new WalletError(message, import_types17.WalletErrorCode.TRANSACTION_FAILED, {
+      throw new WalletError(message, import_types20.WalletErrorCode.TRANSACTION_FAILED, {
         cause: error
       });
     }
@@ -8330,16 +9462,16 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
   async signAllTransactions(transactions) {
     this.requireConnected();
     if (!this.provider) {
-      throw new WalletError("Provider not available", import_types17.WalletErrorCode.NOT_CONNECTED);
+      throw new WalletError("Provider not available", import_types20.WalletErrorCode.NOT_CONNECTED);
     }
     try {
       return await this.provider.signAllTransactions(transactions);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Signing failed";
       if (message.includes("User rejected") || message.includes("rejected")) {
-        throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_REJECTED);
+        throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_REJECTED);
       }
-      throw new WalletError(message, import_types17.WalletErrorCode.SIGNING_FAILED, {
+      throw new WalletError(message, import_types20.WalletErrorCode.SIGNING_FAILED, {
         cause: error
       });
     }
@@ -8360,7 +9492,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         "Failed to get balance",
-        import_types17.WalletErrorCode.UNKNOWN,
+        import_types20.WalletErrorCode.UNKNOWN,
         { cause: error }
       );
     }
@@ -8373,7 +9505,7 @@ var SolanaWalletAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "solana") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Solana adapter`,
-        import_types17.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types20.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8491,7 +9623,7 @@ function createSolanaAdapter(config = {}) {
 }
 
 // src/wallet/solana/mock.ts
-var import_types19 = require("@sip-protocol/types");
+var import_types22 = require("@sip-protocol/types");
 var MockPublicKey = class {
   base58;
   bytes;
@@ -8557,8 +9689,8 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this._connectionState = "connecting";
     await this.simulateLatency();
     if (this.shouldFailConnect) {
-      this.setError(import_types19.WalletErrorCode.CONNECTION_FAILED, "Mock connection failure");
-      throw new WalletError("Mock connection failure", import_types19.WalletErrorCode.CONNECTION_FAILED);
+      this.setError(import_types22.WalletErrorCode.CONNECTION_FAILED, "Mock connection failure");
+      throw new WalletError("Mock connection failure", import_types22.WalletErrorCode.CONNECTION_FAILED);
     }
     const hexPubKey = "0x" + Buffer.from(this.mockPublicKey.toBytes()).toString("hex");
     this.setConnected(this.mockAddress, hexPubKey);
@@ -8577,7 +9709,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     const mockSig = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
@@ -8595,7 +9727,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     const solTx = tx.data;
     this.signedTransactions.push(solTx);
@@ -8615,10 +9747,10 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     if (this.shouldFailTransaction) {
-      throw new WalletError("Mock transaction failure", import_types19.WalletErrorCode.TRANSACTION_FAILED);
+      throw new WalletError("Mock transaction failure", import_types22.WalletErrorCode.TRANSACTION_FAILED);
     }
     const txSig = `mock_tx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     this.sentTransactions.push(txSig);
@@ -8638,7 +9770,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     this.requireConnected();
     await this.simulateLatency();
     if (this.shouldFailSign) {
-      throw new WalletError("Mock signing failure", import_types19.WalletErrorCode.SIGNING_REJECTED);
+      throw new WalletError("Mock signing failure", import_types22.WalletErrorCode.SIGNING_REJECTED);
     }
     this.signedTransactions.push(...transactions);
     return transactions.map((tx) => {
@@ -8665,7 +9797,7 @@ var MockSolanaAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "solana") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Solana adapter`,
-        import_types19.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types22.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -8834,7 +9966,7 @@ function createMockSolanaAdapter(config = {}) {
 }
 
 // src/wallet/ethereum/adapter.ts
-var import_types21 = require("@sip-protocol/types");
+var import_types24 = require("@sip-protocol/types");
 
 // src/wallet/ethereum/types.ts
 var EthereumChainId = {
@@ -8976,7 +10108,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           `${this.walletType} wallet not found. Please install the extension.`,
-          import_types21.WalletErrorCode.NOT_INSTALLED
+          import_types24.WalletErrorCode.NOT_INSTALLED
         );
       }
       const accounts = await this.provider.request({
@@ -8986,7 +10118,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           "No accounts returned from wallet",
-          import_types21.WalletErrorCode.CONNECTION_REJECTED
+          import_types24.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       const address = normalizeAddress(accounts[0]);
@@ -9006,12 +10138,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected connection request",
-          import_types21.WalletErrorCode.CONNECTION_REJECTED
+          import_types24.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       throw new WalletError(
         `Failed to connect: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.CONNECTION_FAILED
+        import_types24.WalletErrorCode.CONNECTION_FAILED
       );
     }
   }
@@ -9031,7 +10163,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -9049,12 +10181,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected signing request",
-          import_types21.WalletErrorCode.SIGNING_REJECTED
+          import_types24.WalletErrorCode.SIGNING_REJECTED
         );
       }
       throw new WalletError(
         `Failed to sign message: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.SIGNING_FAILED
+        import_types24.WalletErrorCode.SIGNING_FAILED
       );
     }
   }
@@ -9066,7 +10198,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -9083,12 +10215,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected signing request",
-          import_types21.WalletErrorCode.SIGNING_REJECTED
+          import_types24.WalletErrorCode.SIGNING_REJECTED
         );
       }
       throw new WalletError(
         `Failed to sign typed data: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.SIGNING_FAILED
+        import_types24.WalletErrorCode.SIGNING_FAILED
       );
     }
   }
@@ -9100,7 +10232,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -9128,7 +10260,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected transaction signing",
-          import_types21.WalletErrorCode.SIGNING_REJECTED
+          import_types24.WalletErrorCode.SIGNING_REJECTED
         );
       }
       if (rpcError.code === -32601 || rpcError.message?.includes("not supported")) {
@@ -9146,7 +10278,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       }
       throw new WalletError(
         `Failed to sign transaction: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.TRANSACTION_FAILED
+        import_types24.WalletErrorCode.TRANSACTION_FAILED
       );
     }
   }
@@ -9158,7 +10290,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -9180,12 +10312,12 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected transaction",
-          import_types21.WalletErrorCode.TRANSACTION_REJECTED
+          import_types24.WalletErrorCode.TRANSACTION_REJECTED
         );
       }
       throw new WalletError(
         `Failed to send transaction: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.TRANSACTION_FAILED
+        import_types24.WalletErrorCode.TRANSACTION_FAILED
       );
     }
   }
@@ -9220,7 +10352,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         `Failed to fetch balance: ${String(error)}`,
-        import_types21.WalletErrorCode.UNKNOWN
+        import_types24.WalletErrorCode.UNKNOWN
       );
     }
   }
@@ -9232,7 +10364,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "ethereum") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Ethereum adapter`,
-        import_types21.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types24.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -9257,7 +10389,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     } catch (error) {
       throw new WalletError(
         `Failed to fetch token balance: ${String(error)}`,
-        import_types21.WalletErrorCode.UNKNOWN
+        import_types24.WalletErrorCode.UNKNOWN
       );
     }
   }
@@ -9269,7 +10401,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     if (!this.provider) {
       throw new WalletError(
         "Provider not available",
-        import_types21.WalletErrorCode.NOT_CONNECTED
+        import_types24.WalletErrorCode.NOT_CONNECTED
       );
     }
     try {
@@ -9284,18 +10416,18 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
       if (rpcError.code === 4001) {
         throw new WalletError(
           "User rejected chain switch",
-          import_types21.WalletErrorCode.CHAIN_SWITCH_REJECTED
+          import_types24.WalletErrorCode.CHAIN_SWITCH_REJECTED
         );
       }
       if (rpcError.code === 4902) {
         throw new WalletError(
           `Chain ${chainId} not added to wallet`,
-          import_types21.WalletErrorCode.UNSUPPORTED_CHAIN
+          import_types24.WalletErrorCode.UNSUPPORTED_CHAIN
         );
       }
       throw new WalletError(
         `Failed to switch chain: ${rpcError.message || String(error)}`,
-        import_types21.WalletErrorCode.CHAIN_SWITCH_FAILED
+        import_types24.WalletErrorCode.CHAIN_SWITCH_FAILED
       );
     }
   }
@@ -9331,7 +10463,7 @@ var EthereumWalletAdapter = class extends BaseWalletAdapter {
     }
     throw new WalletError(
       `Transaction ${txHash} not confirmed after ${maxAttempts * 5} seconds`,
-      import_types21.WalletErrorCode.TRANSACTION_FAILED
+      import_types24.WalletErrorCode.TRANSACTION_FAILED
     );
   }
   /**
@@ -9405,7 +10537,7 @@ function createEthereumAdapter(config) {
 }
 
 // src/wallet/ethereum/mock.ts
-var import_types23 = require("@sip-protocol/types");
+var import_types26 = require("@sip-protocol/types");
 var MockEthereumAdapter = class extends BaseWalletAdapter {
   chain = "ethereum";
   name = "mock-ethereum";
@@ -9446,7 +10578,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
         this._connectionState = "error";
         throw new WalletError(
           "Mock connection rejected",
-          import_types23.WalletErrorCode.CONNECTION_REJECTED
+          import_types26.WalletErrorCode.CONNECTION_REJECTED
         );
       }
       await new Promise((resolve) => setTimeout(resolve, 10));
@@ -9458,7 +10590,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
       this._connectionState = "error";
       throw new WalletError(
         `Mock connection failed: ${String(error)}`,
-        import_types23.WalletErrorCode.CONNECTION_FAILED
+        import_types26.WalletErrorCode.CONNECTION_FAILED
       );
     }
   }
@@ -9476,7 +10608,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types23.WalletErrorCode.SIGNING_REJECTED
+        import_types26.WalletErrorCode.SIGNING_REJECTED
       );
     }
     const msgHex = Buffer.from(message).toString("hex");
@@ -9494,7 +10626,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types23.WalletErrorCode.SIGNING_REJECTED
+        import_types26.WalletErrorCode.SIGNING_REJECTED
       );
     }
     const mockSig = `0x${"1".repeat(130)}`;
@@ -9511,7 +10643,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailSign) {
       throw new WalletError(
         "Mock signing rejected",
-        import_types23.WalletErrorCode.SIGNING_REJECTED
+        import_types26.WalletErrorCode.SIGNING_REJECTED
       );
     }
     this._signedTransactions.push(tx);
@@ -9536,7 +10668,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (this._shouldFailTransaction) {
       throw new WalletError(
         "Mock transaction failed",
-        import_types23.WalletErrorCode.TRANSACTION_FAILED
+        import_types26.WalletErrorCode.TRANSACTION_FAILED
       );
     }
     this._signedTransactions.push(tx);
@@ -9566,7 +10698,7 @@ var MockEthereumAdapter = class extends BaseWalletAdapter {
     if (asset.chain !== "ethereum") {
       throw new WalletError(
         `Asset chain ${asset.chain} not supported by Ethereum adapter`,
-        import_types23.WalletErrorCode.UNSUPPORTED_CHAIN
+        import_types26.WalletErrorCode.UNSUPPORTED_CHAIN
       );
     }
     if (!asset.address) {
@@ -9845,7 +10977,7 @@ function getAvailableTransports() {
 }
 
 // src/wallet/hardware/ledger.ts
-var import_types26 = require("@sip-protocol/types");
+var import_types29 = require("@sip-protocol/types");
 var LedgerWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "ledger";
@@ -9998,7 +11130,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types26.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10009,7 +11141,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types26.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -10297,7 +11429,7 @@ function createLedgerAdapter(config) {
 }
 
 // src/wallet/hardware/trezor.ts
-var import_types28 = require("@sip-protocol/types");
+var import_types31 = require("@sip-protocol/types");
 var TrezorWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "trezor";
@@ -10443,7 +11575,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types28.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types31.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10454,7 +11586,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types28.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types31.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -10735,8 +11867,8 @@ function createTrezorAdapter(config) {
 }
 
 // src/wallet/hardware/mock.ts
-var import_types30 = require("@sip-protocol/types");
-var import_utils14 = require("@noble/hashes/utils");
+var import_types33 = require("@sip-protocol/types");
+var import_utils15 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -10883,7 +12015,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10892,7 +12024,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10981,15 +12113,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils14.randomBytes)(20);
+    const bytes = (0, import_utils15.randomBytes)(20);
     bytes[0] = index;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils14.randomBytes)(33);
+    const bytes = (0, import_utils15.randomBytes)(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -10998,7 +12130,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${(0, import_utils14.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils15.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -11122,13 +12254,13 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types30.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getAccounts(startIndex = 0, count = 5) {
@@ -11187,15 +12319,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils14.randomBytes)(20);
+    const bytes = (0, import_utils15.randomBytes)(20);
     bytes[0] = index + 100;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils14.randomBytes)(33);
+    const bytes = (0, import_utils15.randomBytes)(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${(0, import_utils14.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -11204,7 +12336,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${(0, import_utils14.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils15.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -11218,7 +12350,7 @@ function createMockTrezorAdapter(config) {
 }
 
 // src/wallet/index.ts
-var import_types33 = require("@sip-protocol/types");
+var import_types36 = require("@sip-protocol/types");
 
 // src/proofs/browser.ts
 var import_noir_js = require("@noir-lang/noir_js");
@@ -12989,6 +14121,211 @@ function createWorkerBlobURL() {
       }
     }
 
+    // Generate validity proof
+    async function generateValidityProof(id, params) {
+      if (!isReady) {
+        sendError(id, new Error('Worker not initialized'));
+        return;
+      }
+
+      try {
+        sendProgress(id, 'witness', 20, 'Preparing validity witness...');
+
+        // Import noble crypto for hashing
+        const { sha256 } = await import('@noble/hashes/sha256');
+
+        // Convert inputs to field elements
+        const intentHashField = hexToField(params.intentHash);
+        const senderAddressField = hexToField(params.senderAddress);
+        const senderBlindingField = bytesToField(params.senderBlinding);
+        const senderSecretField = bytesToField(params.senderSecret);
+        const nonceField = bytesToField(params.nonce);
+
+        // Compute sender commitment
+        const addressBytes = hexToBytes(senderAddressField);
+        const blindingBytes = hexToBytes(senderBlindingField.padStart(64, '0'));
+        const commitmentPreimage = new Uint8Array([...addressBytes, ...blindingBytes]);
+        const commitmentHash = sha256(commitmentPreimage);
+        const commitmentX = bytesToHex(commitmentHash.slice(0, 16)).padStart(64, '0');
+        const commitmentY = bytesToHex(commitmentHash.slice(16, 32)).padStart(64, '0');
+
+        // Compute nullifier
+        const secretBytes = hexToBytes(senderSecretField.padStart(64, '0'));
+        const intentBytes = hexToBytes(intentHashField);
+        const nonceBytes = hexToBytes(nonceField.padStart(64, '0'));
+        const nullifierPreimage = new Uint8Array([...secretBytes, ...intentBytes, ...nonceBytes]);
+        const nullifierHash = sha256(nullifierPreimage);
+        const nullifier = bytesToHex(nullifierHash);
+
+        const signature = Array.from(params.authorizationSignature);
+        const messageHash = fieldToBytes32(intentHashField);
+
+        // Get public key coordinates
+        let pubKeyX, pubKeyY;
+        if (params.senderPublicKey) {
+          pubKeyX = Array.from(params.senderPublicKey.x);
+          pubKeyY = Array.from(params.senderPublicKey.y);
+        } else {
+          // Derive from secret
+          const { secp256k1 } = await import('@noble/curves/secp256k1');
+          const uncompressedPubKey = secp256k1.getPublicKey(params.senderSecret, false);
+          pubKeyX = Array.from(uncompressedPubKey.slice(1, 33));
+          pubKeyY = Array.from(uncompressedPubKey.slice(33, 65));
+        }
+
+        const witnessInputs = {
+          intent_hash: intentHashField,
+          sender_commitment_x: commitmentX,
+          sender_commitment_y: commitmentY,
+          nullifier: nullifier,
+          timestamp: params.timestamp.toString(),
+          expiry: params.expiry.toString(),
+          sender_address: senderAddressField,
+          sender_blinding: senderBlindingField,
+          sender_secret: senderSecretField,
+          pub_key_x: pubKeyX,
+          pub_key_y: pubKeyY,
+          signature: signature,
+          message_hash: messageHash,
+          nonce: nonceField,
+        };
+
+        sendProgress(id, 'witness', 40, 'Executing validity circuit...');
+        const { witness } = await validityNoir.execute(witnessInputs);
+
+        sendProgress(id, 'proving', 60, 'Generating validity proof...');
+        const proofData = await validityBackend.generateProof(witness);
+
+        sendProgress(id, 'complete', 100, 'Validity proof generated');
+
+        const publicInputs = [
+          '0x' + intentHashField,
+          '0x' + commitmentX,
+          '0x' + commitmentY,
+          '0x' + nullifier,
+          '0x' + params.timestamp.toString(16).padStart(16, '0'),
+          '0x' + params.expiry.toString(16).padStart(16, '0'),
+        ];
+
+        const proof = {
+          type: 'validity',
+          proof: '0x' + bytesToHex(proofData.proof),
+          publicInputs,
+        };
+
+        sendSuccess(id, { proof, publicInputs });
+      } catch (error) {
+        sendError(id, error);
+      }
+    }
+
+    // Generate fulfillment proof
+    async function generateFulfillmentProof(id, params) {
+      if (!isReady) {
+        sendError(id, new Error('Worker not initialized'));
+        return;
+      }
+
+      try {
+        sendProgress(id, 'witness', 20, 'Preparing fulfillment witness...');
+
+        // Import noble crypto for hashing
+        const { sha256 } = await import('@noble/hashes/sha256');
+
+        const intentHashField = hexToField(params.intentHash);
+        const recipientStealthField = hexToField(params.recipientStealth);
+
+        // Compute output commitment
+        const amountBytes = bigintToBytes(params.outputAmount, 8);
+        const blindingBytes = params.outputBlinding.slice(0, 32);
+        const outputPreimage = new Uint8Array([...amountBytes, ...blindingBytes]);
+        const outputHash = sha256(outputPreimage);
+        const commitmentX = bytesToHex(outputHash.slice(0, 16)).padStart(64, '0');
+        const commitmentY = bytesToHex(outputHash.slice(16, 32)).padStart(64, '0');
+
+        const solverSecretField = bytesToField(params.solverSecret);
+
+        // Compute solver ID
+        const solverSecretBytes = hexToBytes(solverSecretField.padStart(64, '0'));
+        const solverIdHash = sha256(solverSecretBytes);
+        const solverId = bytesToHex(solverIdHash);
+
+        const outputBlindingField = bytesToField(params.outputBlinding);
+
+        const attestation = params.oracleAttestation;
+        const attestationRecipientField = hexToField(attestation.recipient);
+        const attestationTxHashField = hexToField(attestation.txHash);
+        const oracleSignature = Array.from(attestation.signature);
+
+        // Compute oracle message hash
+        const recipientBytes = hexToBytes(attestationRecipientField);
+        const attestationAmountBytes = bigintToBytes(attestation.amount, 8);
+        const txHashBytes = hexToBytes(attestationTxHashField);
+        const blockBytes = bigintToBytes(attestation.blockNumber, 8);
+        const oraclePreimage = new Uint8Array([
+          ...recipientBytes,
+          ...attestationAmountBytes,
+          ...txHashBytes,
+          ...blockBytes,
+        ]);
+        const oracleMessageHash = Array.from(sha256(oraclePreimage));
+
+        const oraclePubKeyX = config.oraclePublicKey?.x ?? new Array(32).fill(0);
+        const oraclePubKeyY = config.oraclePublicKey?.y ?? new Array(32).fill(0);
+
+        const witnessInputs = {
+          intent_hash: intentHashField,
+          output_commitment_x: commitmentX,
+          output_commitment_y: commitmentY,
+          recipient_stealth: recipientStealthField,
+          min_output_amount: params.minOutputAmount.toString(),
+          solver_id: solverId,
+          fulfillment_time: params.fulfillmentTime.toString(),
+          expiry: params.expiry.toString(),
+          output_amount: params.outputAmount.toString(),
+          output_blinding: outputBlindingField,
+          solver_secret: solverSecretField,
+          attestation_recipient: attestationRecipientField,
+          attestation_amount: attestation.amount.toString(),
+          attestation_tx_hash: attestationTxHashField,
+          attestation_block: attestation.blockNumber.toString(),
+          oracle_signature: oracleSignature,
+          oracle_message_hash: oracleMessageHash,
+          oracle_pub_key_x: oraclePubKeyX,
+          oracle_pub_key_y: oraclePubKeyY,
+        };
+
+        sendProgress(id, 'witness', 40, 'Executing fulfillment circuit...');
+        const { witness } = await fulfillmentNoir.execute(witnessInputs);
+
+        sendProgress(id, 'proving', 60, 'Generating fulfillment proof...');
+        const proofData = await fulfillmentBackend.generateProof(witness);
+
+        sendProgress(id, 'complete', 100, 'Fulfillment proof generated');
+
+        const publicInputs = [
+          '0x' + intentHashField,
+          '0x' + commitmentX,
+          '0x' + commitmentY,
+          '0x' + recipientStealthField,
+          '0x' + params.minOutputAmount.toString(16).padStart(16, '0'),
+          '0x' + solverId,
+          '0x' + params.fulfillmentTime.toString(16).padStart(16, '0'),
+          '0x' + params.expiry.toString(16).padStart(16, '0'),
+        ];
+
+        const proof = {
+          type: 'fulfillment',
+          proof: '0x' + bytesToHex(proofData.proof),
+          publicInputs,
+        };
+
+        sendSuccess(id, { proof, publicInputs });
+      } catch (error) {
+        sendError(id, error);
+      }
+    }
+
     // Helper functions
     function bytesToField(bytes) {
       let result = 0n;
@@ -13016,6 +14353,39 @@ function createWorkerBlobURL() {
       return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
     }
 
+    function hexToBytes(hex) {
+      const h = hex.startsWith('0x') ? hex.slice(2) : hex;
+      const bytes = new Uint8Array(h.length / 2);
+      for (let i = 0; i < h.length; i += 2) {
+        bytes[i / 2] = parseInt(h.slice(i, i + 2), 16);
+      }
+      return bytes;
+    }
+
+    function hexToField(hex) {
+      const h = hex.startsWith('0x') ? hex.slice(2) : hex;
+      return h.padStart(64, '0');
+    }
+
+    function fieldToBytes32(field) {
+      const hex = field.padStart(64, '0');
+      const bytes = [];
+      for (let i = 0; i < 32; i++) {
+        bytes.push(parseInt(hex.slice(i * 2, i * 2 + 2), 16));
+      }
+      return bytes;
+    }
+
+    function bigintToBytes(value, length) {
+      const bytes = new Uint8Array(length);
+      let v = value;
+      for (let i = length - 1; i >= 0; i--) {
+        bytes[i] = Number(v & 0xffn);
+        v = v >> 8n;
+      }
+      return bytes;
+    }
+
     // Message handler
     self.onmessage = async function(event) {
       const { id, type, params, config: initConfig } = event.data;
@@ -13028,12 +14398,10 @@ function createWorkerBlobURL() {
           await generateFundingProof(id, params);
           break;
         case 'generateValidityProof':
-          // TODO: Implement
-          sendError(id, new Error('Validity proof not yet implemented in worker'));
+          await generateValidityProof(id, params);
           break;
         case 'generateFulfillmentProof':
-          // TODO: Implement
-          sendError(id, new Error('Fulfillment proof not yet implemented in worker'));
+          await generateFulfillmentProof(id, params);
           break;
         case 'destroy':
           // Cleanup
@@ -13193,6 +14561,7 @@ var ProofWorker = class _ProofWorker {
   MockWalletAdapter,
   NATIVE_TOKENS,
   NEARIntentsAdapter,
+  NEARIntentsBackend,
   NetworkError,
   ORACLE_DOMAIN,
   OneClickClient,
@@ -13215,13 +14584,18 @@ var ProofWorker = class _ProofWorker {
   STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS,
   STABLECOIN_INFO,
+  SettlementRegistry,
+  SettlementRegistryError,
+  SmartRouter,
   SolanaWalletAdapter,
+  SwapStatus,
   Treasury,
   TrezorWalletAdapter,
   ValidationError,
   WalletError,
   WalletErrorCode,
   ZcashErrorCode,
+  ZcashNativeBackend,
   ZcashRPCClient,
   ZcashRPCError,
   ZcashShieldedService,
@@ -13251,16 +14625,19 @@ var ProofWorker = class _ProofWorker {
   createMockSolver,
   createMockTrezorAdapter,
   createNEARIntentsAdapter,
+  createNEARIntentsBackend,
   createOracleRegistry,
   createProductionSIP,
   createSIP,
   createShieldedIntent,
   createShieldedPayment,
+  createSmartRouter,
   createSolanaAdapter,
   createTrezorAdapter,
   createWalletFactory,
   createWorkerBlobURL,
   createZcashClient,
+  createZcashNativeBackend,
   createZcashShieldedService,
   createZcashSwapService,
   decodeStealthMetaAddress,