@zkp2p/sdk 0.0.1

package/dist/index.cjs

@@ -0,0 +1,3080 @@
+'use strict';
+
+var baseAddressesRaw = require('@zkp2p/contracts-v2/addresses/base');
+var baseSepoliaAddressesRaw = require('@zkp2p/contracts-v2/addresses/baseSepolia');
+var baseStagingAddressesRaw = require('@zkp2p/contracts-v2/addresses/baseStaging');
+var EscrowBase = require('@zkp2p/contracts-v2/abis/base/Escrow.json');
+var OrchestratorBase = require('@zkp2p/contracts-v2/abis/base/Orchestrator.json');
+var ProtocolViewerBase = require('@zkp2p/contracts-v2/abis/base/ProtocolViewer.json');
+var UnifiedPaymentVerifierBase = require('@zkp2p/contracts-v2/abis/base/UnifiedPaymentVerifier.json');
+var EscrowBaseSepolia = require('@zkp2p/contracts-v2/abis/baseSepolia/Escrow.json');
+var OrchestratorBaseSepolia = require('@zkp2p/contracts-v2/abis/baseSepolia/Orchestrator.json');
+var ProtocolViewerBaseSepolia = require('@zkp2p/contracts-v2/abis/baseSepolia/ProtocolViewer.json');
+var UnifiedPaymentVerifierBaseSepolia = require('@zkp2p/contracts-v2/abis/baseSepolia/UnifiedPaymentVerifier.json');
+var EscrowBaseStaging = require('@zkp2p/contracts-v2/abis/baseStaging/Escrow.json');
+var OrchestratorBaseStaging = require('@zkp2p/contracts-v2/abis/baseStaging/Orchestrator.json');
+var UnifiedPaymentVerifierBaseStaging = require('@zkp2p/contracts-v2/abis/baseStaging/UnifiedPaymentVerifier.json');
+var ProtocolViewerBaseStaging = require('@zkp2p/contracts-v2/abis/baseStaging/ProtocolViewer.json');
+var baseConstantsRaw = require('@zkp2p/contracts-v2/constants/base');
+var baseStagingConstantsRaw = require('@zkp2p/contracts-v2/constants/baseStaging');
+var basePaymentMethodsRaw = require('@zkp2p/contracts-v2/paymentMethods/base.json');
+var baseSepoliaPaymentMethodsRaw = require('@zkp2p/contracts-v2/paymentMethods/baseSepolia.json');
+var baseStagingPaymentMethodsRaw = require('@zkp2p/contracts-v2/paymentMethods/baseStaging.json');
+var viem = require('viem');
+var baseSepoliaPaymentMethods2 = require('@zkp2p/contracts-v2/paymentMethods/baseSepolia');
+var baseStagingPaymentMethods2 = require('@zkp2p/contracts-v2/paymentMethods/baseStaging');
+var chains = require('viem/chains');
+var ethers = require('ethers');
+var erc8021 = require('ox/erc8021');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var baseAddressesRaw__default = /*#__PURE__*/_interopDefault(baseAddressesRaw);
+var baseSepoliaAddressesRaw__default = /*#__PURE__*/_interopDefault(baseSepoliaAddressesRaw);
+var baseStagingAddressesRaw__default = /*#__PURE__*/_interopDefault(baseStagingAddressesRaw);
+var EscrowBase__default = /*#__PURE__*/_interopDefault(EscrowBase);
+var OrchestratorBase__default = /*#__PURE__*/_interopDefault(OrchestratorBase);
+var ProtocolViewerBase__default = /*#__PURE__*/_interopDefault(ProtocolViewerBase);
+var UnifiedPaymentVerifierBase__default = /*#__PURE__*/_interopDefault(UnifiedPaymentVerifierBase);
+var EscrowBaseSepolia__default = /*#__PURE__*/_interopDefault(EscrowBaseSepolia);
+var OrchestratorBaseSepolia__default = /*#__PURE__*/_interopDefault(OrchestratorBaseSepolia);
+var ProtocolViewerBaseSepolia__default = /*#__PURE__*/_interopDefault(ProtocolViewerBaseSepolia);
+var UnifiedPaymentVerifierBaseSepolia__default = /*#__PURE__*/_interopDefault(UnifiedPaymentVerifierBaseSepolia);
+var EscrowBaseStaging__default = /*#__PURE__*/_interopDefault(EscrowBaseStaging);
+var OrchestratorBaseStaging__default = /*#__PURE__*/_interopDefault(OrchestratorBaseStaging);
+var UnifiedPaymentVerifierBaseStaging__default = /*#__PURE__*/_interopDefault(UnifiedPaymentVerifierBaseStaging);
+var ProtocolViewerBaseStaging__default = /*#__PURE__*/_interopDefault(ProtocolViewerBaseStaging);
+var baseConstantsRaw__default = /*#__PURE__*/_interopDefault(baseConstantsRaw);
+var baseStagingConstantsRaw__default = /*#__PURE__*/_interopDefault(baseStagingConstantsRaw);
+var basePaymentMethodsRaw__default = /*#__PURE__*/_interopDefault(basePaymentMethodsRaw);
+var baseSepoliaPaymentMethodsRaw__default = /*#__PURE__*/_interopDefault(baseSepoliaPaymentMethodsRaw);
+var baseStagingPaymentMethodsRaw__default = /*#__PURE__*/_interopDefault(baseStagingPaymentMethodsRaw);
+var baseSepoliaPaymentMethods2__default = /*#__PURE__*/_interopDefault(baseSepoliaPaymentMethods2);
+var baseStagingPaymentMethods2__default = /*#__PURE__*/_interopDefault(baseStagingPaymentMethods2);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function unwrapAddresses(mod) {
+  if (!mod) return {};
+  const m = mod;
+  if (m.contracts) return m;
+  if (m.default?.contracts) return m.default;
+  try {
+    const d = typeof m.default === "function" ? m.default() : m.default;
+    if (d?.contracts) return d;
+  } catch {
+  }
+  return m;
+}
+function unwrapMethods(mod) {
+  if (!mod) return {};
+  const m = mod;
+  if (m.methods) return m;
+  if (m.default?.methods) return m.default;
+  try {
+    const d = typeof m.default === "function" ? m.default() : m.default;
+    if (d?.methods) return d;
+  } catch {
+  }
+  return m;
+}
+function unwrapConstants(mod) {
+  if (!mod) return {};
+  const m = mod;
+  if (m.USDC) return m;
+  if (m.default?.USDC) return m.default;
+  try {
+    const d = typeof m.default === "function" ? m.default() : m.default;
+    if (d?.USDC) return d;
+  } catch {
+  }
+  return m;
+}
+function networkKeyFromChainId(chainId) {
+  if (chainId === 84532) return "base_sepolia";
+  return "base";
+}
+function getContracts(chainId, env = "production") {
+  const key = networkKeyFromChainId(chainId);
+  const addressesByKey = {
+    base: {
+      escrow: baseAddresses.contracts?.Escrow ?? "",
+      orchestrator: baseAddresses.contracts?.Orchestrator ?? "",
+      unifiedPaymentVerifier: baseAddresses.contracts?.UnifiedPaymentVerifier ?? "",
+      protocolViewer: baseAddresses.contracts?.ProtocolViewer ?? "",
+      usdc: baseConstants.USDC
+    },
+    base_sepolia: {
+      escrow: baseSepoliaAddresses.contracts?.Escrow ?? "",
+      orchestrator: baseSepoliaAddresses.contracts?.Orchestrator ?? "",
+      unifiedPaymentVerifier: baseSepoliaAddresses.contracts?.UnifiedPaymentVerifier ?? "",
+      protocolViewer: baseSepoliaAddresses.contracts?.ProtocolViewer ?? "",
+      // Prefer mock USDC when available on testnet
+      usdc: baseSepoliaAddresses.contracts?.USDCMock
+    }
+  };
+  const abisByKey = {
+    base: {
+      escrow: EscrowBase__default.default,
+      orchestrator: OrchestratorBase__default.default,
+      unifiedPaymentVerifier: UnifiedPaymentVerifierBase__default.default,
+      protocolViewer: ProtocolViewerBase__default.default
+    },
+    base_sepolia: {
+      escrow: EscrowBaseSepolia__default.default,
+      orchestrator: OrchestratorBaseSepolia__default.default,
+      unifiedPaymentVerifier: UnifiedPaymentVerifierBaseSepolia__default.default,
+      protocolViewer: ProtocolViewerBaseSepolia__default.default
+    }
+  };
+  if (env === "staging") {
+    return {
+      addresses: {
+        escrow: baseStagingAddresses.contracts?.Escrow ?? "",
+        orchestrator: baseStagingAddresses.contracts?.Orchestrator ?? "",
+        unifiedPaymentVerifier: baseStagingAddresses.contracts?.UnifiedPaymentVerifier ?? "",
+        protocolViewer: baseStagingAddresses.contracts?.ProtocolViewer ?? "",
+        usdc: baseStagingConstants.USDC
+      },
+      abis: {
+        escrow: EscrowBaseStaging__default.default,
+        orchestrator: OrchestratorBaseStaging__default.default,
+        unifiedPaymentVerifier: UnifiedPaymentVerifierBaseStaging__default.default,
+        protocolViewer: ProtocolViewerBaseStaging__default.default
+      }
+    };
+  }
+  return { addresses: addressesByKey[key], abis: abisByKey[key] };
+}
+function getPaymentMethodsCatalog(chainId, env = "production") {
+  const isBaseSepolia = networkKeyFromChainId(chainId) === "base_sepolia";
+  const src = env === "staging" ? baseStagingPaymentMethods : isBaseSepolia ? baseSepoliaPaymentMethods : basePaymentMethods;
+  const methods = src?.methods ?? src?.default?.methods ?? {};
+  return methods;
+}
+function getGatingServiceAddress(chainId, env = "production") {
+  if (env === "staging") {
+    return "0x396D31055Db28C0C6f36e8b36f18FE7227248a97";
+  }
+  if (networkKeyFromChainId(chainId) === "base_sepolia") {
+    return "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+  }
+  return "0x396D31055Db28C0C6f36e8b36f18FE7227248a97";
+}
+var baseAddresses, baseSepoliaAddresses, baseStagingAddresses, basePaymentMethods, baseSepoliaPaymentMethods, baseStagingPaymentMethods, baseConstants, baseStagingConstants;
+var init_contracts = __esm({
+  "src/contracts.ts"() {
+    baseAddresses = unwrapAddresses(baseAddressesRaw__default.default);
+    baseSepoliaAddresses = unwrapAddresses(baseSepoliaAddressesRaw__default.default);
+    baseStagingAddresses = unwrapAddresses(baseStagingAddressesRaw__default.default);
+    basePaymentMethods = unwrapMethods(basePaymentMethodsRaw__default.default);
+    baseSepoliaPaymentMethods = unwrapMethods(baseSepoliaPaymentMethodsRaw__default.default);
+    baseStagingPaymentMethods = unwrapMethods(baseStagingPaymentMethodsRaw__default.default);
+    baseConstants = unwrapConstants(baseConstantsRaw__default.default);
+    baseStagingConstants = unwrapConstants(baseStagingConstantsRaw__default.default);
+  }
+});
+
+// src/errors/index.ts
+exports.ErrorCode = void 0; exports.ZKP2PError = void 0; exports.ValidationError = void 0; exports.NetworkError = void 0; exports.APIError = void 0; exports.ContractError = void 0;
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    exports.ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+      ErrorCode2["VALIDATION"] = "VALIDATION";
+      ErrorCode2["NETWORK"] = "NETWORK";
+      ErrorCode2["API"] = "API";
+      ErrorCode2["CONTRACT"] = "CONTRACT";
+      ErrorCode2["UNKNOWN"] = "UNKNOWN";
+      return ErrorCode2;
+    })(exports.ErrorCode || {});
+    exports.ZKP2PError = class extends Error {
+      constructor(message, code = "UNKNOWN" /* UNKNOWN */, details, field) {
+        super(message);
+        this.name = "ZKP2PError";
+        this.code = code;
+        this.details = details;
+        this.field = field;
+      }
+    };
+    exports.ValidationError = class extends exports.ZKP2PError {
+      constructor(message, field, details) {
+        super(message, "VALIDATION" /* VALIDATION */, details, field);
+        this.name = "ValidationError";
+      }
+    };
+    exports.NetworkError = class extends exports.ZKP2PError {
+      constructor(message, details) {
+        super(message, "NETWORK" /* NETWORK */, details);
+        this.name = "NetworkError";
+      }
+    };
+    exports.APIError = class extends exports.ZKP2PError {
+      constructor(message, status, details) {
+        super(message, "API" /* API */, details);
+        this.status = status;
+        this.name = "APIError";
+      }
+    };
+    exports.ContractError = class extends exports.ZKP2PError {
+      constructor(message, details) {
+        super(message, "CONTRACT" /* CONTRACT */, details);
+        this.name = "ContractError";
+      }
+    };
+  }
+});
+
+// src/utils/timeout.ts
+var timeout_exports = {};
+__export(timeout_exports, {
+  DEFAULT_TIMEOUTS: () => DEFAULT_TIMEOUTS,
+  withTimeout: () => withTimeout
+});
+async function withTimeout(promise, timeoutMs, timeoutMessage) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new exports.NetworkError(timeoutMessage, { timeout: timeoutMs }));
+    }, timeoutMs);
+  });
+  try {
+    const result = await Promise.race([promise, timeoutPromise]);
+    if (timeoutId) clearTimeout(timeoutId);
+    return result;
+  } catch (error) {
+    if (timeoutId) clearTimeout(timeoutId);
+    throw error;
+  }
+}
+var DEFAULT_TIMEOUTS;
+var init_timeout = __esm({
+  "src/utils/timeout.ts"() {
+    init_errors();
+    DEFAULT_TIMEOUTS = {
+      /** API call timeout (30 seconds) */
+      API: 3e4,
+      /** Blockchain transaction timeout (60 seconds) */
+      TRANSACTION: 6e4,
+      /** Proof generation timeout (120 seconds) */
+      PROOF_GENERATION: 12e4,
+      /** Extension communication timeout (60 seconds) */
+      EXTENSION: 6e4
+    };
+  }
+});
+function ensureBytes32(value, { hashIfAscii = false } = {}) {
+  if (value.startsWith("0x")) {
+    const bytes = viem.hexToBytes(value);
+    if (bytes.length !== 32) throw new Error("Expected 32-byte hex value");
+    return value;
+  }
+  if (!hashIfAscii) throw new Error("Expected 32-byte hex; received ascii string. Pass hashIfAscii=true to hash.");
+  const hashed = viem.keccak256(viem.toBytes(value));
+  return hashed;
+}
+function asciiToBytes32(value) {
+  const b = viem.toBytes(value);
+  if (b.length > 32) throw new Error("ASCII input exceeds 32 bytes");
+  const padded = new Uint8Array(32);
+  padded.set(b);
+  return `0x${viem.bytesToHex(padded)}`;
+}
+var init_bytes32 = __esm({
+  "src/utils/bytes32.ts"() {
+  }
+});
+
+// src/utils/paymentResolution.ts
+var paymentResolution_exports = {};
+__export(paymentResolution_exports, {
+  resolveFiatCurrencyBytes32: () => resolveFiatCurrencyBytes32,
+  resolvePaymentMethodHash: () => resolvePaymentMethodHash,
+  resolvePaymentMethodHashFromCatalog: () => resolvePaymentMethodHashFromCatalog,
+  resolvePaymentMethodNameFromHash: () => resolvePaymentMethodNameFromHash
+});
+function getPaymentMethodMap(env, network) {
+  if (env === "staging") {
+    const m = baseStagingPaymentMethods2__default.default?.methods ?? {};
+    return m && Object.keys(m).length ? m : null;
+  }
+  if (network === "base_sepolia") {
+    const m = baseSepoliaPaymentMethods2__default.default?.methods ?? {};
+    return m && Object.keys(m).length ? m : null;
+  }
+  return null;
+}
+function resolvePaymentMethodHash(nameOrBytes, opts = {}) {
+  const { env = "production", network = "base" } = opts;
+  if (nameOrBytes.startsWith("0x")) return ensureBytes32(nameOrBytes);
+  const mapping = getPaymentMethodMap(env, network);
+  if (mapping) {
+    const key = nameOrBytes.toLowerCase();
+    const entry = mapping[key];
+    if (entry?.paymentMethodHash) return entry.paymentMethodHash;
+  }
+  return ensureBytes32(nameOrBytes, { hashIfAscii: true });
+}
+function resolveFiatCurrencyBytes32(codeOrBytes) {
+  if (codeOrBytes.startsWith("0x")) return ensureBytes32(codeOrBytes);
+  return asciiToBytes32(codeOrBytes.toUpperCase());
+}
+function resolvePaymentMethodHashFromCatalog(processorName, catalog) {
+  if (!processorName) {
+    throw new Error("processorName is required to resolve paymentMethodHash");
+  }
+  if (processorName.startsWith("0x")) {
+    return ensureBytes32(processorName);
+  }
+  const key = processorName.toLowerCase();
+  const entry = catalog?.[key];
+  if (entry?.paymentMethodHash) return entry.paymentMethodHash;
+  const available = Object.keys(catalog || {}).sort().join(", ");
+  throw new Error(
+    available ? `Unknown processorName: ${processorName}. Available: ${available}` : `Unknown processorName: ${processorName}. The payment methods catalog is empty or unavailable.`
+  );
+}
+function resolvePaymentMethodNameFromHash(hash, catalog) {
+  if (!hash) return void 0;
+  const target = ensureBytes32(hash);
+  for (const [name, entry] of Object.entries(catalog || {})) {
+    if (entry?.paymentMethodHash?.toLowerCase() === target.toLowerCase()) return name;
+  }
+  return void 0;
+}
+var init_paymentResolution = __esm({
+  "src/utils/paymentResolution.ts"() {
+    init_bytes32();
+  }
+});
+var currencyKeccak256;
+var init_keccak = __esm({
+  "src/utils/keccak.ts"() {
+    currencyKeccak256 = (inputString) => {
+      return viem.keccak256(viem.stringToHex(inputString));
+    };
+  }
+});
+
+// src/utils/currency.ts
+var currency_exports = {};
+__export(currency_exports, {
+  Currency: () => exports.Currency,
+  currencyInfo: () => exports.currencyInfo,
+  getCurrencyCodeFromHash: () => getCurrencyCodeFromHash,
+  getCurrencyInfoFromCountryCode: () => getCurrencyInfoFromCountryCode,
+  getCurrencyInfoFromHash: () => getCurrencyInfoFromHash,
+  isSupportedCurrencyHash: () => isSupportedCurrencyHash,
+  mapConversionRatesToOnchain: () => mapConversionRatesToOnchain,
+  mapConversionRatesToOnchainMinRate: () => mapConversionRatesToOnchainMinRate
+});
+function mapConversionRatesToOnchain(groups, expectedGroups) {
+  if (!Array.isArray(groups) || !Array.isArray(groups[0])) {
+    throw new Error("conversionRates must be a nested array per processor");
+  }
+  if (typeof expectedGroups === "number" && groups.length !== expectedGroups) {
+    throw new Error(`conversionRates length (${groups.length}) must match processorNames length (${expectedGroups})`);
+  }
+  return groups.map((group) => group.map((r) => {
+    const info = exports.currencyInfo[r.currency];
+    if (!info?.currencyCodeHash) throw new Error("Invalid currency");
+    return { code: info.currencyCodeHash, conversionRate: BigInt(r.conversionRate) };
+  }));
+}
+function mapConversionRatesToOnchainMinRate(groups, expectedGroups) {
+  if (!Array.isArray(groups) || !Array.isArray(groups[0])) {
+    throw new Error("conversionRates must be a nested array per payment method");
+  }
+  if (typeof expectedGroups === "number" && groups.length !== expectedGroups) {
+    throw new Error(`conversionRates length (${groups.length}) must match processorNames length (${expectedGroups})`);
+  }
+  return groups.map(
+    (group) => group.map((r) => {
+      const info = exports.currencyInfo[r.currency];
+      const hash = info?.currencyCodeHash;
+      if (!hash) throw new Error(`Invalid currency: ${r.currency}`);
+      return { code: hash, minConversionRate: BigInt(r.conversionRate) };
+    })
+  );
+}
+function getCurrencyInfoFromHash(hash) {
+  if (!hash) return void 0;
+  const h = hash.toLowerCase();
+  for (const key of Object.keys(exports.currencyInfo)) {
+    const info = exports.currencyInfo[key];
+    if (info?.currencyCodeHash?.toLowerCase() === h) return info;
+  }
+  return void 0;
+}
+function getCurrencyInfoFromCountryCode(code) {
+  if (!code) return void 0;
+  const upper = code.toUpperCase();
+  return exports.currencyInfo[upper];
+}
+function getCurrencyCodeFromHash(hash) {
+  return getCurrencyInfoFromHash(hash)?.currencyCode;
+}
+function isSupportedCurrencyHash(hash) {
+  return Boolean(getCurrencyInfoFromHash(hash));
+}
+exports.Currency = void 0; exports.currencyInfo = void 0;
+var init_currency = __esm({
+  "src/utils/currency.ts"() {
+    init_keccak();
+    exports.Currency = {
+      AED: "AED",
+      ARS: "ARS",
+      AUD: "AUD",
+      CAD: "CAD",
+      CHF: "CHF",
+      CNY: "CNY",
+      CZK: "CZK",
+      DKK: "DKK",
+      EUR: "EUR",
+      GBP: "GBP",
+      HKD: "HKD",
+      HUF: "HUF",
+      IDR: "IDR",
+      ILS: "ILS",
+      INR: "INR",
+      JPY: "JPY",
+      KES: "KES",
+      MXN: "MXN",
+      MYR: "MYR",
+      NOK: "NOK",
+      NZD: "NZD",
+      PHP: "PHP",
+      PLN: "PLN",
+      RON: "RON",
+      SAR: "SAR",
+      SEK: "SEK",
+      SGD: "SGD",
+      THB: "THB",
+      TRY: "TRY",
+      UGX: "UGX",
+      USD: "USD",
+      VND: "VND",
+      ZAR: "ZAR"
+    };
+    exports.currencyInfo = {
+      AED: { currency: "AED", currencyCode: "AED", currencyName: "United Arab Emirates Dirham", currencyCodeHash: currencyKeccak256("AED"), currencySymbol: "\u062F.\u0625", countryCode: "ae" },
+      ARS: { currency: "ARS", currencyCode: "ARS", currencyName: "Argentine Peso", currencyCodeHash: currencyKeccak256("ARS"), currencySymbol: "$", countryCode: "ar" },
+      AUD: { currency: "AUD", currencyCode: "AUD", currencyName: "Australian Dollar", currencyCodeHash: currencyKeccak256("AUD"), currencySymbol: "A$", countryCode: "au" },
+      CAD: { currency: "CAD", currencyCode: "CAD", currencyName: "Canadian Dollar", currencyCodeHash: currencyKeccak256("CAD"), currencySymbol: "C$", countryCode: "ca" },
+      CHF: { currency: "CHF", currencyCode: "CHF", currencyName: "Swiss Franc", currencyCodeHash: currencyKeccak256("CHF"), currencySymbol: "Fr", countryCode: "ch" },
+      CNY: { currency: "CNY", currencyCode: "CNY", currencyName: "Chinese Yuan", currencyCodeHash: currencyKeccak256("CNY"), currencySymbol: "\xA5", countryCode: "cn" },
+      CZK: { currency: "CZK", currencyCode: "CZK", currencyName: "Czech Koruna", currencyCodeHash: currencyKeccak256("CZK"), currencySymbol: "K\u010D", countryCode: "cz" },
+      DKK: { currency: "DKK", currencyCode: "DKK", currencyName: "Danish Krone", currencyCodeHash: currencyKeccak256("DKK"), currencySymbol: "kr", countryCode: "dk" },
+      EUR: { currency: "EUR", currencyCode: "EUR", currencyName: "Euro", currencyCodeHash: currencyKeccak256("EUR"), currencySymbol: "\u20AC", countryCode: "eu" },
+      GBP: { currency: "GBP", currencyCode: "GBP", currencyName: "British Pound", currencyCodeHash: currencyKeccak256("GBP"), currencySymbol: "\xA3", countryCode: "gb" },
+      HKD: { currency: "HKD", currencyCode: "HKD", currencyName: "Hong Kong Dollar", currencyCodeHash: currencyKeccak256("HKD"), currencySymbol: "HK$", countryCode: "hk" },
+      HUF: { currency: "HUF", currencyCode: "HUF", currencyName: "Hungarian Forint", currencyCodeHash: currencyKeccak256("HUF"), currencySymbol: "Ft", countryCode: "hu" },
+      IDR: { currency: "IDR", currencyCode: "IDR", currencyName: "Indonesian Rupiah", currencyCodeHash: currencyKeccak256("IDR"), currencySymbol: "Rp", countryCode: "id" },
+      ILS: { currency: "ILS", currencyCode: "ILS", currencyName: "Israeli New Shekel", currencyCodeHash: currencyKeccak256("ILS"), currencySymbol: "\u20AA", countryCode: "il" },
+      INR: { currency: "INR", currencyCode: "INR", currencyName: "Indian Rupee", currencyCodeHash: currencyKeccak256("INR"), currencySymbol: "\u20B9", countryCode: "in" },
+      JPY: { currency: "JPY", currencyCode: "JPY", currencyName: "Japanese Yen", currencyCodeHash: currencyKeccak256("JPY"), currencySymbol: "\xA5", countryCode: "jp" },
+      KES: { currency: "KES", currencyCode: "KES", currencyName: "Kenyan Shilling", currencyCodeHash: currencyKeccak256("KES"), currencySymbol: "KSh", countryCode: "ke" },
+      MXN: { currency: "MXN", currencyCode: "MXN", currencyName: "Mexican Peso", currencyCodeHash: currencyKeccak256("MXN"), currencySymbol: "$", countryCode: "mx" },
+      MYR: { currency: "MYR", currencyCode: "MYR", currencyName: "Malaysian Ringgit", currencyCodeHash: currencyKeccak256("MYR"), currencySymbol: "RM", countryCode: "my" },
+      NOK: { currency: "NOK", currencyCode: "NOK", currencyName: "Norwegian Krone", currencyCodeHash: currencyKeccak256("NOK"), currencySymbol: "kr", countryCode: "no" },
+      NZD: { currency: "NZD", currencyCode: "NZD", currencyName: "New Zealand Dollar", currencyCodeHash: currencyKeccak256("NZD"), currencySymbol: "NZ$", countryCode: "nz" },
+      PHP: { currency: "PHP", currencyCode: "PHP", currencyName: "Philippine Peso", currencyCodeHash: currencyKeccak256("PHP"), currencySymbol: "\u20B1", countryCode: "ph" },
+      PLN: { currency: "PLN", currencyCode: "PLN", currencyName: "Polish Z\u0142oty", currencyCodeHash: currencyKeccak256("PLN"), currencySymbol: "z\u0142", countryCode: "pl" },
+      RON: { currency: "RON", currencyCode: "RON", currencyName: "Romanian Leu", currencyCodeHash: currencyKeccak256("RON"), currencySymbol: "lei", countryCode: "ro" },
+      SAR: { currency: "SAR", currencyCode: "SAR", currencyName: "Saudi Riyal", currencyCodeHash: currencyKeccak256("SAR"), currencySymbol: "\uFDFC", countryCode: "sa" },
+      SEK: { currency: "SEK", currencyCode: "SEK", currencyName: "Swedish Krona", currencyCodeHash: currencyKeccak256("SEK"), currencySymbol: "kr", countryCode: "se" },
+      SGD: { currency: "SGD", currencyCode: "SGD", currencyName: "Singapore Dollar", currencyCodeHash: currencyKeccak256("SGD"), currencySymbol: "S$", countryCode: "sg" },
+      THB: { currency: "THB", currencyCode: "THB", currencyName: "Thai Baht", currencyCodeHash: currencyKeccak256("THB"), currencySymbol: "\u0E3F", countryCode: "th" },
+      TRY: { currency: "TRY", currencyCode: "TRY", currencyName: "Turkish Lira", currencyCodeHash: currencyKeccak256("TRY"), currencySymbol: "\u20BA", countryCode: "tr" },
+      UGX: { currency: "UGX", currencyCode: "UGX", currencyName: "Ugandan Shilling", currencyCodeHash: currencyKeccak256("UGX"), currencySymbol: "USh", countryCode: "ug" },
+      USD: { currency: "USD", currencyCode: "USD", currencyName: "United States Dollar", currencyCodeHash: currencyKeccak256("USD"), currencySymbol: "$", countryCode: "us" },
+      VND: { currency: "VND", currencyCode: "VND", currencyName: "Vietnamese Dong", currencyCodeHash: currencyKeccak256("VND"), currencySymbol: "\u20AB", countryCode: "vn" },
+      ZAR: { currency: "ZAR", currencyCode: "ZAR", currencyName: "South African Rand", currencyCodeHash: currencyKeccak256("ZAR"), currencySymbol: "R", countryCode: "za" }
+    };
+  }
+});
+
+// src/types/index.ts
+exports.PAYMENT_PLATFORMS = void 0;
+var init_types = __esm({
+  "src/types/index.ts"() {
+    exports.PAYMENT_PLATFORMS = [
+      "wise",
+      "venmo",
+      "revolut",
+      "cashapp",
+      "mercadopago",
+      "zelle",
+      "paypal",
+      "monzo"
+    ];
+  }
+});
+
+// src/utils/constants.ts
+var DEFAULT_BASE_API_URL, DEFAULT_WITNESS_URL, DEPLOYED_ADDRESSES;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    DEFAULT_BASE_API_URL = "https://api.zkp2p.xyz";
+    DEFAULT_WITNESS_URL = "https://witness-proxy.zkp2p.xyz";
+    DEPLOYED_ADDRESSES = {
+      8453: {
+        production: {
+          // external contracts
+          usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+          // escrow + verifiers
+          escrow: "0xCA38607D85E8F6294Dc10728669605E6664C2D70",
+          // Processor names to deployed addresses
+          venmo: "0x9a733B55a875D0DB4915c6B36350b24F8AB99dF5",
+          revolut: "0xAA5A1B62B01781E789C900d616300717CD9A41aB",
+          cashapp: "0x76D33A33068D86016B806dF02376dDBb23Dd3703",
+          wise: "0xFF0149799631D7A5bdE2e7eA9b306c42b3d9a9ca",
+          mercadopago: "0xf2AC5be14F32Cbe6A613CFF8931d95460D6c33A3",
+          zelle: "0x431a078A5029146aAB239c768A615CD484519aF7",
+          paypal: "0x03d17E9371C858072E171276979f6B44571C5DeA",
+          monzo: "0x0dE46433bD251027f73eD8f28E01eF05DA36a2E0",
+          // offchain services
+          gatingService: "0x396D31055Db28C0C6f36e8b36f18FE7227248a97",
+          zkp2pWitnessSigner: "0x0636c417755E3ae25C6c166D181c0607F4C572A3"
+        },
+        staging: {
+          // external contracts
+          usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+          // escrow + verifiers
+          escrow: "0xC8cd114C6274Ef1066840337E7678BC9731BEa68",
+          // Processor names to deployed addresses
+          venmo: "0xCE6454f272127ba69e8C8128B92F2388Ca343257",
+          revolut: "0xb941e69B6C1A23A88cf9DA7D243bAE1D2Cb8eb6b",
+          cashapp: "0xdDB9d452180398F456Fe89A43Df9C65B19756CEa",
+          wise: "0x79F35E2f65ff917BE35686d34932C8Ef5a30631f",
+          mercadopago: "0xA2d54F983B8201c7b276C9705641C49C2FBD1A36",
+          zelle: "0x0Ed3c3DB9CF8458e5D9991712552539675D2C896",
+          paypal: "0xB07764999679a9136d6853a5D4c70449afbfc2f8",
+          monzo: "0x179792F99C0eFBFa06c3F6747989a96c58544f6F",
+          // offchain services
+          gatingService: "0x396D31055Db28C0C6f36e8b36f18FE7227248a97",
+          zkp2pWitnessSigner: "0x0636c417755E3ae25C6c166D181c0607F4C572A3"
+        }
+      },
+      84532: {
+        usdc: "0x17463cb89A62c7b4A5ecD949aFDEDBD0Aa047ad1",
+        escrow: "0x15EF83EBB422B4AC8e3b8393d016Ed076dc50CB7",
+        venmo: "0x8499f2e7c4496Acfe0D7Ca5C7b6522514877b33F",
+        revolut: "0x7E34909A1C1b2a4D2FAbA61c17a0F59ECAce6F29",
+        cashapp: "0xe4148B108Fe4D7421853FE8cFfd35bDc2c0d95Ec",
+        wise: "0x54c92a8828A393C5A6D1DfbB71d0e9e97329b39C",
+        mercadopago: "0x4367155Fe7BAA99d9AE99fE4F6aC1b8E87012e6b",
+        zelle: "0xbeeC239145b3c461422BC2fC45B78E5fd70862F1",
+        paypal: "0xC8cd114C6274Ef1066840337E7678BC9731BEa68",
+        monzo: "0xe2B378D9181046c84dB1156B0F90cF3108e25E9D",
+        gatingService: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        zkp2pWitnessSigner: "0x0636c417755E3ae25C6c166D181c0607F4C572A3"
+      },
+      31337: {
+        usdc: "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+        escrow: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+        venmo: "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9",
+        revolut: "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853",
+        cashapp: "0x610178dA211FEF7D417bC0e6FeD39F05609AD788",
+        wise: "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
+        mercadopago: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
+        zelle: "0x3Aa5ebB10DC797CAC828524e59A333d0A371443c",
+        paypal: "0xE6E340D132b5f46d1e472DebcD681B2aBc16e57E",
+        monzo: "0x9E545E3C0baAB3E08CdfD552C960A1050f373042",
+        // offchain services
+        gatingService: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        // Hardhat 0
+        zkp2pWitnessSigner: "0x0636c417755E3ae25C6c166D181c0607F4C572A3"
+      }
+    };
+  }
+});
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  Currency: () => exports.Currency,
+  DEFAULT_BASE_API_URL: () => DEFAULT_BASE_API_URL,
+  DEFAULT_WITNESS_URL: () => DEFAULT_WITNESS_URL,
+  DEPLOYED_ADDRESSES: () => DEPLOYED_ADDRESSES,
+  PAYMENT_PLATFORMS: () => exports.PAYMENT_PLATFORMS,
+  PLATFORM_ATTESTATION_CONFIG: () => PLATFORM_ATTESTATION_CONFIG,
+  PLATFORM_METADATA: () => exports.PLATFORM_METADATA,
+  SUPPORTED_CHAIN_IDS: () => exports.SUPPORTED_CHAIN_IDS,
+  TOKEN_METADATA: () => exports.TOKEN_METADATA,
+  currencyInfo: () => exports.currencyInfo,
+  resolvePlatformAttestationConfig: () => resolvePlatformAttestationConfig
+});
+function resolvePlatformAttestationConfig(platformName) {
+  const normalized = platformName.toLowerCase();
+  const config = PLATFORM_ATTESTATION_CONFIG[normalized];
+  if (!config) {
+    throw new Error(`Unknown payment platform: ${platformName}`);
+  }
+  return config;
+}
+exports.SUPPORTED_CHAIN_IDS = void 0; exports.PLATFORM_METADATA = void 0; exports.TOKEN_METADATA = void 0; var PLATFORM_ATTESTATION_CONFIG;
+var init_constants2 = __esm({
+  "src/constants.ts"() {
+    init_types();
+    init_currency();
+    init_constants();
+    init_constants();
+    exports.SUPPORTED_CHAIN_IDS = {
+      /** Base mainnet (8453) */
+      BASE_MAINNET: 8453,
+      /** Base Sepolia testnet (84532) */
+      BASE_SEPOLIA: 84532,
+      /** Scroll mainnet (534352) */
+      SCROLL_MAINNET: 534352,
+      /** Local Hardhat network (31337) */
+      HARDHAT: 31337
+    };
+    exports.PLATFORM_METADATA = {
+      venmo: {
+        name: "Venmo",
+        displayName: "Venmo",
+        logo: "\u{1F4B5}",
+        requiredProofs: 1
+      },
+      revolut: {
+        name: "Revolut",
+        displayName: "Revolut",
+        logo: "\u{1F4B3}",
+        requiredProofs: 1
+      },
+      cashapp: {
+        name: "CashApp",
+        displayName: "Cash App",
+        logo: "\u{1F4B8}",
+        requiredProofs: 1
+      },
+      wise: {
+        name: "Wise",
+        displayName: "Wise",
+        logo: "\u{1F30D}",
+        requiredProofs: 2
+      },
+      mercadopago: {
+        name: "MercadoPago",
+        displayName: "Mercado Pago",
+        logo: "\u{1F4B0}",
+        requiredProofs: 1
+      },
+      zelle: {
+        name: "Zelle",
+        displayName: "Zelle",
+        logo: "\u{1F4B2}",
+        requiredProofs: 1
+      },
+      paypal: {
+        name: "PayPal",
+        displayName: "PayPal",
+        logo: "\u{1F499}",
+        requiredProofs: 1
+      },
+      monzo: {
+        name: "Monzo",
+        displayName: "Monzo",
+        logo: "\u{1F3E6}",
+        requiredProofs: 1
+      }
+    };
+    exports.TOKEN_METADATA = {
+      USDC: {
+        symbol: "USDC",
+        decimals: 6,
+        name: "USD Coin"
+      }
+    };
+    PLATFORM_ATTESTATION_CONFIG = {
+      wise: { actionType: "transfer_wise", actionPlatform: "wise" },
+      venmo: { actionType: "transfer_venmo", actionPlatform: "venmo" },
+      revolut: { actionType: "transfer_revolut", actionPlatform: "revolut" },
+      cashapp: { actionType: "transfer_cashapp", actionPlatform: "cashapp" },
+      mercadopago: { actionType: "transfer_mercadopago", actionPlatform: "mercadopago" },
+      paypal: { actionType: "transfer_paypal", actionPlatform: "paypal" },
+      monzo: { actionType: "transfer_monzo", actionPlatform: "monzo" },
+      "zelle-chase": { actionType: "transfer_zelle", actionPlatform: "chase" },
+      "zelle-bofa": { actionType: "transfer_zelle", actionPlatform: "bankofamerica" },
+      "zelle-citi": { actionType: "transfer_zelle", actionPlatform: "citi" }
+    };
+  }
+});
+
+// src/utils/protocolViewerParsers.ts
+var protocolViewerParsers_exports = {};
+__export(protocolViewerParsers_exports, {
+  enrichPvDepositView: () => enrichPvDepositView,
+  enrichPvIntentView: () => enrichPvIntentView,
+  parseDepositView: () => parseDepositView,
+  parseIntentView: () => parseIntentView
+});
+function toBigInt2(v) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") return BigInt(v);
+  if (typeof v === "string") return BigInt(v);
+  if (v && typeof v.toString === "function") return BigInt(v.toString());
+  throw new Error("Unsupported numeric type for bigint conversion");
+}
+function parseDepositView(raw) {
+  return {
+    depositId: toBigInt2(raw.depositId),
+    deposit: {
+      depositor: raw.deposit.depositor,
+      delegate: raw.deposit.delegate,
+      token: raw.deposit.token,
+      amount: toBigInt2(raw.deposit.amount),
+      intentAmountRange: {
+        min: toBigInt2(raw.deposit.intentAmountRange.min),
+        max: toBigInt2(raw.deposit.intentAmountRange.max)
+      },
+      acceptingIntents: raw.deposit.acceptingIntents,
+      remainingDeposits: toBigInt2(raw.deposit.remainingDeposits),
+      outstandingIntentAmount: toBigInt2(raw.deposit.outstandingIntentAmount),
+      makerProtocolFee: toBigInt2(raw.deposit.makerProtocolFee ?? 0),
+      reservedMakerFees: toBigInt2(raw.deposit.reservedMakerFees ?? 0),
+      accruedMakerFees: toBigInt2(raw.deposit.accruedMakerFees ?? 0),
+      accruedReferrerFees: toBigInt2(raw.deposit.accruedReferrerFees ?? 0),
+      intentGuardian: raw.deposit.intentGuardian,
+      referrer: raw.deposit.referrer,
+      referrerFee: toBigInt2(raw.deposit.referrerFee ?? 0)
+    },
+    availableLiquidity: toBigInt2(raw.availableLiquidity),
+    paymentMethods: (raw.paymentMethods || []).map((pm) => ({
+      paymentMethod: pm.paymentMethod,
+      verificationData: {
+        intentGatingService: pm.verificationData.intentGatingService,
+        payeeDetails: pm.verificationData.payeeDetails,
+        data: pm.verificationData.data
+      },
+      currencies: (pm.currencies || []).map((c) => ({
+        code: c.code,
+        minConversionRate: toBigInt2(c.minConversionRate)
+      }))
+    })),
+    intentHashes: raw.intentHashes || []
+  };
+}
+function parseIntentView(raw) {
+  const parsedDeposit = parseDepositView(raw.deposit);
+  const deposit = {
+    depositId: parsedDeposit.depositId,
+    deposit: parsedDeposit.deposit,
+    availableLiquidity: parsedDeposit.availableLiquidity,
+    paymentMethods: parsedDeposit.paymentMethods
+  };
+  return {
+    intentHash: raw.intentHash,
+    intent: {
+      owner: raw.intent.owner,
+      to: raw.intent.to,
+      escrow: raw.intent.escrow,
+      depositId: toBigInt2(raw.intent.depositId),
+      amount: toBigInt2(raw.intent.amount),
+      timestamp: toBigInt2(raw.intent.timestamp),
+      paymentMethod: raw.intent.paymentMethod,
+      fiatCurrency: raw.intent.fiatCurrency,
+      conversionRate: toBigInt2(raw.intent.conversionRate),
+      referrer: raw.intent.referrer,
+      referrerFee: toBigInt2(raw.intent.referrerFee ?? 0),
+      postIntentHook: raw.intent.postIntentHook,
+      data: raw.intent.data
+    },
+    deposit
+  };
+}
+function enrichPvDepositView(view, chainId, env = "production") {
+  const catalog = getPaymentMethodsCatalog(chainId, env);
+  return {
+    ...view,
+    paymentMethods: view.paymentMethods.map((pm) => ({
+      ...pm,
+      processorName: resolvePaymentMethodNameFromHash(pm.paymentMethod, catalog),
+      currencies: pm.currencies.map((c) => ({
+        ...c,
+        currencyInfo: getCurrencyInfoFromHash(c.code)
+      }))
+    }))
+  };
+}
+function enrichPvIntentView(view, chainId, env = "production") {
+  const catalog = getPaymentMethodsCatalog(chainId, env);
+  return {
+    ...view,
+    intent: {
+      ...view.intent,
+      processorName: resolvePaymentMethodNameFromHash(view.intent.paymentMethod, catalog),
+      currencyInfo: getCurrencyInfoFromHash(view.intent.fiatCurrency)
+    },
+    deposit: enrichPvDepositView(view.deposit, chainId, env)
+  };
+}
+var init_protocolViewerParsers = __esm({
+  "src/utils/protocolViewerParsers.ts"() {
+    init_contracts();
+    init_paymentResolution();
+    init_currency();
+  }
+});
+
+// src/indexer/client.ts
+var IndexerClient = class {
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  async _post(request, init) {
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request),
+      cache: "no-store",
+      ...init
+    });
+    if (!res.ok) throw new Error(`Indexer request failed: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    if (json.errors?.length) {
+      const msg = json.errors.map((e) => e.message).join(", ");
+      throw new Error(`GraphQL errors: ${msg}`);
+    }
+    if (!json.data) throw new Error("No data returned from indexer");
+    return json.data;
+  }
+  async query(request, init) {
+    const retries = init?.retries ?? 1;
+    let lastErr;
+    for (let i = 0; i <= retries; i++) {
+      try {
+        return await this._post(request, init);
+      } catch (e) {
+        lastErr = e;
+        if (i === retries) break;
+        await new Promise((r) => setTimeout(r, 200 * (i + 1)));
+      }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+  }
+};
+function defaultIndexerEndpoint(env = "PRODUCTION") {
+  switch (env) {
+    case "PRODUCTION":
+      return "https://indexer.hyperindex.xyz/8fd74dc/v1/graphql";
+    case "PREPRODUCTION":
+      return "https://indexer.hyperindex.xyz/186c193/v1/graphql";
+    case "STAGING":
+      return "https://indexer.dev.hyperindex.xyz/3b6e163/v1/graphql";
+    case "DEV":
+    case "LOCAL":
+    case "STAGING_TESTNET":
+      return "https://indexer.dev.hyperindex.xyz/3b6e163/v1/graphql";
+    default:
+      return "https://indexer.hyperindex.xyz/8fd74dc/v1/graphql";
+  }
+}
+
+// src/indexer/queries.ts
+var DEPOSIT_FIELDS = `
+  id
+  chainId
+  escrowAddress
+  depositId
+  depositor
+  token
+  remainingDeposits
+  intentAmountMin
+  intentAmountMax
+  acceptingIntents
+  status
+  outstandingIntentAmount
+  totalAmountTaken
+  totalWithdrawn
+  successRateBps
+  totalIntents
+  signaledIntents
+  fulfilledIntents
+  prunedIntents
+  blockNumber
+  timestamp
+  txHash
+  updatedAt
+`;
+var DEPOSITS_QUERY = (
+  /* GraphQL */
+  `
+  query GetDeposits(
+    $where: Deposit_bool_exp
+    $order_by: [Deposit_order_by!]
+    $limit: Int
+    $offset: Int
+  ) {
+    Deposit(where: $where, order_by: $order_by, limit: $limit, offset: $offset) {
+      ${DEPOSIT_FIELDS}
+    }
+  }
+`
+);
+var DEPOSITS_BY_IDS_QUERY = (
+  /* GraphQL */
+  `
+  query GetDepositsByIds($ids: [String!]) {
+    Deposit(where: { id: { _in: $ids } }) {
+      ${DEPOSIT_FIELDS}
+    }
+  }
+`
+);
+var DEPOSIT_RELATIONS_QUERY = (
+  /* GraphQL */
+  `
+  query GetDepositRelations($depositIds: [String!]) {
+    DepositPaymentMethod(where: { depositId: { _in: $depositIds } }) {
+      id
+      chainId
+      depositIdOnContract
+      depositId
+      paymentMethodHash
+      verifierAddress
+      intentGatingService
+      payeeDetailsHash
+      active
+    }
+    MethodCurrency(where: { depositId: { _in: $depositIds } }) {
+      id
+      chainId
+      depositIdOnContract
+      depositId
+      paymentMethodHash
+      currencyCode
+      minConversionRate
+    }
+  }
+`
+);
+var PAYMENT_METHODS_BY_PAYEE_HASH_QUERY = (
+  /* GraphQL */
+  `
+  query GetPaymentMethodsByPayeeHash(
+    $where: DepositPaymentMethod_bool_exp!
+    $limit: Int
+  ) {
+    DepositPaymentMethod(where: $where, limit: $limit) {
+      id
+      chainId
+      depositIdOnContract
+      depositId
+      paymentMethodHash
+      verifierAddress
+      intentGatingService
+      payeeDetailsHash
+      active
+    }
+  }
+`
+);
+var DEPOSIT_WITH_RELATIONS_QUERY = (
+  /* GraphQL */
+  `
+  query GetDepositWithRelations($id: String!) {
+    Deposit_by_pk(id: $id) {
+      ${DEPOSIT_FIELDS}
+    }
+    DepositPaymentMethod(where: { depositId: { _eq: $id } }) {
+      id
+      chainId
+      depositIdOnContract
+      depositId
+      paymentMethodHash
+      verifierAddress
+      intentGatingService
+      payeeDetailsHash
+      active
+    }
+    MethodCurrency(where: { depositId: { _eq: $id } }) {
+      id
+      chainId
+      depositIdOnContract
+      depositId
+      paymentMethodHash
+      currencyCode
+      minConversionRate
+    }
+  }
+`
+);
+var INTENTS_QUERY = (
+  /* GraphQL */
+  `
+  query GetIntents(
+    $where: Intent_bool_exp
+    $order_by: [Intent_order_by!]
+    $limit: Int
+    $offset: Int
+  ) {
+    Intent(where: $where, order_by: $order_by, limit: $limit, offset: $offset) {
+      id
+      intentHash
+      depositId
+      orchestratorAddress
+      verifier
+      owner
+      toAddress
+      amount
+      fiatCurrency
+      conversionRate
+      status
+      isExpired
+      signalTimestamp
+      expiryTime
+      fulfillTimestamp
+      pruneTimestamp
+      updatedAt
+      signalTxHash
+      fulfillTxHash
+      pruneTxHash
+      paymentMethodHash
+      paymentAmount
+      paymentCurrency
+      paymentTimestamp
+      paymentId
+      releasedAmount
+      takerAmountNetFees
+    }
+  }
+`
+);
+var EXPIRED_INTENTS_QUERY = (
+  /* GraphQL */
+  `
+  query GetExpiredIntents(
+    $now: numeric!
+    $limit: Int
+    $depositIds: [String!]
+  ) {
+    Intent(
+      where: {
+        status: { _eq: "SIGNALED" }
+        expiryTime: { _lt: $now }
+        depositId: { _in: $depositIds }
+      }
+      order_by: { expiryTime: asc }
+      limit: $limit
+    ) {
+      id
+      intentHash
+      depositId
+      owner
+      toAddress
+      amount
+      expiryTime
+      isExpired
+      updatedAt
+      paymentMethodHash
+    }
+  }
+`
+);
+var INTENT_FULFILLMENTS_QUERY = (
+  /* GraphQL */
+  `
+  query GetFulfilledIntents($intentHashes: [String!]) {
+    Orchestrator_V21_IntentFulfilled(
+      where: { intentHash: { _in: $intentHashes } }
+    ) {
+      intentHash
+      isManualRelease
+      fundsTransferredTo
+    }
+  }
+`
+);
+var FULFILLMENT_AND_PAYMENT_QUERY = (
+  /* GraphQL */
+  `
+  query PaymentVerificationForFulfilledIntent($intentHash: String!) {
+    Orchestrator_V21_IntentFulfilled(
+      where: { intentHash: { _eq: $intentHash } }
+    ) {
+      id
+      intentHash
+      amount
+      isManualRelease
+      fundsTransferredTo
+    }
+    UnifiedVerifier_V21_PaymentVerified(
+      where: { intentHash: { _eq: $intentHash } }
+    ) {
+      id
+      intentHash
+      method
+      currency
+      amount
+      timestamp
+      paymentId
+      payeeId
+    }
+  }
+`
+);
+
+// src/indexer/converters.ts
+var ZERO = "0x0000000000000000000000000000000000000000";
+function toBigInt(value) {
+  if (value === null || value === void 0) return 0n;
+  try {
+    return typeof value === "bigint" ? value : BigInt(value);
+  } catch {
+    return 0n;
+  }
+}
+function normalizeAddress(value) {
+  if (!value) return ZERO;
+  return value.startsWith("0x") ? value : ZERO;
+}
+function extractDepositId(compositeId) {
+  const parts = compositeId.split("_");
+  return parts[1] || "0";
+}
+function createCompositeDepositId(escrowAddress, depositId) {
+  return `${escrowAddress.toLowerCase()}_${depositId.toString()}`;
+}
+function convertIndexerDepositToEscrowView(deposit, _chainId, _escrowAddress) {
+  const paymentMethods = (deposit.paymentMethods ?? []).filter((pm) => pm.active !== false);
+  const currencies = deposit.currencies ?? [];
+  const currenciesByPaymentMethod = /* @__PURE__ */ new Map();
+  for (const c of currencies) {
+    const bucket = currenciesByPaymentMethod.get(c.paymentMethodHash) ?? [];
+    bucket.push(c);
+    currenciesByPaymentMethod.set(c.paymentMethodHash, bucket);
+  }
+  const verifiers = paymentMethods.map((pm) => ({
+    verifier: normalizeAddress(pm.verifierAddress),
+    verificationData: {
+      intentGatingService: normalizeAddress(pm.intentGatingService),
+      payeeDetails: pm.payeeDetailsHash ?? "",
+      data: ""
+    },
+    currencies: (currenciesByPaymentMethod.get(pm.paymentMethodHash) ?? []).map((cur) => ({
+      code: cur.currencyCode,
+      conversionRate: toBigInt(cur.minConversionRate)
+    })),
+    methodHash: pm.paymentMethodHash
+  }));
+  const uniqueIntentHashes = new Set((deposit.intents ?? []).map((i) => i.intentHash));
+  const remaining = toBigInt(deposit.remainingDeposits);
+  const outstanding = toBigInt(deposit.outstandingIntentAmount);
+  const depositAmount = remaining + outstanding + toBigInt(deposit.totalAmountTaken ?? 0) + toBigInt(deposit.totalWithdrawn ?? 0);
+  return {
+    depositId: toBigInt(deposit.depositId),
+    deposit: {
+      depositor: normalizeAddress(deposit.depositor),
+      token: normalizeAddress(deposit.token),
+      depositAmount,
+      intentAmountRange: { min: toBigInt(deposit.intentAmountMin), max: toBigInt(deposit.intentAmountMax) },
+      acceptingIntents: Boolean(deposit.acceptingIntents),
+      remainingDepositAmount: remaining,
+      outstandingIntentAmount: outstanding,
+      intentHashes: Array.from(uniqueIntentHashes)
+    },
+    verifiers
+  };
+}
+function convertDepositsForLiquidity(deposits, chainId, escrowAddress) {
+  return deposits.filter((d) => d.depositor && d.depositor.toLowerCase() !== ZERO && d.acceptingIntents && toBigInt(d.remainingDeposits) > 0n && d.status === "ACTIVE").map((d) => convertIndexerDepositToEscrowView(d));
+}
+function convertIndexerIntentsToEscrowViews(intents, depositViewsById) {
+  const result = [];
+  for (const intent of intents) {
+    const depositView = depositViewsById.get(intent.depositId.toLowerCase());
+    if (!depositView) continue;
+    const rawDepositId = extractDepositId(intent.depositId);
+    result.push({
+      intentHash: intent.intentHash,
+      intent: {
+        owner: normalizeAddress(intent.owner),
+        to: normalizeAddress(intent.toAddress),
+        depositId: toBigInt(rawDepositId),
+        amount: toBigInt(intent.amount),
+        timestamp: toBigInt(intent.signalTimestamp),
+        paymentVerifier: normalizeAddress(intent.verifier),
+        fiatCurrency: intent.fiatCurrency,
+        conversionRate: toBigInt(intent.conversionRate)
+      },
+      deposit: depositView
+    });
+  }
+  return result;
+}
+
+// src/indexer/service.ts
+function groupByDepositId(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!item.depositId) continue;
+    const key = item.depositId.toLowerCase();
+    const bucket = map.get(key);
+    if (bucket) bucket.push(item);
+    else map.set(key, [item]);
+  }
+  return map;
+}
+var DEFAULT_LIMIT = 100;
+var DEFAULT_ORDER_FIELD = "remainingDeposits";
+var IndexerDepositService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  buildDepositWhere(filter) {
+    if (!filter) return void 0;
+    const where = {};
+    if (filter.status) where.status = { _eq: filter.status };
+    if (filter.depositor) where.depositor = { _ilike: filter.depositor };
+    if (filter.chainId) where.chainId = { _eq: filter.chainId };
+    if (filter.escrowAddresses && filter.escrowAddresses.length) {
+      where.escrowAddress = { _in: filter.escrowAddresses };
+    } else if (filter.escrowAddress) {
+      where.escrowAddress = { _ilike: filter.escrowAddress };
+    }
+    if (filter.acceptingIntents !== void 0) where.acceptingIntents = { _eq: filter.acceptingIntents };
+    if (filter.minLiquidity) where.remainingDeposits = { _gte: filter.minLiquidity };
+    return Object.keys(where).length ? where : void 0;
+  }
+  buildOrderBy(pagination) {
+    const field = pagination?.orderBy ?? DEFAULT_ORDER_FIELD;
+    const direction = pagination?.orderDirection === "asc" ? "asc" : "desc";
+    return [{ [field]: direction }];
+  }
+  async fetchRelations(depositIds) {
+    if (!depositIds.length) {
+      return {
+        paymentMethodsByDeposit: /* @__PURE__ */ new Map(),
+        currenciesByDeposit: /* @__PURE__ */ new Map()
+      };
+    }
+    const result = await this.client.query({ query: DEPOSIT_RELATIONS_QUERY, variables: { depositIds } });
+    const paymentMethodsByDeposit = groupByDepositId(result.DepositPaymentMethod ?? []);
+    const currenciesByDeposit = groupByDepositId(result.MethodCurrency ?? []);
+    return { paymentMethodsByDeposit, currenciesByDeposit };
+  }
+  async fetchIntents(params) {
+    const where = {};
+    if (params.depositIds?.length) where.depositId = { _in: params.depositIds };
+    if (params.owner) where.owner = { _ilike: params.owner };
+    if (params.statuses?.length) where.status = { _in: params.statuses };
+    if (!Object.keys(where).length) return [];
+    const result = await this.client.query({
+      query: INTENTS_QUERY,
+      variables: { where, order_by: [{ signalTimestamp: "desc" }], limit: params.limit, offset: params.offset }
+    });
+    return result.Intent ?? [];
+  }
+  async attachRelations(deposits, options = {}) {
+    if (!deposits.length) return [];
+    const depositIds = deposits.map((d) => d.id);
+    const [{ paymentMethodsByDeposit, currenciesByDeposit }, intents] = await Promise.all([
+      this.fetchRelations(depositIds),
+      options.includeIntents ? this.fetchIntents({ depositIds, statuses: options.intentStatuses }) : Promise.resolve([])
+    ]);
+    const intentsByDeposit = options.includeIntents ? groupByDepositId(intents) : /* @__PURE__ */ new Map();
+    return deposits.map((d) => {
+      const key = d.id.toLowerCase();
+      return {
+        ...d,
+        paymentMethods: paymentMethodsByDeposit.get(key) ?? [],
+        currencies: currenciesByDeposit.get(key) ?? [],
+        intents: options.includeIntents ? intentsByDeposit.get(key) ?? [] : void 0
+      };
+    });
+  }
+  async fetchDeposits(filter, pagination) {
+    const result = await this.client.query({
+      query: DEPOSITS_QUERY,
+      variables: {
+        where: this.buildDepositWhere(filter),
+        order_by: this.buildOrderBy(pagination),
+        limit: pagination?.limit ?? DEFAULT_LIMIT,
+        offset: pagination?.offset ?? 0
+      }
+    });
+    return result.Deposit ?? [];
+  }
+  async fetchDepositsWithRelations(filter, pagination, options = {}) {
+    const deposits = await this.fetchDeposits(filter, pagination);
+    return this.attachRelations(deposits, options);
+  }
+  async fetchDepositsByIds(ids) {
+    if (!ids.length) return [];
+    const result = await this.client.query({ query: DEPOSITS_BY_IDS_QUERY, variables: { ids } });
+    return result.Deposit ?? [];
+  }
+  async fetchDepositsByIdsWithRelations(ids, options = {}) {
+    const deposits = await this.fetchDepositsByIds(ids);
+    return this.attachRelations(deposits, options);
+  }
+  async fetchIntentsForDeposits(depositIds, statuses) {
+    if (!depositIds.length) return [];
+    return this.fetchIntents({ depositIds, statuses });
+  }
+  async fetchIntentsByOwner(owner, statuses) {
+    if (!owner) return [];
+    return this.fetchIntents({ owner, statuses });
+  }
+  async fetchDepositWithRelations(id, options = {}) {
+    const result = await this.client.query({ query: DEPOSIT_WITH_RELATIONS_QUERY, variables: { id } });
+    const deposit = result.Deposit_by_pk;
+    if (!deposit) return null;
+    const base2 = { ...deposit, paymentMethods: result.DepositPaymentMethod ?? [], currencies: result.MethodCurrency ?? [] };
+    if (!options.includeIntents) return base2;
+    const intents = await this.fetchIntents({ depositIds: [deposit.id], statuses: options.intentStatuses });
+    return { ...base2, intents };
+  }
+  async fetchExpiredIntents(params) {
+    const depositIds = params.depositIds.map((id) => id.toLowerCase());
+    if (!depositIds.length) return [];
+    const result = await this.client.query({
+      query: EXPIRED_INTENTS_QUERY,
+      variables: {
+        now: typeof params.now === "bigint" ? params.now.toString() : params.now,
+        limit: params.limit ?? 1e3,
+        depositIds
+      }
+    });
+    return result.Intent ?? [];
+  }
+  async fetchFulfilledIntentEvents(intentHashes) {
+    if (!intentHashes.length) return [];
+    const uniqueHashes = Array.from(new Set(intentHashes)).filter(Boolean);
+    if (!uniqueHashes.length) return [];
+    const result = await this.client.query({
+      query: INTENT_FULFILLMENTS_QUERY,
+      variables: { intentHashes: uniqueHashes }
+    });
+    return result.Orchestrator_V21_IntentFulfilled ?? [];
+  }
+  async resolvePayeeHash(params) {
+    try {
+      const { escrowAddress, depositId, paymentMethodHash } = params;
+      if (!escrowAddress || depositId === null || depositId === void 0 || !paymentMethodHash) return null;
+      const compositeId = createCompositeDepositId(
+        escrowAddress,
+        typeof depositId === "bigint" ? depositId : depositId?.toString() ?? ""
+      );
+      const detail = await this.fetchDepositWithRelations(compositeId, { includeIntents: false });
+      if (!detail?.paymentMethods?.length) return null;
+      const target = paymentMethodHash.toLowerCase();
+      const match = detail.paymentMethods.find((pm) => (pm.paymentMethodHash ?? "").toLowerCase() === target);
+      return match?.payeeDetailsHash ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async fetchDepositsByPayeeHash(payeeHash, options = {}) {
+    if (!payeeHash) return [];
+    const normalizedHash = payeeHash.toLowerCase();
+    const where = {
+      payeeDetailsHash: { _ilike: normalizedHash }
+    };
+    if (options.paymentMethodHash) {
+      where.paymentMethodHash = { _eq: options.paymentMethodHash.toLowerCase?.() ?? options.paymentMethodHash };
+    }
+    const result = await this.client.query({
+      query: PAYMENT_METHODS_BY_PAYEE_HASH_QUERY,
+      variables: { where, limit: options.limit }
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const depositIds = [];
+    for (const pm of result.DepositPaymentMethod ?? []) {
+      const id = pm.depositId;
+      if (!id) continue;
+      const key = id.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      depositIds.push(id);
+    }
+    if (!depositIds.length) return [];
+    return this.fetchDepositsByIdsWithRelations(depositIds, {
+      includeIntents: options.includeIntents,
+      intentStatuses: options.intentStatuses
+    });
+  }
+};
+
+// src/indexer/intentVerification.ts
+async function fetchFulfillmentAndPayment(client, intentHash) {
+  return client.query({
+    query: FULFILLMENT_AND_PAYMENT_QUERY,
+    variables: { intentHash }
+  });
+}
+
+// src/client/Zkp2pClient.ts
+init_contracts();
+
+// src/adapters/verification.ts
+async function apiSignIntentV2(request, opts) {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), opts.timeoutMs ?? 15e3);
+  try {
+    const headers2 = { "Content-Type": "application/json" };
+    if (opts.apiKey) headers2["x-api-key"] = opts.apiKey;
+    if (opts.authorizationToken) headers2["authorization"] = `Bearer ${opts.authorizationToken}`;
+    const res = await fetch(`${opts.baseApiUrl.replace(/\/$/, "")}/v2/verify/intent`, {
+      method: "POST",
+      headers: headers2,
+      body: JSON.stringify(request),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`verify/intent failed: ${res.status} ${res.statusText} ${text}`);
+    }
+    const json = await res.json();
+    const sig = json?.responseObject?.signedIntent;
+    const expStr = json?.responseObject?.intentData?.signatureExpiration ?? json?.responseObject?.signatureExpiration;
+    if (!sig || !expStr) throw new Error("verify/intent missing signature or expiration");
+    return { signature: sig, signatureExpiration: BigInt(expStr) };
+  } finally {
+    clearTimeout(id);
+  }
+}
+
+// src/adapters/attestation.ts
+init_errors();
+
+// src/errors/utils.ts
+init_errors();
+function parseAPIError(response, responseText) {
+  let message = `Request failed: ${response.statusText}`;
+  try {
+    const parsed = responseText ? JSON.parse(responseText) : void 0;
+    if (parsed && (parsed.error || parsed.message)) {
+      message = parsed.error || parsed.message;
+    }
+  } catch {
+    if (responseText && responseText.length < 200) message = responseText;
+  }
+  if (response.status === 429) {
+    message = "Too many requests. Please try again later.";
+  }
+  return new exports.APIError(message, response.status, { url: response.url });
+}
+async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs) {
+  let lastErr;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      if (timeoutMs) {
+        const { withTimeout: withTimeout2 } = await Promise.resolve().then(() => (init_timeout(), timeout_exports));
+        return await withTimeout2(fn(), timeoutMs, `Operation timed out after ${timeoutMs}ms`);
+      }
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      const isNetwork = err instanceof exports.NetworkError;
+      const isRateLimit = err instanceof exports.APIError && err.status === 429;
+      const retryable = isNetwork || isRateLimit;
+      if (!retryable || i === maxRetries - 1) throw err;
+      const base2 = isRateLimit ? delayMs * Math.pow(2, i) : delayMs;
+      const jitter = Math.floor(Math.random() * Math.min(1e3, base2));
+      await new Promise((r) => setTimeout(r, base2 + jitter));
+    }
+  }
+  throw lastErr;
+}
+
+// src/adapters/attestation.ts
+function headers() {
+  return { "Content-Type": "application/json" };
+}
+async function apiCreatePaymentAttestation(payload, attestationServiceUrl, platform, actionType) {
+  return withRetry(async () => {
+    let res;
+    try {
+      const endpoint = `/verify/${encodeURIComponent(platform)}/${encodeURIComponent(actionType)}`;
+      res = await fetch(`${attestationServiceUrl}${endpoint}`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(payload)
+      });
+    } catch (error) {
+      throw new exports.NetworkError("Failed to connect to Attestation Service", {
+        endpoint: `/verify/${platform}/${actionType}`,
+        error
+      });
+    }
+    if (!res.ok) {
+      const errorText = await res.text();
+      throw parseAPIError(res, errorText);
+    }
+    return res.json();
+  });
+}
+var abiCoder = ethers.AbiCoder.defaultAbiCoder();
+function encodeVerifyPaymentData(params) {
+  return abiCoder.encode(
+    ["tuple(bytes32,bytes,bytes)"],
+    [[params.intentHash, params.paymentProof, params.data]]
+  );
+}
+function encodeAddressAsBytes(addr) {
+  return abiCoder.encode(["address"], [addr]);
+}
+function encodePaymentAttestation(attestation) {
+  const resp = attestation.responseObject;
+  const td = resp.typedDataValue;
+  const intentHash = td.intentHash;
+  const releaseAmount = BigInt(td.releaseAmount);
+  const dataHash = td.dataHash;
+  const signatures = [resp.signature];
+  const encodedPaymentDetails = resp.encodedPaymentDetails;
+  if (!intentHash || !releaseAmount || !dataHash || !encodedPaymentDetails) {
+    throw new Error("Attestation response missing required fields");
+  }
+  return abiCoder.encode(
+    ["tuple(bytes32,uint256,bytes32,bytes[],bytes,bytes)"],
+    [[intentHash, releaseAmount, dataHash, signatures, encodedPaymentDetails, "0x"]]
+  );
+}
+
+// src/adapters/api.ts
+init_errors();
+function createHeaders(apiKey, authToken) {
+  const headers2 = { "Content-Type": "application/json" };
+  if (apiKey) headers2["x-api-key"] = apiKey;
+  if (authToken) headers2["Authorization"] = authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
+  return headers2;
+}
+function withApiBase(baseApiUrl) {
+  const trimmed = (baseApiUrl || "").trim();
+  let base2 = trimmed.replace(/\/+$/, "");
+  base2 = base2.replace(/\/v1$/i, "");
+  base2 = base2.replace(/\/v2$/i, "");
+  return base2;
+}
+async function apiFetch({
+  url,
+  method = "GET",
+  body,
+  apiKey,
+  authToken,
+  timeoutMs,
+  retryCount = 3,
+  retryDelayMs = 1e3
+}) {
+  const endpoint = url.replace(/^[^/]*\/\/[^/]*/, "");
+  return withRetry(async () => {
+    let res;
+    try {
+      const options = {
+        method,
+        headers: createHeaders(apiKey, authToken)
+      };
+      if (body && method !== "GET") {
+        options.body = JSON.stringify(body);
+      }
+      res = await fetch(url, options);
+    } catch (error) {
+      throw new exports.NetworkError("Failed to connect to API server", { endpoint, error });
+    }
+    if (!res.ok) {
+      const errorText = await res.text();
+      throw parseAPIError(res, errorText);
+    }
+    return res.json();
+  }, retryCount, retryDelayMs, timeoutMs);
+}
+async function apiPostDepositDetails(req, baseApiUrl, timeoutMs) {
+  return apiFetch({
+    url: `${baseApiUrl.replace(/\/$/, "")}/v1/makers/create`,
+    method: "POST",
+    body: req,
+    timeoutMs
+  });
+}
+async function apiGetQuote(req, baseApiUrl, timeoutMs, apiKey, authToken) {
+  if (req.quotesToReturn !== void 0) {
+    if (!Number.isInteger(req.quotesToReturn) || req.quotesToReturn < 1) {
+      throw new exports.ValidationError("quotesToReturn must be a positive integer", "quotesToReturn");
+    }
+  }
+  const isExactFiat = req.isExactFiat !== false;
+  const endpoint = isExactFiat ? "exact-fiat" : "exact-token";
+  let url = `${withApiBase(baseApiUrl)}/v2/quote/${endpoint}`;
+  if (req.quotesToReturn) url += `?quotesToReturn=${req.quotesToReturn}`;
+  const requestBody = {
+    ...req,
+    [isExactFiat ? "exactFiatAmount" : "exactTokenAmount"]: req.amount,
+    amount: void 0,
+    isExactFiat: void 0,
+    quotesToReturn: void 0
+  };
+  Object.keys(requestBody).forEach((k) => requestBody[k] === void 0 && delete requestBody[k]);
+  return apiFetch({
+    url,
+    method: "POST",
+    body: requestBody,
+    apiKey,
+    authToken,
+    timeoutMs
+  });
+}
+async function apiGetPayeeDetails(req, apiKey, baseApiUrl, authToken, timeoutMs) {
+  return apiFetch({
+    url: `${baseApiUrl.replace(/\/$/, "")}/v1/makers/${req.processorName}/${req.hashedOnchainId}`,
+    method: "GET",
+    apiKey,
+    authToken,
+    timeoutMs
+  });
+}
+async function apiValidatePayeeDetails(req, baseApiUrl, timeoutMs) {
+  const data = await apiFetch({
+    url: `${baseApiUrl.replace(/\/$/, "")}/v1/makers/validate`,
+    method: "POST",
+    body: req,
+    timeoutMs
+  });
+  if (typeof data?.responseObject === "boolean") {
+    return {
+      ...data,
+      responseObject: { isValid: data.responseObject }
+    };
+  }
+  return data;
+}
+async function apiGetTakerTier(req, apiKey, baseApiUrl, authToken, timeoutMs) {
+  const normalizedOwner = req.owner.toLowerCase();
+  const query = new URLSearchParams({
+    owner: normalizedOwner,
+    chainId: String(req.chainId)
+  });
+  const endpoint = `/v2/taker/tier?${query.toString()}`;
+  return apiFetch({
+    url: `${withApiBase(baseApiUrl)}${endpoint}`,
+    method: "GET",
+    apiKey,
+    authToken,
+    timeoutMs
+  });
+}
+
+// src/client/Zkp2pClient.ts
+init_contracts();
+init_paymentResolution();
+init_keccak();
+
+// src/utils/erc20.ts
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "amount", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  }
+];
+var BASE_BUILDER_CODE = "bc_nbn6qkni";
+var ZKP2P_IOS_REFERRER = "zkp2p-ios";
+var ZKP2P_ANDROID_REFERRER = "zkp2p-android";
+function getAttributionDataSuffix(referrer) {
+  const codes = [];
+  if (referrer) {
+    if (Array.isArray(referrer)) {
+      codes.push(...referrer);
+    } else {
+      codes.push(referrer);
+    }
+  }
+  codes.push(BASE_BUILDER_CODE);
+  return erc8021.Attribution.toDataSuffix({ codes });
+}
+function appendAttributionToCalldata(calldata, referrer) {
+  const suffix = getAttributionDataSuffix(referrer);
+  return viem.concatHex([calldata, suffix]);
+}
+async function sendTransactionWithAttribution(walletClient, request, referrer, overrides) {
+  const functionData = viem.encodeFunctionData({
+    abi: request.abi,
+    functionName: request.functionName,
+    args: request.args || []
+  });
+  const dataWithAttribution = appendAttributionToCalldata(functionData, referrer);
+  const {
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    value,
+    accessList,
+    authorizationList
+  } = overrides ?? {};
+  const optionalOverrides = {
+    ...gas !== void 0 ? { gas } : {},
+    ...gasPrice !== void 0 ? { gasPrice } : {},
+    ...maxFeePerGas !== void 0 ? { maxFeePerGas } : {},
+    ...maxPriorityFeePerGas !== void 0 ? { maxPriorityFeePerGas } : {},
+    ...nonce !== void 0 ? { nonce } : {},
+    ...accessList !== void 0 ? { accessList } : {},
+    ...authorizationList !== void 0 ? { authorizationList } : {}
+  };
+  return walletClient.sendTransaction({
+    to: request.address,
+    data: dataWithAttribution,
+    value: value ?? request.value,
+    account: walletClient.account,
+    chain: walletClient.chain,
+    ...optionalOverrides
+  });
+}
+
+// src/client/Zkp2pClient.ts
+var Zkp2pClient = class {
+  /**
+   * Creates a new Zkp2pClient instance.
+   *
+   * @param opts - Configuration options
+   * @throws Error if walletClient is missing an account
+   */
+  constructor(opts) {
+    this.walletClient = opts.walletClient;
+    this.chainId = opts.chainId;
+    this.runtimeEnv = opts.runtimeEnv ?? "production";
+    const inferredRpc = this.walletClient?.chain?.rpcUrls?.default?.http?.[0];
+    const defaultRpcUrls = {
+      [chains.base.id]: "https://mainnet.base.org",
+      [chains.baseSepolia.id]: "https://sepolia.base.org",
+      [chains.hardhat.id]: "http://127.0.0.1:8545"
+    };
+    const rpc = opts.rpcUrl ?? inferredRpc ?? defaultRpcUrls[opts.chainId] ?? "https://mainnet.base.org";
+    const chainMap = { [chains.base.id]: chains.base, [chains.baseSepolia.id]: chains.baseSepolia, [chains.hardhat.id]: chains.hardhat };
+    const selectedChain = chainMap[this.chainId];
+    this.publicClient = viem.createPublicClient({ chain: selectedChain, transport: viem.http(rpc, { batch: false }) });
+    const { addresses, abis } = getContracts(this.chainId, this.runtimeEnv);
+    this.escrowAddress = addresses.escrow;
+    this.escrowAbi = abis.escrow;
+    this.orchestratorAddress = addresses.orchestrator;
+    this.orchestratorAbi = abis.orchestrator;
+    this.unifiedPaymentVerifier = addresses.unifiedPaymentVerifier;
+    this.protocolViewerAddress = addresses.protocolViewer;
+    this.protocolViewerAbi = abis.protocolViewer;
+    const maybeUsdc = addresses.usdc;
+    if (maybeUsdc) this._usdcAddress = maybeUsdc;
+    const indexerEndpoint = opts.indexerUrl ?? defaultIndexerEndpoint(this.runtimeEnv === "staging" ? "STAGING" : "PRODUCTION");
+    this._indexerClient = new IndexerClient(indexerEndpoint);
+    this._indexerService = new IndexerDepositService(this._indexerClient);
+    this.baseApiUrl = opts.baseApiUrl;
+    this.apiKey = opts.apiKey;
+    this.authorizationToken = opts.authorizationToken;
+    this.apiTimeoutMs = opts.timeouts?.api ?? 15e3;
+  }
+  isValidHexAddress(addr) {
+    if (typeof addr !== "string") return false;
+    return /^0x[0-9a-fA-F]{40}$/.test(addr);
+  }
+  /**
+   * Simulate a contract call (validation only) and send with ERC-8021 attribution.
+   * Referrer codes are stripped from overrides for simulation and appended to calldata.
+   */
+  async simulateAndSendWithAttribution(opts) {
+    const { referrer, ...txOverrides } = opts.txOverrides ?? {};
+    await this.publicClient.simulateContract({
+      address: opts.address,
+      abi: opts.abi,
+      functionName: opts.functionName,
+      args: opts.args ?? [],
+      account: this.walletClient.account,
+      ...txOverrides
+    });
+    return sendTransactionWithAttribution(
+      this.walletClient,
+      {
+        address: opts.address,
+        abi: opts.abi,
+        functionName: opts.functionName,
+        args: opts.args ?? [],
+        value: opts.value ?? txOverrides.value
+      },
+      referrer,
+      txOverrides
+    );
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: DEPOSIT QUERIES (RPC-first via ProtocolViewer)                     ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Fetches all deposits owned by the connected wallet from on-chain.
+   *
+   * This is the primary method for liquidity providers to query their deposits.
+   * Uses ProtocolViewer for instant on-chain reads (no indexer lag).
+   *
+   * @returns Array of deposit views with payment methods and currencies
+   *
+   * @example
+   * ```typescript
+   * const deposits = await client.getDeposits();
+   * for (const d of deposits) {
+   *   console.log(`Deposit ${d.depositId}: ${d.availableLiquidity} available`);
+   * }
+   * ```
+   */
+  async getDeposits() {
+    const owner = this.walletClient.account?.address;
+    if (!owner) throw new Error("Wallet client is missing account");
+    return this.getAccountDeposits(owner);
+  }
+  /**
+   * Fetches all deposits owned by a specific address from on-chain.
+   *
+   * Uses ProtocolViewer for instant on-chain reads.
+   *
+   * @param owner - The owner's Ethereum address
+   * @returns Array of deposit views with payment methods and currencies
+   *
+   * @example
+   * ```typescript
+   * const deposits = await client.getAccountDeposits('0x...');
+   * ```
+   */
+  async getAccountDeposits(owner) {
+    return this.getPvAccountDeposits(owner);
+  }
+  /**
+   * Fetches a single deposit by its numeric ID from on-chain.
+   *
+   * Uses ProtocolViewer for instant on-chain reads.
+   *
+   * @param depositId - The deposit ID (numeric)
+   * @returns Deposit view with payment methods, currencies, and intent hashes
+   *
+   * @example
+   * ```typescript
+   * const deposit = await client.getDeposit(42n);
+   * console.log(`Available: ${deposit.availableLiquidity}`);
+   * console.log(`Payment methods: ${deposit.paymentMethods.length}`);
+   * ```
+   */
+  async getDeposit(depositId) {
+    const id = typeof depositId === "bigint" ? depositId : BigInt(depositId);
+    return this.getPvDepositById(id);
+  }
+  /**
+   * Fetches multiple deposits by their IDs from on-chain in a batch.
+   *
+   * @param depositIds - Array of deposit IDs
+   * @returns Array of deposit views
+   */
+  async getDepositsById(depositIds) {
+    const ids = depositIds.map((id) => typeof id === "bigint" ? id : BigInt(id));
+    return this.getPvDepositsFromIds(ids);
+  }
+  /**
+   * Fetches all intents created by the connected wallet from on-chain.
+   *
+   * Uses ProtocolViewer for instant on-chain reads.
+   *
+   * @returns Array of intent views with deposit context
+   *
+   * @example
+   * ```typescript
+   * const intents = await client.getIntents();
+   * for (const i of intents) {
+   *   console.log(`Intent ${i.intentHash}: ${i.intent.amount} tokens`);
+   * }
+   * ```
+   */
+  async getIntents() {
+    const owner = this.walletClient.account?.address;
+    if (!owner) throw new Error("Wallet client is missing account");
+    return this.getAccountIntents(owner);
+  }
+  /**
+   * Fetches all intents created by a specific address from on-chain.
+   *
+   * @param owner - The owner's Ethereum address
+   * @returns Array of intent views with deposit context
+   */
+  async getAccountIntents(owner) {
+    return this.getPvAccountIntents(owner);
+  }
+  /**
+   * Fetches a single intent by its hash from on-chain.
+   *
+   * @param intentHash - The intent hash (0x-prefixed, 32 bytes)
+   * @returns Intent view with deposit context
+   */
+  async getIntent(intentHash) {
+    return this.getPvIntent(intentHash);
+  }
+  /**
+   * Resolves the payee details hash for a deposit's payment method from on-chain.
+   *
+   * @param depositId - The deposit ID
+   * @param paymentMethodHash - The payment method hash
+   * @returns The payee details hash, or null if not found
+   */
+  async resolvePayeeHash(depositId, paymentMethodHash) {
+    const deposit = await this.getDeposit(depositId);
+    const pmLower = paymentMethodHash.toLowerCase();
+    for (const pm of deposit.paymentMethods) {
+      if (pm.paymentMethod.toLowerCase() === pmLower) {
+        return pm.verificationData.payeeDetails;
+      }
+    }
+    return null;
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ ADVANCED: INDEXER QUERIES (for historical/filtered data)                 ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Access to the indexer for advanced queries.
+   *
+   * Use this for:
+   * - Historical data (totalAmountTaken, totalWithdrawn)
+   * - Filtered queries across all deposits (not just by owner)
+   * - Pagination with ordering
+   * - Fulfillment/verification records
+   *
+   * @example
+   * ```typescript
+   * // Query deposits with filters and pagination
+   * const deposits = await client.indexer.getDeposits(
+   *   { status: 'ACTIVE', minLiquidity: '1000000' },
+   *   { limit: 50, orderBy: 'remainingDeposits', orderDirection: 'desc' }
+   * );
+   *
+   * // Get historical fulfillment data
+   * const fulfillments = await client.indexer.getFulfilledIntentEvents(['0x...']);
+   * ```
+   */
+  get indexer() {
+    const service = this._indexerService;
+    const client = this._indexerClient;
+    return {
+      /** Raw GraphQL client for custom queries */
+      client,
+      /**
+       * Fetches deposits from the indexer with optional filtering and pagination.
+       * Use for advanced queries across all deposits, not just by owner.
+       */
+      getDeposits: (filter, pagination) => {
+        return service.fetchDeposits(filter, pagination);
+      },
+      /**
+       * Fetches deposits with their related payment methods and optionally intents.
+       */
+      getDepositsWithRelations: (filter, pagination, options) => {
+        return service.fetchDepositsWithRelations(filter, pagination, options);
+      },
+      /**
+       * Fetches a single deposit by its composite ID with all related data.
+       * @param id - Composite ID format: "chainId_escrowAddress_depositId"
+       */
+      getDepositById: (id, options) => {
+        return service.fetchDepositWithRelations(id, options);
+      },
+      /**
+       * Fetches intents for multiple deposits.
+       */
+      getIntentsForDeposits: (depositIds, statuses = ["SIGNALED"]) => {
+        return service.fetchIntentsForDeposits(depositIds, statuses);
+      },
+      /**
+       * Fetches all intents created by a specific owner address.
+       */
+      getOwnerIntents: (owner, statuses) => {
+        return service.fetchIntentsByOwner(owner, statuses);
+      },
+      /**
+       * Fetches intents that have expired.
+       */
+      getExpiredIntents: (params) => {
+        return service.fetchExpiredIntents(params);
+      },
+      /**
+       * Fetches fulfillment events for completed intents.
+       */
+      getFulfilledIntentEvents: (intentHashes) => {
+        return service.fetchFulfilledIntentEvents(intentHashes);
+      },
+      /**
+       * Fetches both the fulfillment record and payment verification for an intent.
+       */
+      getFulfillmentAndPayment: (intentHash) => {
+        return fetchFulfillmentAndPayment(client, intentHash);
+      },
+      /**
+       * Fetches deposits that match a specific payee details hash.
+       */
+      getDepositsByPayeeHash: (payeeHash, options = {}) => {
+        return service.fetchDepositsByPayeeHash(payeeHash, options);
+      }
+    };
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: DEPOSIT CREATION                                                   ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Ensures ERC20 token allowance is sufficient for the Escrow contract.
+   *
+   * If the current allowance is less than the requested amount, this method
+   * will submit an approval transaction. Use `maxApprove: true` for unlimited
+   * approval to avoid repeated approval transactions.
+   *
+   * @param params.token - ERC20 token address to approve
+   * @param params.amount - Minimum required allowance amount
+   * @param params.spender - Spender address (defaults to Escrow contract)
+   * @param params.maxApprove - If true, approves MaxUint256 instead of exact amount
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Object with `hadAllowance` (true if no approval needed) and optional `hash`
+   *
+   * @example
+   * ```typescript
+   * // Ensure allowance for 1000 USDC
+   * const { hadAllowance, hash } = await client.ensureAllowance({
+   *   token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+   *   amount: 1000_000000n,
+   *   maxApprove: true,
+   * });
+   *
+   * if (!hadAllowance) {
+   *   console.log('Approval tx:', hash);
+   * }
+   * ```
+   */
+  async ensureAllowance(params) {
+    const owner = this.walletClient.account?.address;
+    if (!owner) throw new Error("Wallet client is missing account");
+    const spender = params.spender ?? this.escrowAddress;
+    const allowance = await this.publicClient.readContract({ address: params.token, abi: ERC20_ABI, functionName: "allowance", args: [owner, spender] });
+    if (allowance >= params.amount) return { hadAllowance: true };
+    const MAX = (1n << 256n) - 1n;
+    const value = params.maxApprove ? MAX : params.amount;
+    const hash = await this.simulateAndSendWithAttribution({
+      address: params.token,
+      abi: ERC20_ABI,
+      functionName: "approve",
+      args: [spender, value],
+      txOverrides: params.txOverrides
+    });
+    return { hadAllowance: false, hash };
+  }
+  /**
+   * Creates a new USDC deposit in the Escrow contract.
+   *
+   * This is the primary method for liquidity providers to add funds to the protocol.
+   * The deposit can accept intents from multiple payment platforms with different
+   * conversion rates per currency.
+   *
+   * **Important**: Requires `apiKey` or `authorizationToken` to be set.
+   * Call `ensureAllowance()` first to approve USDC spending.
+   *
+   * @param params.token - Token address (USDC)
+   * @param params.amount - Total deposit amount in token units (6 decimals for USDC)
+   * @param params.intentAmountRange - Min/max amount per intent
+   * @param params.processorNames - Payment platforms to accept (e.g., ['wise', 'revolut'])
+   * @param params.depositData - Payee details per processor (e.g., [{ email: '...' }])
+   * @param params.conversionRates - Conversion rates per processor, grouped by currency
+   * @param params.delegate - Optional delegate address that can manage the deposit
+   * @param params.intentGuardian - Optional guardian for intent approval
+   * @param params.retainOnEmpty - Keep deposit active when balance reaches zero
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns The deposit details posted to API and the transaction hash
+   *
+   * @throws Error if apiKey/authorizationToken is missing
+   * @throws Error if processorNames, depositData, and conversionRates lengths don't match
+   * @throws Error if a currency is not supported by the specified processor
+   *
+   * @example
+   * ```typescript
+   * // Create a 1000 USDC deposit accepting Wise payments in USD and EUR
+   * const { hash } = await client.createDeposit({
+   *   token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+   *   amount: 1000_000000n,
+   *   intentAmountRange: { min: 10_000000n, max: 500_000000n },
+   *   processorNames: ['wise'],
+   *   depositData: [{ email: 'you@example.com' }],
+   *   conversionRates: [[
+   *     { currency: 'USD', conversionRate: '1020000000000000000' }, // 1.02
+   *     { currency: 'EUR', conversionRate: '1100000000000000000' }, // 1.10
+   *   ]],
+   * });
+   * ```
+   */
+  async createDeposit(params) {
+    const methods = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
+    if (!Array.isArray(params.processorNames) || params.processorNames.length === 0) {
+      throw new Error("processorNames must be a non-empty array");
+    }
+    if (params.processorNames.length !== params.conversionRates.length) {
+      throw new Error("processorNames and conversionRates length mismatch");
+    }
+    if (params.processorNames.length !== params.depositData.length) {
+      throw new Error("processorNames and depositData length mismatch");
+    }
+    const paymentMethods = params.processorNames.map((name) => resolvePaymentMethodHashFromCatalog(name, methods));
+    const intentGatingService = getGatingServiceAddress(this.chainId, this.runtimeEnv);
+    const baseApiUrl = (this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
+    if (!this.apiKey && !this.authorizationToken) {
+      throw new Error("createDeposit requires apiKey or authorizationToken to post deposit details");
+    }
+    const depositDetails = params.processorNames.map((processorName, index) => ({
+      processorName,
+      depositData: params.depositData[index] || {}
+    }));
+    const apiResponses = await Promise.all(
+      depositDetails.map((req) => apiPostDepositDetails(req, baseApiUrl, this.apiTimeoutMs))
+    );
+    if (!apiResponses.every((r) => r?.success)) {
+      const failed = apiResponses.find((r) => !r?.success);
+      throw new Error(failed?.message || "Failed to create deposit details");
+    }
+    const hashedOnchainIds = apiResponses.map((r) => r.responseObject?.hashedOnchainId);
+    const paymentMethodData = hashedOnchainIds.map((hid) => ({ intentGatingService, payeeDetails: hid, data: "0x" }));
+    params.conversionRates.forEach((group, i) => {
+      const key = params.processorNames[i]?.toLowerCase();
+      const allowed = methods[key]?.currencies?.map((c) => c.toLowerCase());
+      if (allowed && allowed.length) {
+        for (const { currency } of group) {
+          const codeHash = currencyKeccak256(String(currency).toUpperCase()).toLowerCase();
+          if (!allowed.includes(codeHash)) {
+            throw new Error(`Currency ${currency} not supported by ${params.processorNames[i]}. Allowed: ${allowed.join(", ")}`);
+          }
+        }
+      }
+    });
+    const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await Promise.resolve().then(() => (init_currency(), currency_exports));
+    const normalized = params.conversionRates.map((group) => group.map((r) => ({ currency: r.currency, conversionRate: r.conversionRate })));
+    const currencies = mapConversionRatesToOnchainMinRate2(normalized, paymentMethods.length);
+    const args = [{
+      token: params.token,
+      amount: params.amount,
+      intentAmountRange: params.intentAmountRange,
+      paymentMethods,
+      paymentMethodData,
+      currencies,
+      delegate: params.delegate ?? "0x0000000000000000000000000000000000000000",
+      intentGuardian: params.intentGuardian ?? "0x0000000000000000000000000000000000000000",
+      retainOnEmpty: Boolean(params.retainOnEmpty ?? false)
+    }];
+    const hash = await this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "createDeposit",
+      args,
+      txOverrides: params.txOverrides
+    });
+    return { depositDetails, hash };
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: DEPOSIT MANAGEMENT                                                 ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Enables or disables a deposit from accepting new intents.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.accepting - Whether to accept new intents
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async setAcceptingIntents(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "setAcceptingIntents",
+      args: [params.depositId, params.accepting],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Updates the min/max intent amount range for a deposit.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.min - Minimum intent amount
+   * @param params.max - Maximum intent amount
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async setIntentRange(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "setIntentRange",
+      args: [params.depositId, { min: params.min, max: params.max }],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Updates the minimum conversion rate for a specific currency on a payment method.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethod - Payment method hash (bytes32)
+   * @param params.fiatCurrency - Fiat currency hash (bytes32)
+   * @param params.minConversionRate - New minimum conversion rate (18 decimals)
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async setCurrencyMinRate(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "setCurrencyMinRate",
+      args: [params.depositId, params.paymentMethod, params.fiatCurrency, params.minConversionRate],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Adds additional funds to an existing deposit.
+   * Requires prior approval of the token amount.
+   *
+   * @param params.depositId - The deposit ID to add funds to
+   * @param params.amount - Amount to add (in token units)
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async addFunds(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "addFunds",
+      args: [params.depositId, params.amount],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Removes funds from a deposit (partial withdrawal).
+   * Can only withdraw available (non-locked) funds.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.amount - Amount to remove (in token units)
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async removeFunds(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "removeFunds",
+      args: [params.depositId, params.amount],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Fully withdraws a deposit, returning all available funds to the owner.
+   * The deposit must have no active intents.
+   *
+   * @param params.depositId - The deposit ID to withdraw
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async withdrawDeposit(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "withdrawDeposit",
+      args: [params.depositId],
+      txOverrides: params.txOverrides
+    });
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: ADVANCED DEPOSIT CONFIGURATION                                     ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Sets whether a deposit should remain active when its balance reaches zero.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.retain - If true, deposit stays active when empty
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async setRetainOnEmpty(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "setRetainOnEmpty",
+      args: [params.depositId, params.retain],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Assigns a delegate address that can manage the deposit on behalf of the owner.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.delegate - Address to delegate management to
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async setDelegate(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "setDelegate",
+      args: [params.depositId, params.delegate],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Removes the delegate from a deposit.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async removeDelegate(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "removeDelegate",
+      args: [params.depositId],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Adds new payment methods to an existing deposit.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethods - Array of payment method hashes to add
+   * @param params.paymentMethodData - Corresponding payment method configuration
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async addPaymentMethods(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "addPaymentMethods",
+      args: [params.depositId, params.paymentMethods, params.paymentMethodData],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Activates or deactivates a payment method on a deposit.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethod - Payment method hash to modify
+   * @param params.isActive - Whether the payment method should accept intents
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async setPaymentMethodActive(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "setPaymentMethodActive",
+      args: [params.depositId, params.paymentMethod, params.isActive],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Deactivates a payment method on a deposit (convenience alias for setPaymentMethodActive).
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethod - Payment method hash to deactivate
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async removePaymentMethod(params) {
+    return this.setPaymentMethodActive({ depositId: params.depositId, paymentMethod: params.paymentMethod, isActive: false, txOverrides: params.txOverrides });
+  }
+  /**
+   * Adds new currencies to a payment method on a deposit.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethod - Payment method hash to add currencies to
+   * @param params.currencies - Array of currency configurations with code and min rate
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async addCurrencies(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "addCurrencies",
+      args: [params.depositId, params.paymentMethod, params.currencies],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Deactivates a currency for a payment method on a deposit.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethod - Payment method hash
+   * @param params.currencyCode - Currency code hash to deactivate
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async deactivateCurrency(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "deactivateCurrency",
+      args: [params.depositId, params.paymentMethod, params.currencyCode],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * Removes (deactivates) a currency from a payment method.
+   * Alias for deactivateCurrency.
+   *
+   * @param params.depositId - The deposit ID
+   * @param params.paymentMethod - Payment method hash
+   * @param params.currencyCode - Currency code hash to remove
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async removeCurrency(params) {
+    return this.deactivateCurrency(params);
+  }
+  /**
+   * Removes expired intents from a deposit, freeing up locked funds.
+   * Can be called by anyone (permissionless cleanup).
+   *
+   * @param params.depositId - The deposit ID to prune
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async pruneExpiredIntents(params) {
+    return this.simulateAndSendWithAttribution({
+      address: this.escrowAddress,
+      abi: this.escrowAbi,
+      functionName: "pruneExpiredIntents",
+      args: [params.depositId],
+      txOverrides: params.txOverrides
+    });
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // SUPPORTING: INTENT OPERATIONS
+  // (Used by takers/buyers - not primary SDK functionality)
+  // ───────────────────────────────────────────────────────────────────────────
+  /**
+   * **Supporting Method** - Signals intent to use a deposit.
+   *
+   * > **Note**: This method is typically used by takers/buyers who want to
+   * > purchase crypto by paying fiat. Liquidity providers generally don't
+   * > need to call this method directly.
+   *
+   * This reserves funds from a deposit and creates an intent that must be
+   * fulfilled (via `fulfillIntent`) or will expire. The taker commits to
+   * sending fiat payment to the deposit's payee.
+   *
+   * If `gatingServiceSignature` is not provided, the SDK will automatically
+   * fetch one from the API (requires `apiKey` or `authorizationToken`).
+   *
+   * @param params.depositId - The deposit to use
+   * @param params.amount - Amount of tokens to claim (in token units)
+   * @param params.toAddress - Address to receive the tokens when fulfilled
+   * @param params.processorName - Payment platform (e.g., 'wise', 'revolut')
+   * @param params.payeeDetails - Hashed payee details (from deposit)
+   * @param params.fiatCurrencyCode - Fiat currency code (e.g., 'USD', 'EUR')
+   * @param params.conversionRate - Agreed conversion rate (18 decimals)
+   * @param params.referrer - Optional referrer address for fee sharing
+   * @param params.referrerFee - Optional referrer fee amount
+   * @param params.postIntentHook - Optional hook contract to call after signaling
+   * @param params.data - Optional data to pass to the hook
+   * @param params.gatingServiceSignature - Pre-obtained signature (if not auto-fetching)
+   * @param params.signatureExpiration - Signature expiration timestamp
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   *
+   * @example
+   * ```typescript
+   * const hash = await client.signalIntent({
+   *   depositId: 42n,
+   *   amount: 100_000000n, // 100 USDC
+   *   toAddress: '0x...',
+   *   processorName: 'wise',
+   *   payeeDetails: '0x...',
+   *   fiatCurrencyCode: 'USD',
+   *   conversionRate: 1_020000000000000000n, // 1.02
+   * });
+   * ```
+   */
+  async signalIntent(params) {
+    if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
+    const catalog = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
+    const paymentMethod = resolvePaymentMethodHashFromCatalog(params.processorName, catalog);
+    const fiatCurrency = resolveFiatCurrencyBytes32(params.fiatCurrencyCode);
+    const depositId = typeof params.depositId === "bigint" ? params.depositId : BigInt(params.depositId);
+    const amount = typeof params.amount === "bigint" ? params.amount : BigInt(params.amount);
+    const conversionRate = typeof params.conversionRate === "bigint" ? params.conversionRate : BigInt(params.conversionRate);
+    const referrerFee = params.referrerFee === void 0 ? 0n : typeof params.referrerFee === "bigint" ? params.referrerFee : BigInt(params.referrerFee);
+    let { gatingServiceSignature, signatureExpiration } = params;
+    if ((!gatingServiceSignature || !signatureExpiration) && this.baseApiUrl && (this.apiKey || this.authorizationToken)) {
+      const resp = await apiSignIntentV2(
+        {
+          processorName: params.processorName,
+          payeeDetails: params.payeeDetails,
+          depositId: depositId.toString(),
+          amount: amount.toString(),
+          toAddress: params.toAddress,
+          paymentMethod,
+          fiatCurrency,
+          conversionRate: conversionRate.toString(),
+          chainId: this.chainId.toString(),
+          orchestratorAddress: this.orchestratorAddress,
+          escrowAddress: this.escrowAddress
+        },
+        { baseApiUrl: this.baseApiUrl, apiKey: this.apiKey, authorizationToken: this.authorizationToken, timeoutMs: this.apiTimeoutMs }
+      );
+      gatingServiceSignature = resp.signature;
+      signatureExpiration = resp.signatureExpiration;
+    }
+    if (!gatingServiceSignature || !signatureExpiration) throw new Error("Missing gatingServiceSignature/signatureExpiration");
+    const args = [{
+      escrow: this.escrowAddress,
+      depositId,
+      amount,
+      to: params.toAddress,
+      paymentMethod,
+      fiatCurrency,
+      conversionRate,
+      referrer: params.referrer ?? "0x0000000000000000000000000000000000000000",
+      referrerFee,
+      gatingServiceSignature,
+      signatureExpiration: typeof signatureExpiration === "bigint" ? signatureExpiration : BigInt(signatureExpiration),
+      postIntentHook: params.postIntentHook ?? "0x0000000000000000000000000000000000000000",
+      data: params.data ?? "0x"
+    }];
+    return this.simulateAndSendWithAttribution({
+      address: this.orchestratorAddress,
+      abi: this.orchestratorAbi,
+      functionName: "signalIntent",
+      args,
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * **Supporting Method** - Cancels a signaled intent before fulfillment.
+   *
+   * Only the intent owner can cancel. Releases reserved funds back to the deposit.
+   *
+   * @param params.intentHash - The intent hash to cancel (0x-prefixed, 32 bytes)
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async cancelIntent(params) {
+    if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
+    return this.simulateAndSendWithAttribution({
+      address: this.orchestratorAddress,
+      abi: this.orchestratorAbi,
+      functionName: "cancelIntent",
+      args: [params.intentHash],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * **Supporting Method** - Releases funds back to the deposit owner.
+   *
+   * Called by the deposit owner when they want to reject an intent
+   * (e.g., payment verification failed or intent expired).
+   *
+   * @param params.intentHash - The intent hash (0x-prefixed, 32 bytes)
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @returns Transaction hash
+   */
+  async releaseFundsToPayer(params) {
+    if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
+    return this.simulateAndSendWithAttribution({
+      address: this.orchestratorAddress,
+      abi: this.orchestratorAbi,
+      functionName: "releaseFundsToPayer",
+      args: [params.intentHash],
+      txOverrides: params.txOverrides
+    });
+  }
+  /**
+   * **Supporting Method** - Fulfills an intent by submitting a payment proof.
+   *
+   * > **Note**: This method is typically used by takers/buyers after they've
+   * > sent fiat payment. Liquidity providers generally don't call this directly.
+   *
+   * This is the final step in the off-ramp flow. After the taker has sent
+   * fiat payment, they generate a proof (via the browser extension) and
+   * submit it here. The SDK handles attestation service calls automatically.
+   *
+   * **Flow:**
+   * 1. Intent parameters are derived from the indexer/ProtocolViewer
+   * 2. Proof is sent to the attestation service for verification
+   * 3. Attestation response is encoded and submitted on-chain
+   * 4. Funds are released to the intent's `toAddress`
+   *
+   * @param params.intentHash - The intent hash to fulfill (0x-prefixed, 32 bytes)
+   * @param params.proof - Payment proof from Reclaim (object or JSON string)
+   * @param params.timestampBufferMs - Allowed timestamp variance (default: 300000ms)
+   * @param params.attestationServiceUrl - Override attestation service URL
+   * @param params.verifyingContract - Override verifier contract address
+   * @param params.postIntentHookData - Data to pass to post-intent hook
+   * @param params.txOverrides - Optional viem transaction overrides
+   * @param params.callbacks - Lifecycle callbacks for UI updates
+   * @returns Transaction hash
+   */
+  async fulfillIntent(params) {
+    if (!this.orchestratorAddress || !this.orchestratorAbi) throw new Error("Orchestrator not available");
+    const intentHash = params.intentHash;
+    const attUrl = params.attestationServiceUrl ?? this.defaultAttestationService();
+    const verifyingContract = params.verifyingContract ?? this.unifiedPaymentVerifier;
+    const inputs = await this.getFulfillIntentInputs(intentHash);
+    const amount = inputs.amount;
+    const fiatCurrency = inputs.fiatCurrency;
+    const conversionRate = inputs.conversionRate;
+    const payeeDetails = inputs.payeeDetails;
+    const timestampMs = inputs.intentTimestampMs;
+    const paymentMethodHash = inputs.paymentMethodHash || "0x";
+    const timestampBufferMs = params.timestampBufferMs ?? "300000";
+    const catalog = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
+    const { resolvePaymentMethodNameFromHash: resolvePaymentMethodNameFromHash2 } = await Promise.resolve().then(() => (init_paymentResolution(), paymentResolution_exports));
+    const platformName = resolvePaymentMethodNameFromHash2(paymentMethodHash, catalog);
+    if (!platformName) throw new Error("Unknown paymentMethodHash for this network/env; update SDK catalogs.");
+    const { resolvePlatformAttestationConfig: resolvePlatformAttestationConfig2 } = await Promise.resolve().then(() => (init_constants2(), constants_exports));
+    const cfg = resolvePlatformAttestationConfig2(platformName);
+    const platform = cfg.actionPlatform;
+    const actionType = cfg.actionType;
+    const zkTlsProof = typeof params.proof === "string" ? params.proof : JSON.stringify(params.proof);
+    const payload = {
+      proofType: "reclaim",
+      proof: zkTlsProof,
+      chainId: this.chainId,
+      verifyingContract,
+      intent: {
+        intentHash,
+        amount,
+        timestampMs,
+        paymentMethod: paymentMethodHash,
+        fiatCurrency,
+        conversionRate,
+        payeeDetails,
+        timestampBufferMs
+      }
+    };
+    params?.callbacks?.onAttestationStart?.();
+    const att = await apiCreatePaymentAttestation(payload, attUrl, platform, actionType);
+    const paymentProof = encodePaymentAttestation(att);
+    const verificationData = encodeVerifyPaymentData({
+      intentHash,
+      paymentProof,
+      data: encodeAddressAsBytes(att.responseObject.signer)
+    });
+    const args = [{
+      paymentProof,
+      intentHash,
+      verificationData,
+      postIntentHookData: params.postIntentHookData ?? "0x"
+    }];
+    const txHash = await this.simulateAndSendWithAttribution({
+      address: this.orchestratorAddress,
+      abi: this.orchestratorAbi,
+      functionName: "fulfillIntent",
+      args,
+      txOverrides: params.txOverrides
+    });
+    params?.callbacks?.onTxSent?.(txHash);
+    return txHash;
+  }
+  defaultAttestationService() {
+    return this.runtimeEnv === "staging" ? "https://attestation-service-staging.zkp2p.xyz" : "https://attestation-service.zkp2p.xyz";
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // SUPPORTING: QUOTES API
+  // (Used by frontends to find available liquidity)
+  // ───────────────────────────────────────────────────────────────────────────
+  /**
+   * **Supporting Method** - Fetches quotes for available liquidity.
+   *
+   * > **Note**: This method is typically used by frontend applications to
+   * > display available off-ramp options to users. Liquidity providers can
+   * > use it to see how their deposits appear to takers.
+   *
+   * Returns available quotes from liquidity providers matching the request
+   * criteria. When authenticated, the API returns payee details in each quote.
+   *
+   * @param req - Quote request parameters
+   * @param req.paymentPlatforms - Payment platforms to search (e.g., ['wise', 'revolut'])
+   * @param req.fiatCurrency - Target fiat currency code (e.g., 'USD')
+   * @param req.user - User's address
+   * @param req.recipient - Token recipient address
+   * @param req.destinationChainId - Chain ID for token delivery
+   * @param req.destinationToken - Token address to receive
+   * @param req.amount - Amount (in fiat if isExactFiat, else in tokens)
+   * @param req.isExactFiat - If true, amount is in fiat; quotes return token amounts
+   * @param req.escrowAddresses - Optional filter for specific escrow contracts
+   * @param opts - Optional overrides for API URL and timeout
+   * @returns Quote response with available options
+   *
+   * @example
+   * ```typescript
+   * const quote = await client.getQuote({
+   *   paymentPlatforms: ['wise'],
+   *   fiatCurrency: 'EUR',
+   *   user: '0x...',
+   *   recipient: '0x...',
+   *   destinationChainId: 8453,
+   *   destinationToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+   *   amount: '100',
+   *   isExactFiat: true,
+   * });
+   *
+   * for (const q of quote.responseObject.quotes) {
+   *   console.log(`${q.tokenAmountFormatted} USDC for ${q.fiatAmountFormatted}`);
+   * }
+   * ```
+   */
+  async getQuote(req, opts) {
+    const baseApiUrl = (opts?.baseApiUrl ?? this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
+    const timeoutMs = opts?.timeoutMs ?? this.apiTimeoutMs;
+    const reqWithEscrow = { ...req };
+    if ((!reqWithEscrow.escrowAddresses || reqWithEscrow.escrowAddresses.length === 0) && this.escrowAddress) {
+      reqWithEscrow.escrowAddresses = [this.escrowAddress];
+    }
+    const quote = await apiGetQuote(reqWithEscrow, baseApiUrl, timeoutMs, this.apiKey, this.authorizationToken);
+    const quotes = quote?.responseObject?.quotes ?? [];
+    for (const q of quotes) {
+      const maker = q?.maker;
+      if (maker?.depositData && typeof q === "object") {
+        q.payeeData = maker.depositData;
+      }
+    }
+    return quote;
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // SUPPORTING: TAKER TIER
+  // (Used by frontends to display taker limits)
+  // ───────────────────────────────────────────────────────────────────────────
+  /**
+   * **Supporting Method** - Fetches taker tier information for an address.
+   *
+   * > **Note**: Requires `apiKey` or `authorizationToken` to be set.
+   *
+   * @param req - Taker tier request parameters
+   * @param req.owner - Taker address
+   * @param req.chainId - Chain ID
+   * @param opts - Optional overrides for API URL and timeout
+   * @returns Taker tier response
+   */
+  async getTakerTier(req, opts) {
+    const baseApiUrl = (opts?.baseApiUrl ?? this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
+    const timeoutMs = opts?.timeoutMs ?? this.apiTimeoutMs;
+    if (!this.apiKey && !this.authorizationToken) {
+      throw new Error("getTakerTier requires apiKey or authorizationToken");
+    }
+    return apiGetTakerTier(req, this.apiKey, baseApiUrl, this.authorizationToken, timeoutMs);
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: ON-CHAIN DEPOSIT VIEWS                                             ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  requireProtocolViewer() {
+    if (!this.protocolViewerAddress || !this.protocolViewerAbi) {
+      throw new Error("ProtocolViewer not available for this network");
+    }
+    return { address: this.protocolViewerAddress, abi: this.protocolViewerAbi };
+  }
+  /**
+   * Fetches a deposit directly from on-chain ProtocolViewer contract.
+   * Falls back to Escrow.getDeposit if ProtocolViewer is unavailable.
+   *
+   * @param depositId - The deposit ID (string or bigint)
+   * @returns Parsed deposit view with all payment methods and currencies
+   */
+  async getPvDepositById(depositId) {
+    const id = typeof depositId === "bigint" ? depositId : BigInt(depositId);
+    try {
+      const { address, abi } = this.requireProtocolViewer();
+      const raw = await this.publicClient.readContract({ address, abi, functionName: "getDeposit", args: [id] });
+      const { parseDepositView: parseDepositView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+      return parseDepositView2(raw);
+    } catch (e) {
+      const raw = await this.publicClient.readContract({ address: this.escrowAddress, abi: this.escrowAbi, functionName: "getDeposit", args: [id] });
+      const { parseDepositView: parseDepositView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+      return parseDepositView2(raw);
+    }
+  }
+  /**
+   * Fetches multiple deposits by ID from on-chain in a batch call.
+   *
+   * @param ids - Array of deposit IDs
+   * @returns Array of parsed deposit views
+   */
+  async getPvDepositsFromIds(ids) {
+    if (!this.protocolViewerAddress || !this.protocolViewerAbi) {
+      const { parseDepositView: parseDepositView3 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+      const results = [];
+      for (const id of ids) {
+        const raw2 = await this.publicClient.readContract({
+          address: this.escrowAddress,
+          abi: this.escrowAbi,
+          functionName: "getDeposit",
+          args: [typeof id === "bigint" ? id : BigInt(id)]
+        });
+        results.push(parseDepositView3(raw2));
+      }
+      return results;
+    }
+    const bn = ids.map((id) => typeof id === "bigint" ? id : BigInt(id));
+    const raw = await this.publicClient.readContract({
+      address: this.protocolViewerAddress,
+      abi: this.protocolViewerAbi,
+      functionName: "getDepositFromIds",
+      args: [bn]
+    });
+    const { parseDepositView: parseDepositView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+    return raw.map(parseDepositView2);
+  }
+  /**
+   * Fetches all deposits owned by an address from on-chain.
+   *
+   * @param owner - The owner address
+   * @returns Array of parsed deposit views
+   */
+  async getPvAccountDeposits(owner) {
+    try {
+      const { address, abi } = this.requireProtocolViewer();
+      const raw = await this.publicClient.readContract({ address, abi, functionName: "getAccountDeposits", args: [owner] });
+      const { parseDepositView: parseDepositView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+      return raw.map(parseDepositView2);
+    } catch (e) {
+      const raw = await this.publicClient.readContract({ address: this.escrowAddress, abi: this.escrowAbi, functionName: "getAccountDeposits", args: [owner] });
+      const { parseDepositView: parseDepositView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+      return raw.map(parseDepositView2);
+    }
+  }
+  /**
+   * Fetches all intents created by an address from on-chain.
+   * Requires ProtocolViewer to be available.
+   *
+   * @param owner - The owner address
+   * @returns Array of parsed intent views
+   */
+  async getPvAccountIntents(owner) {
+    const { address, abi } = this.requireProtocolViewer();
+    const raw = await this.publicClient.readContract({
+      address,
+      abi,
+      functionName: "getAccountIntents",
+      args: [owner]
+    });
+    const { parseIntentView: parseIntentView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+    return raw.map(parseIntentView2);
+  }
+  /**
+   * Fetches a single intent by hash from on-chain.
+   *
+   * @param intentHash - The intent hash (0x-prefixed, 32 bytes)
+   * @returns Parsed intent view with deposit context
+   */
+  async getPvIntent(intentHash) {
+    const { address, abi } = this.requireProtocolViewer();
+    const raw = await this.publicClient.readContract({
+      address,
+      abi,
+      functionName: "getIntent",
+      args: [intentHash]
+    });
+    const { parseIntentView: parseIntentView2 } = await Promise.resolve().then(() => (init_protocolViewerParsers(), protocolViewerParsers_exports));
+    return parseIntentView2(raw);
+  }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: UTILITIES                                                          ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Returns the USDC token address for the current network (if known).
+   *
+   * @returns USDC address or undefined if not configured
+   */
+  getUsdcAddress() {
+    return this._usdcAddress;
+  }
+  /**
+   * Returns all deployed contract addresses for the current network/environment.
+   *
+   * @returns Object with escrow, orchestrator, protocolViewer, verifier, and USDC addresses
+   */
+  getDeployedAddresses() {
+    return {
+      escrow: this.escrowAddress,
+      orchestrator: this.orchestratorAddress,
+      protocolViewer: this.protocolViewerAddress,
+      unifiedPaymentVerifier: this.unifiedPaymentVerifier,
+      usdc: this._usdcAddress
+    };
+  }
+  /**
+   * Resolves all parameters needed to fulfill an intent.
+   *
+   * Attempts to fetch from ProtocolViewer first (on-chain source of truth),
+   * then falls back to the indexer. This is called internally by `fulfillIntent`
+   * but exposed for advanced use cases.
+   *
+   * @param intentHash - The intent hash to resolve
+   * @returns Intent parameters needed for fulfillment
+   * @throws Error if intent not found or payee details cannot be resolved
+   */
+  async getFulfillIntentInputs(intentHash) {
+    try {
+      if (this.protocolViewerAddress && this.protocolViewerAbi) {
+        const view = await this.getPvIntent(intentHash);
+        const pmHash = view.intent.paymentMethod.toLowerCase();
+        const matched = (view.deposit.paymentMethods || []).find((pm) => pm.paymentMethod?.toLowerCase?.() === pmHash);
+        const payee2 = matched?.verificationData?.payeeDetails;
+        if (payee2) {
+          return {
+            amount: view.intent.amount.toString(),
+            fiatCurrency: view.intent.fiatCurrency,
+            conversionRate: view.intent.conversionRate.toString(),
+            payeeDetails: payee2,
+            intentTimestampMs: (BigInt(view.intent.timestamp) * 1000n).toString(),
+            paymentMethodHash: view.intent.paymentMethod
+          };
+        }
+      }
+    } catch {
+    }
+    const query = (
+      /* GraphQL */
+      `
+      query GetIntentMinimal($hash: String!) {
+        Intent(where: { intentHash: { _eq: $hash } }, limit: 1) {
+          amount
+          fiatCurrency
+          conversionRate
+          paymentMethodHash
+          depositId
+          signalTimestamp
+        }
+      }
+    `
+    );
+    const res = await this._indexerClient.query({
+      query,
+      variables: { hash: intentHash.toLowerCase() }
+    });
+    const rec = res?.Intent?.[0];
+    if (!rec) throw new Error("Intent not found on indexer");
+    if (!rec.signalTimestamp) throw new Error("Intent signal timestamp not found on indexer");
+    const deposit = await this._indexerService.fetchDepositWithRelations(rec.depositId, { includeIntents: false });
+    let payee;
+    const pmHashLower = (rec.paymentMethodHash || "").toLowerCase();
+    for (const pm of deposit?.paymentMethods || []) {
+      if ((pm.paymentMethodHash || "").toLowerCase() === pmHashLower) {
+        payee = pm.payeeDetailsHash;
+        break;
+      }
+    }
+    if (!payee) throw new Error("Payee details not found for intent");
+    return {
+      amount: rec.amount,
+      fiatCurrency: rec.fiatCurrency,
+      conversionRate: rec.conversionRate,
+      payeeDetails: payee,
+      intentTimestampMs: (BigInt(rec.signalTimestamp) * 1000n).toString(),
+      paymentMethodHash: rec.paymentMethodHash || "0x0000000000000000000000000000000000000000000000000000000000000000"
+    };
+  }
+};
+
+// src/index.ts
+init_constants2();
+init_currency();
+init_paymentResolution();
+init_contracts();
+init_bytes32();
+init_protocolViewerParsers();
+
+// src/utils/logger.ts
+var currentLevel = "info";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  switch (currentLevel) {
+    case "debug":
+      return true;
+    case "info":
+      return level !== "debug";
+    case "error":
+      return level === "error";
+    default:
+      return true;
+  }
+}
+var logger = {
+  debug: (...args) => {
+    if (shouldLog("debug")) {
+      console.log("[DEBUG]", ...args);
+    }
+  },
+  info: (...args) => {
+    if (shouldLog("info")) {
+      console.log("[INFO]", ...args);
+    }
+  },
+  warn: (...args) => {
+    if (shouldLog("info")) {
+      console.warn("[WARN]", ...args);
+    }
+  },
+  error: (...args) => {
+    console.error("[ERROR]", ...args);
+  }
+};
+
+// src/index.ts
+init_errors();
+
+exports.BASE_BUILDER_CODE = BASE_BUILDER_CODE;
+exports.IndexerClient = IndexerClient;
+exports.IndexerDepositService = IndexerDepositService;
+exports.OfframpClient = Zkp2pClient;
+exports.ZKP2P_ANDROID_REFERRER = ZKP2P_ANDROID_REFERRER;
+exports.ZKP2P_IOS_REFERRER = ZKP2P_IOS_REFERRER;
+exports.Zkp2pClient = Zkp2pClient;
+exports.apiGetPayeeDetails = apiGetPayeeDetails;
+exports.apiGetTakerTier = apiGetTakerTier;
+exports.apiPostDepositDetails = apiPostDepositDetails;
+exports.apiValidatePayeeDetails = apiValidatePayeeDetails;
+exports.appendAttributionToCalldata = appendAttributionToCalldata;
+exports.asciiToBytes32 = asciiToBytes32;
+exports.convertDepositsForLiquidity = convertDepositsForLiquidity;
+exports.convertIndexerDepositToEscrowView = convertIndexerDepositToEscrowView;
+exports.convertIndexerIntentsToEscrowViews = convertIndexerIntentsToEscrowViews;
+exports.createCompositeDepositId = createCompositeDepositId;
+exports.defaultIndexerEndpoint = defaultIndexerEndpoint;
+exports.enrichPvDepositView = enrichPvDepositView;
+exports.enrichPvIntentView = enrichPvIntentView;
+exports.ensureBytes32 = ensureBytes32;
+exports.fetchIndexerFulfillmentAndPayment = fetchFulfillmentAndPayment;
+exports.getAttributionDataSuffix = getAttributionDataSuffix;
+exports.getContracts = getContracts;
+exports.getCurrencyCodeFromHash = getCurrencyCodeFromHash;
+exports.getCurrencyInfoFromCountryCode = getCurrencyInfoFromCountryCode;
+exports.getCurrencyInfoFromHash = getCurrencyInfoFromHash;
+exports.getGatingServiceAddress = getGatingServiceAddress;
+exports.getPaymentMethodsCatalog = getPaymentMethodsCatalog;
+exports.isSupportedCurrencyHash = isSupportedCurrencyHash;
+exports.logger = logger;
+exports.mapConversionRatesToOnchainMinRate = mapConversionRatesToOnchainMinRate;
+exports.parseDepositView = parseDepositView;
+exports.parseIntentView = parseIntentView;
+exports.resolveFiatCurrencyBytes32 = resolveFiatCurrencyBytes32;
+exports.resolvePaymentMethodHash = resolvePaymentMethodHash;
+exports.resolvePaymentMethodHashFromCatalog = resolvePaymentMethodHashFromCatalog;
+exports.resolvePaymentMethodNameFromHash = resolvePaymentMethodNameFromHash;
+exports.sendTransactionWithAttribution = sendTransactionWithAttribution;
+exports.setLogLevel = setLogLevel;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map