@zkp2p/sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2205 @@
+import { ValidationError, APIError, NetworkError } from './chunk-GHQK65J2.mjs';
+export { APIError, ContractError, ErrorCode, NetworkError, ValidationError, ZKP2PError } from './chunk-GHQK65J2.mjs';
+export { PAYMENT_PLATFORMS, PLATFORM_METADATA, SUPPORTED_CHAIN_IDS, TOKEN_METADATA } from './chunk-JLEW4EOG.mjs';
+import { getContracts, getPaymentMethodsCatalog, getGatingServiceAddress } from './chunk-O7DHVBCL.mjs';
+export { enrichPvDepositView, enrichPvIntentView, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, parseDepositView, parseIntentView } from './chunk-O7DHVBCL.mjs';
+import { resolvePaymentMethodHashFromCatalog, resolveFiatCurrencyBytes32 } from './chunk-M6S5FL2X.mjs';
+export { asciiToBytes32, ensureBytes32, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-M6S5FL2X.mjs';
+import { currencyKeccak256 } from './chunk-PBBMWRNE.mjs';
+export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-PBBMWRNE.mjs';
+import { concatHex, encodeFunctionData, createPublicClient, http } from 'viem';
+import { hardhat, baseSepolia, base } from 'viem/chains';
+import { AbiCoder } from 'ethers';
+import { Attribution } from 'ox/erc8021';
+
+// 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/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/errors/utils.ts
+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 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 } = await import('./timeout-QB7K5SOB.mjs');
+        return await withTimeout(fn(), timeoutMs, `Operation timed out after ${timeoutMs}ms`);
+      }
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      const isNetwork = err instanceof NetworkError;
+      const isRateLimit = err instanceof 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 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 = 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
+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 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 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/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 Attribution.toDataSuffix({ codes });
+}
+function appendAttributionToCalldata(calldata, referrer) {
+  const suffix = getAttributionDataSuffix(referrer);
+  return concatHex([calldata, suffix]);
+}
+async function sendTransactionWithAttribution(walletClient, request, referrer, overrides) {
+  const functionData = 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 = {
+      [base.id]: "https://mainnet.base.org",
+      [baseSepolia.id]: "https://sepolia.base.org",
+      [hardhat.id]: "http://127.0.0.1:8545"
+    };
+    const rpc = opts.rpcUrl ?? inferredRpc ?? defaultRpcUrls[opts.chainId] ?? "https://mainnet.base.org";
+    const chainMap = { [base.id]: base, [baseSepolia.id]: baseSepolia, [hardhat.id]: hardhat };
+    const selectedChain = chainMap[this.chainId];
+    this.publicClient = createPublicClient({ chain: selectedChain, transport: 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 import('./currency-ULYH5HL2.mjs');
+    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 import('./paymentResolution-S6GZR3OY.mjs');
+    const platformName = resolvePaymentMethodNameFromHash2(paymentMethodHash, catalog);
+    if (!platformName) throw new Error("Unknown paymentMethodHash for this network/env; update SDK catalogs.");
+    const { resolvePlatformAttestationConfig } = await import('./constants-DMJE2ALO.mjs');
+    const cfg = resolvePlatformAttestationConfig(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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+      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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+      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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+      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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+    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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+      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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+      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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+    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 import('./protocolViewerParsers-DTJLHUCH.mjs');
+    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/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);
+  }
+};
+
+export { BASE_BUILDER_CODE, IndexerClient, IndexerDepositService, Zkp2pClient as OfframpClient, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiGetPayeeDetails, apiGetTakerTier, apiPostDepositDetails, apiValidatePayeeDetails, appendAttributionToCalldata, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, defaultIndexerEndpoint, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, logger, sendTransactionWithAttribution, setLogLevel };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map