@zkp2p/sdk 0.1.0-rc.8 → 0.1.0

package/dist/index.mjs

@@ -1,20 +1,26 @@
-export { ZERO_RATE_MANAGER_ID, classifyDelegationState, getDelegationRoute, isZeroRateManagerId, normalizeRateManagerId, normalizeRegistry } from './chunk-456CSWDT.mjs';
+export { ZERO_RATE_MANAGER_ID, classifyDelegationState, getDelegationRoute, isZeroRateManagerId, normalizeRateManagerId, normalizeRegistry } from './chunk-YLITJ7SI.mjs';
 import { ValidationError, NetworkError, APIError } from './chunk-GHQK65J2.mjs';
 export { APIError, ContractError, ErrorCode, NetworkError, ValidationError, ZKP2PError } from './chunk-GHQK65J2.mjs';
-export { CHAINLINK_ORACLE_ADAPTER, CHAINLINK_ORACLE_FEEDS, DEFAULT_ORACLE_MAX_STALENESS_SECONDS, PAYMENT_PLATFORMS, PLATFORM_METADATA, PYTH_ORACLE_ADAPTER, PYTH_ORACLE_FEEDS, SPREAD_ORACLE_FEEDS, SUPPORTED_CHAIN_IDS, TOKEN_METADATA, encodePythAdapterConfig, encodeSpreadOracleAdapterConfig, getSpreadOracleConfig } from './chunk-F7USDS7O.mjs';
-import { getContracts, getRateManagerContracts, parseBigIntLike, getPaymentMethodsCatalog, getGatingServiceAddress } from './chunk-6YLLNF6Q.mjs';
-export { HISTORICAL_ESCROW_ADDRESSES, enrichPvDepositView, enrichPvIntentView, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, getRateManagerContracts, parseDepositView, parseIntentView } from './chunk-6YLLNF6Q.mjs';
-import { resolvePaymentMethodHashFromCatalog, resolveFiatCurrencyBytes32 } from './chunk-E5SYWOUK.mjs';
-export { asciiToBytes32, ensureBytes32, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-E5SYWOUK.mjs';
-export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-PQQWQF3C.mjs';
-import { currencyKeccak256 } from './chunk-37HJPVJE.mjs';
-import { concatHex, encodeFunctionData, createPublicClient, http } from 'viem';
+import { getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash } from './chunk-JH74HXTS.mjs';
+export { HISTORICAL_ESCROW_ADDRESSES, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, getRateManagerContracts, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-JH74HXTS.mjs';
+import { Currency, currencyKeccak256 } from './chunk-ZFBH4HD7.mjs';
+export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-ZFBH4HD7.mjs';
+import { concatHex, encodeFunctionData, encodeAbiParameters, createPublicClient, http, formatUnits } from 'viem';
 import { hardhat, base } from 'viem/chains';
 import { AbiCoder } from 'ethers';
 import { Attribution } from 'ox/erc8021';
+import chainlinkFeeds from '@zkp2p/contracts-v2/oracleFeeds/chainlink.json';
 
-// src/client/ContractRouter.ts
-var isSameAddress = (left, right) => !!left && !!right && left.toLowerCase() === right.toLowerCase();
+// src/client/clientUtils.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var MIN_ORACLE_SPREAD_BPS = -32768;
+var MAX_ORACLE_SPREAD_BPS = 32767;
+var EMPTY_ORACLE_RATE_CONFIG = {
+  adapter: ZERO_ADDRESS,
+  adapterConfig: "0x",
+  spreadBps: 0,
+  maxStaleness: 0
+};
 var isValidHexAddress = (addr) => {
   if (typeof addr !== "string") return false;
   return /^0x[0-9a-fA-F]{40}$/.test(addr);
@@ -30,6 +36,106 @@ var parseEscrowAddressFromCompositeDepositId = (depositId) => {
   const maybeEscrow = parts.length >= 3 ? parts[parts.length - 2] : parts[0];
   return normalizeAddress(maybeEscrow);
 };
+var parseRawDepositId = (depositId) => {
+  if (typeof depositId === "bigint") return depositId;
+  if (typeof depositId === "number") return parseBigIntLike(depositId, "Invalid deposit id");
+  const parts = depositId.split("_");
+  const raw = parts[parts.length - 1] ?? depositId;
+  return parseBigIntLike(raw, "Invalid deposit id");
+};
+var normalizeOracleRateConfig = (config) => {
+  const spreadBps = Number(config.spreadBps);
+  if (!Number.isFinite(spreadBps) || spreadBps < MIN_ORACLE_SPREAD_BPS || spreadBps > MAX_ORACLE_SPREAD_BPS) {
+    throw new Error(
+      `Oracle spreadBps must be between ${MIN_ORACLE_SPREAD_BPS} and ${MAX_ORACLE_SPREAD_BPS}`
+    );
+  }
+  const maxStaleness = Number(config.maxStaleness);
+  if (!Number.isFinite(maxStaleness) || maxStaleness < 0 || maxStaleness > 4294967295) {
+    throw new Error("Oracle maxStaleness must be between 0 and 4294967295");
+  }
+  return {
+    adapter: config.adapter,
+    adapterConfig: config.adapterConfig,
+    spreadBps: Math.round(spreadBps),
+    maxStaleness: Math.round(maxStaleness)
+  };
+};
+var escrowCurrencyHasOracleConfig = (abi) => {
+  if (!Array.isArray(abi)) return false;
+  const fnNames = ["createDeposit", "addPaymentMethods", "addCurrencies"];
+  for (const fnName of fnNames) {
+    const fn = abi.find(
+      (item) => item.type === "function" && item.name === fnName
+    );
+    if (!fn) continue;
+    const inputs = fn.inputs ?? [];
+    const hasCurrencyOracle = (items) => {
+      for (const item of items) {
+        const components = item.components ?? [];
+        if (components.some((component) => component.name === "code") && components.some((component) => component.name === "oracleRateConfig")) {
+          return true;
+        }
+        if (components.length > 0 && hasCurrencyOracle(components)) return true;
+      }
+      return false;
+    };
+    if (hasCurrencyOracle(inputs)) return true;
+  }
+  return false;
+};
+var normalizeCurrencyTuples = (currencies, escrowAbi) => {
+  const needsOracle = escrowCurrencyHasOracleConfig(escrowAbi);
+  if (!needsOracle) {
+    return currencies.map((currency) => ({
+      code: currency.code,
+      minConversionRate: currency.minConversionRate
+    }));
+  }
+  return currencies.map((currency) => ({
+    code: currency.code,
+    minConversionRate: currency.minConversionRate,
+    oracleRateConfig: currency.oracleRateConfig ? normalizeOracleRateConfig(currency.oracleRateConfig) : EMPTY_ORACLE_RATE_CONFIG
+  }));
+};
+var getAbiFunction = (abi, ...names) => {
+  if (!Array.isArray(abi)) return null;
+  for (const name of names) {
+    const match = abi.find(
+      (item) => item.type === "function" && item.name === name
+    );
+    if (match) return match;
+  }
+  return null;
+};
+var resolveAbiFunctionName = (abi, names) => {
+  const match = getAbiFunction(abi, ...names);
+  const resolved = match?.name;
+  if (typeof resolved === "string") return resolved;
+  throw new Error(`Contract does not expose any of: ${names.join(", ")}`);
+};
+var abiTupleHasComponent = (abi, functionName, componentName) => {
+  const fn = getAbiFunction(abi, functionName);
+  const inputs = fn?.inputs ?? [];
+  const tupleInput = inputs.find((input) => input.type === "tuple");
+  const components = tupleInput?.components ?? [];
+  return components.some((component) => component.name === componentName);
+};
+var abiFunctionHasInput = (abi, functionName, inputName) => {
+  const fn = getAbiFunction(abi, functionName);
+  const inputs = fn?.inputs ?? [];
+  return inputs.some((input) => input.name === inputName);
+};
+var parseManagerFeeFromRead = (result) => {
+  if (Array.isArray(result)) {
+    const candidate = result.length > 1 ? result[1] : result[0];
+    return parseBigIntLike(candidate, "Unexpected numeric response");
+  }
+  return parseBigIntLike(result, "Unexpected numeric response");
+};
+
+// src/client/ContractRouter.ts
+var isSameAddress = (left, right) => !!left && !!right && left.toLowerCase() === right.toLowerCase();
 var ContractRouter = class {
   constructor(config) {
     this._escrowContextsByAddress = /* @__PURE__ */ new Map();
@@ -271,121 +377,2060 @@ var ContractRouter = class {
   }
 };
 
-// src/indexer/client.ts
-var IndexerHttpError = class extends Error {
-  constructor(status, statusText, options) {
-    super(`Indexer request failed: ${status} ${statusText}`);
-    this.name = "IndexerHttpError";
-    this.status = status;
-    this.retryAfterSeconds = options?.retryAfterSeconds;
+// 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;
   }
-};
-function parseRetryAfterSeconds(rawHeader) {
-  if (!rawHeader) return void 0;
-  const parsedSeconds = Number(rawHeader);
-  if (Number.isFinite(parsedSeconds) && parsedSeconds >= 0) {
-    return Math.ceil(parsedSeconds);
+  if (response.status === 429) {
+    message = "Too many requests. Please try again later.";
   }
-  const parsedDateMs = Date.parse(rawHeader);
-  if (!Number.isFinite(parsedDateMs)) return void 0;
-  const secondsUntilRetry = Math.ceil((parsedDateMs - Date.now()) / 1e3);
-  return Math.max(0, secondsUntilRetry);
-}
-function createAbortError() {
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  return error;
+  return new APIError(message, response.status, { url: response.url });
 }
-function delay(ms, signal) {
-  if (ms <= 0) {
-    return Promise.resolve();
-  }
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(createAbortError());
-      return;
+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));
     }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      reject(createAbortError());
-    };
-    signal?.addEventListener("abort", onAbort);
-  });
-}
-var IndexerClient = class {
-  constructor(endpoint, options = {}) {
-    this.endpoint = endpoint;
-    this.options = options;
-    this.hasLoggedTokenProviderError = false;
   }
-  async resolveAuthorizationToken() {
-    if (this.options.getAuthorizationToken) {
+  throw lastErr;
+}
+
+// src/adapters/verification.ts
+function createHeaders(apiKey, authorizationToken) {
+  const headers2 = { "Content-Type": "application/json" };
+  if (apiKey) headers2["x-api-key"] = apiKey;
+  if (authorizationToken)
+    headers2["Authorization"] = authorizationToken.startsWith("Bearer ") ? authorizationToken : `Bearer ${authorizationToken}`;
+  return headers2;
+}
+async function postSignIntentWithRetry(endpoint, request, opts) {
+  const url = `${opts.baseApiUrl.replace(/\/$/, "")}${endpoint}`;
+  return withRetry(
+    async () => {
+      let res;
       try {
-        const token = await this.options.getAuthorizationToken();
-        return token ?? void 0;
+        res = await fetch(url, {
+          method: "POST",
+          headers: createHeaders(opts.apiKey, opts.authorizationToken),
+          body: JSON.stringify(request)
+        });
       } catch (error) {
-        if (this.options.onAuthorizationTokenError) {
-          this.options.onAuthorizationTokenError(error);
-        } else if (!this.hasLoggedTokenProviderError) {
-          this.hasLoggedTokenProviderError = true;
-          console.warn(
-            "[IndexerClient] getAuthorizationToken failed; continuing without Authorization header",
-            error
-          );
-        }
-        return void 0;
+        throw new NetworkError("Failed to connect to API server", { endpoint, error });
       }
-    }
-    return this.options.authorizationToken;
-  }
-  async _post(request, init) {
-    const token = await this.resolveAuthorizationToken();
-    const headers2 = new Headers(init?.headers);
-    if (!headers2.has("Content-Type")) {
-      headers2.set("Content-Type", "application/json");
-    }
-    if (token && !headers2.has("Authorization")) {
-      headers2.set("Authorization", token.startsWith("Bearer ") ? token : `Bearer ${token}`);
-    }
-    if (this.options.apiKey && !headers2.has("x-api-key")) {
-      headers2.set("x-api-key", this.options.apiKey);
-    }
-    const res = await fetch(this.endpoint, {
-      method: "POST",
-      headers: headers2,
-      body: JSON.stringify(request),
-      cache: "no-store",
-      ...init
-    });
-    if (!res.ok) {
-      throw new IndexerHttpError(res.status, res.statusText, {
-        retryAfterSeconds: parseRetryAfterSeconds(res.headers.get("Retry-After"))
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw parseAPIError(res, text);
+      }
+      return await res.json();
+    },
+    3,
+    1e3,
+    opts.timeoutMs
+  );
+}
+async function apiSignIntentV3(request, opts) {
+  const json = await postSignIntentWithRetry("/v3/intent", request, opts);
+  const sig = json?.responseObject?.signedIntent;
+  const expStr = json?.responseObject?.intentData?.signatureExpiration ?? json?.responseObject?.signatureExpiration;
+  const preIntentHookData = json?.responseObject?.intentData?.preIntentHookData ?? json?.responseObject?.preIntentHookData;
+  if (!sig || !expStr) throw new Error("v3/intent missing signature or expiration");
+  return {
+    signature: sig,
+    signatureExpiration: BigInt(expStr),
+    preIntentHookData
+  };
+}
+async function apiSignIntentV2(request, opts) {
+  const json = await postSignIntentWithRetry(
+    "/v2/verify/intent",
+    request,
+    opts
+  );
+  const sig = json?.responseObject?.signedIntent;
+  const expStr = json?.responseObject?.intentData?.signatureExpiration ?? json?.responseObject?.signatureExpiration;
+  const preIntentHookData = json?.responseObject?.intentData?.preIntentHookData ?? json?.responseObject?.preIntentHookData;
+  if (!sig || !expStr) throw new Error("verify/intent missing signature or expiration");
+  return {
+    signature: sig,
+    signatureExpiration: BigInt(expStr),
+    preIntentHookData
+  };
+}
+
+// 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
       });
     }
-    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 (!res.ok) {
+      const errorText = await res.text();
+      throw parseAPIError(res, errorText);
     }
-    if (!json.data) throw new Error("No data returned from indexer");
-    return json.data;
-  }
-  async query(request, init) {
-    const retries = Math.max(0, init?.retries ?? 1);
-    const rateLimitRetries = Math.max(0, init?.rateLimitRetries ?? 2);
-    const maxAttempts = 1 + Math.max(retries, rateLimitRetries);
-    const {
-      retries: _unusedRetries,
-      rateLimitRetries: _unusedRateLimitRetries,
-      ...requestInit
-    } = init ?? {};
-    let attempts = 0;
-    let rateLimitAttempt = 0;
+    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/referrerFeeConfig.ts
+var evmAddressRegex = /^0x[a-fA-F0-9]{40}$/;
+var isValidReferrerFeeRecipient = (value) => evmAddressRegex.test(value);
+var isValidReferrerFeeBps = (value) => Number.isInteger(value) && value >= 0 && value <= 1e4;
+var assertValidReferrerFeeConfig = (config, context) => {
+  if (!config) {
+    return void 0;
+  }
+  if (!isValidReferrerFeeRecipient(config.recipient)) {
+    throw new Error(`${context} referrerFeeConfig.recipient must be a valid 0x address.`);
+  }
+  if (!isValidReferrerFeeBps(config.feeBps)) {
+    throw new Error(`${context} referrerFeeConfig.feeBps must be an integer between 0 and 10000.`);
+  }
+  return config;
+};
+var parseReferrerFeeConfig = (recipient, feeBpsValue) => {
+  const normalizedRecipient = recipient?.trim();
+  if (!normalizedRecipient || feeBpsValue === null || feeBpsValue === void 0) {
+    return null;
+  }
+  if (!isValidReferrerFeeRecipient(normalizedRecipient)) {
+    return null;
+  }
+  const feeBps = typeof feeBpsValue === "number" ? feeBpsValue : Number(feeBpsValue.trim());
+  if (!isValidReferrerFeeBps(feeBps)) {
+    return null;
+  }
+  return {
+    recipient: normalizedRecipient,
+    feeBps
+  };
+};
+var referrerFeeConfigToPreciseUnits = (config) => BigInt(config.feeBps) * 100000000000000n;
+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]);
+}
+function encodeWithAttribution(request, referrer) {
+  const functionData = encodeFunctionData({
+    abi: request.abi,
+    functionName: request.functionName,
+    args: request.args || []
+  });
+  return appendAttributionToCalldata(functionData, referrer);
+}
+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/types/index.ts
+var PAYMENT_PLATFORMS = [
+  "wise",
+  "venmo",
+  "revolut",
+  "cashapp",
+  "mercadopago",
+  "zelle",
+  "paypal",
+  "monzo",
+  "chime",
+  "luxon",
+  "n26"
+];
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var CHAINLINK_ORACLE_ADAPTER = "0xfc81d1b5841e697973af3072fc8e03af76cb39ef";
+var PYTH_ORACLE_ADAPTER = "0xaa2bBDa3072bD37af76613846268Ec48bd0bB885";
+var DEFAULT_ORACLE_MAX_STALENESS_SECONDS = 86400;
+var PYTH_CONTRACT_BASE = "0xff1a0f4744e8582DF1aE09D5611b887B6a12925C";
+var CHAINLINK_LATEST_ROUND_ABI = [
+  {
+    name: "latestRoundData",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "roundId", type: "uint80" },
+      { name: "answer", type: "int256" },
+      { name: "startedAt", type: "uint256" },
+      { name: "updatedAt", type: "uint256" },
+      { name: "answeredInRound", type: "uint80" }
+    ]
+  }
+];
+function parseUsdPair(pair) {
+  const [base2, quote] = pair.split("/");
+  if (!base2 || !quote) return null;
+  if (quote === "USD" && Object.prototype.hasOwnProperty.call(Currency, base2)) {
+    return { currency: base2, invert: true };
+  }
+  if (base2 === "USD" && Object.prototype.hasOwnProperty.call(Currency, quote)) {
+    return { currency: quote, invert: false };
+  }
+  return null;
+}
+function buildChainlinkOracleFeeds() {
+  const map = {};
+  for (const feed of chainlinkFeeds.feeds) {
+    const parsed = parseUsdPair(feed.pair);
+    if (!parsed) continue;
+    map[parsed.currency] = {
+      feed: feed.feed.toLowerCase(),
+      decimals: feed.decimals,
+      invert: parsed.invert
+    };
+  }
+  return map;
+}
+var CHAINLINK_ORACLE_FEEDS = {
+  ...buildChainlinkOracleFeeds(),
+  [Currency.USD]: {
+    feed: ZERO_ADDRESS2,
+    decimals: 0,
+    invert: false
+  }
+};
+var SPREAD_ORACLE_FEEDS = CHAINLINK_ORACLE_FEEDS;
+var PYTH_ORACLE_FEEDS = {};
+function encodeSpreadOracleAdapterConfig(config) {
+  return encodeAbiParameters(
+    [
+      { name: "feed", type: "address" },
+      { name: "invert", type: "bool" }
+    ],
+    [config.feed, config.invert]
+  );
+}
+function encodePythAdapterConfig(config) {
+  return encodeAbiParameters(
+    [
+      { name: "feedId", type: "bytes32" },
+      { name: "invert", type: "bool" }
+    ],
+    [config.feedId, config.invert]
+  );
+}
+function getSpreadOracleConfig(currency, adapters) {
+  const chainlinkAdapter = adapters?.chainlinkOracleAdapter ?? CHAINLINK_ORACLE_ADAPTER;
+  const chainlinkFeed = CHAINLINK_ORACLE_FEEDS[currency];
+  if (!chainlinkFeed) {
+    return null;
+  }
+  return {
+    ...chainlinkFeed,
+    adapter: chainlinkAdapter,
+    adapterConfig: encodeSpreadOracleAdapterConfig(chainlinkFeed),
+    maxStaleness: DEFAULT_ORACLE_MAX_STALENESS_SECONDS,
+    kind: "oracle_chainlink"
+  };
+}
+async function validateOracleFeedsOnChain(publicClient, _pythContract) {
+  const currencies = [];
+  const contracts = [];
+  for (const [currency, config] of Object.entries(CHAINLINK_ORACLE_FEEDS)) {
+    if (config.feed === ZERO_ADDRESS2) continue;
+    currencies.push(currency);
+    contracts.push({
+      address: config.feed,
+      abi: CHAINLINK_LATEST_ROUND_ABI,
+      functionName: "latestRoundData",
+      args: []
+    });
+  }
+  if (contracts.length === 0) return /* @__PURE__ */ new Set([Currency.USD]);
+  const results = await publicClient.multicall({
+    contracts,
+    allowFailure: true
+  });
+  const available = /* @__PURE__ */ new Set([Currency.USD]);
+  for (let i = 0; i < currencies.length; i++) {
+    if (results[i].status === "success") {
+      available.add(currencies[i]);
+    }
+  }
+  return available;
+}
+
+// src/constants.ts
+var SUPPORTED_CHAIN_IDS = {
+  /** Base mainnet (8453) */
+  BASE_MAINNET: 8453,
+  /** Scroll mainnet (534352) */
+  SCROLL_MAINNET: 534352,
+  /** Local Hardhat network (31337) */
+  HARDHAT: 31337
+};
+var 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
+  },
+  chime: {
+    name: "Chime",
+    displayName: "Chime",
+    logo: "\u{1F3E6}",
+    requiredProofs: 1
+  },
+  luxon: {
+    name: "Luxon",
+    displayName: "Luxon",
+    logo: "\u2728",
+    requiredProofs: 1
+  },
+  n26: {
+    name: "N26",
+    displayName: "N26",
+    logo: "\u{1F3E6}",
+    requiredProofs: 1
+  }
+};
+var TOKEN_METADATA = {
+  USDC: {
+    symbol: "USDC",
+    decimals: 6,
+    name: "USD Coin"
+  }
+};
+var 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" },
+  chime: { actionType: "transfer_chime", actionPlatform: "chime" },
+  luxon: { actionType: "transfer_luxon", actionPlatform: "luxon" },
+  n26: { actionType: "transfer_n26", actionPlatform: "n26" },
+  "zelle-chase": { actionType: "transfer_zelle", actionPlatform: "chase" },
+  "zelle-bofa": { actionType: "transfer_zelle", actionPlatform: "bankofamerica" },
+  "zelle-citi": { actionType: "transfer_zelle", actionPlatform: "citi" }
+};
+function resolvePlatformAttestationConfig(platformName) {
+  const normalized = platformName.toLowerCase();
+  const config = PLATFORM_ATTESTATION_CONFIG[normalized];
+  if (!config) {
+    throw new Error(`Unknown payment platform: ${platformName}`);
+  }
+  return config;
+}
+
+// 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/client/IntentOperations.ts
+var IntentOperations = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async prepareSignalIntent(params) {
+    const referrerFeeConfig = assertValidReferrerFeeConfig(
+      params.referrerFeeConfig,
+      "signalIntent"
+    );
+    if (referrerFeeConfig && (params.referralFees !== void 0 || params.referrer !== void 0 || params.referrerFee !== void 0)) {
+      throw new Error(
+        "signalIntent referrerFeeConfig cannot be combined with referralFees, referrer, or referrerFee."
+      );
+    }
+    const preferV2 = this.config.getDefaultPreferV2();
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrowAddress,
+      depositId: params.depositId,
+      preferV2
+    });
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      escrowAddress: escrowContext.address,
+      preferV2
+    });
+    const catalog = getPaymentMethodsCatalog(this.config.getChainId(), this.config.getRuntimeEnv());
+    const paymentMethod = resolvePaymentMethodHashFromCatalog(params.processorName, catalog);
+    const fiatCurrency = resolveFiatCurrencyBytes32(params.fiatCurrencyCode);
+    const depositId = parseRawDepositId(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 referralFees = referrerFeeConfig !== void 0 ? [
+      {
+        recipient: referrerFeeConfig.recipient,
+        fee: referrerFeeConfigToPreciseUnits(referrerFeeConfig)
+      }
+    ] : normalizeSignalIntentReferralFees(params);
+    let { gatingServiceSignature, signatureExpiration } = params;
+    let preIntentHookData = params.preIntentHookData;
+    const baseApiUrl = this.config.getBaseApiUrl();
+    const apiKey = this.config.getApiKey();
+    const authorizationToken = this.config.getAuthorizationToken();
+    if ((!gatingServiceSignature || !signatureExpiration) && baseApiUrl && (apiKey || authorizationToken)) {
+      const baseRequest = {
+        processorName: params.processorName,
+        payeeDetails: params.payeeDetails,
+        depositId: depositId.toString(),
+        amount: amount.toString(),
+        toAddress: params.toAddress,
+        paymentMethod,
+        fiatCurrency,
+        conversionRate: conversionRate.toString(),
+        chainId: this.config.getChainId().toString(),
+        orchestratorAddress: orchestratorContext.address,
+        escrowAddress: escrowContext.address
+      };
+      const apiOpts = {
+        baseApiUrl,
+        apiKey,
+        authorizationToken,
+        timeoutMs: this.config.getApiTimeoutMs()
+      };
+      const response = orchestratorContext.version === "v2" ? await apiSignIntentV3(
+        {
+          ...baseRequest,
+          callerAddress: this.config.getWalletClient().account.address,
+          referralFees: referralFees.map((referralFee) => ({
+            recipient: referralFee.recipient,
+            fee: referralFee.fee.toString()
+          }))
+        },
+        apiOpts
+      ) : await apiSignIntentV2(baseRequest, apiOpts);
+      gatingServiceSignature = response.signature;
+      signatureExpiration = response.signatureExpiration;
+      preIntentHookData = response.preIntentHookData ?? preIntentHookData;
+    }
+    if (!gatingServiceSignature || !signatureExpiration) {
+      throw new Error("Missing gatingServiceSignature/signatureExpiration");
+    }
+    const commonFields = {
+      escrow: escrowContext.address,
+      depositId,
+      amount,
+      to: params.toAddress,
+      paymentMethod,
+      fiatCurrency,
+      conversionRate,
+      gatingServiceSignature,
+      signatureExpiration: typeof signatureExpiration === "bigint" ? signatureExpiration : BigInt(signatureExpiration),
+      postIntentHook: params.postIntentHook ?? ZERO_ADDRESS,
+      data: params.data ?? "0x"
+    };
+    const args = orchestratorContext.version === "v2" ? [
+      {
+        ...commonFields,
+        referralFees,
+        preIntentHookData: preIntentHookData ?? "0x"
+      }
+    ] : [
+      {
+        ...commonFields,
+        referrer: referralFees[0]?.recipient ?? ZERO_ADDRESS,
+        referrerFee: referralFees[0]?.fee ?? 0n
+      }
+    ];
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: orchestratorContext.abi,
+        functionName: "signalIntent",
+        args
+      },
+      referrer
+    );
+    return {
+      to: orchestratorContext.address,
+      data,
+      value: 0n,
+      chainId: this.config.getChainId(),
+      abi: orchestratorContext.abi,
+      functionName: "signalIntent",
+      args
+    };
+  }
+  async prepareCancelIntent(params) {
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      intentHash: params.intentHash,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    const args = [params.intentHash];
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: orchestratorContext.abi,
+        functionName: "cancelIntent",
+        args
+      },
+      referrer
+    );
+    return {
+      to: orchestratorContext.address,
+      data,
+      value: 0n,
+      chainId: this.config.getChainId(),
+      abi: orchestratorContext.abi,
+      functionName: "cancelIntent",
+      args
+    };
+  }
+  async prepareReleaseFundsToPayer(params) {
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      intentHash: params.intentHash,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    const args = [params.intentHash];
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: orchestratorContext.abi,
+        functionName: "releaseFundsToPayer",
+        args
+      },
+      referrer
+    );
+    return {
+      to: orchestratorContext.address,
+      data,
+      value: 0n,
+      chainId: this.config.getChainId(),
+      abi: orchestratorContext.abi,
+      functionName: "releaseFundsToPayer",
+      args
+    };
+  }
+  async prepareSetDepositPreIntentHook(params) {
+    const escrowAddress = this.config.host.resolveEscrowAddressOrThrow(
+      params.escrowAddress,
+      params.depositId,
+      "setDepositPreIntentHook",
+      { preferV2: this.config.getDefaultPreferV2() }
+    );
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      escrowAddress,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    return this.config.host.prepareResolvedOrchestratorTransaction({
+      orchestrator: orchestratorContext,
+      functionNames: ["setDepositPreIntentHook"],
+      args: [escrowAddress, parseRawDepositId(params.depositId), params.preIntentHook],
+      txOverrides: params.txOverrides
+    });
+  }
+  async prepareSetDepositWhitelistHook(params) {
+    const escrowAddress = this.config.host.resolveEscrowAddressOrThrow(
+      params.escrowAddress,
+      params.depositId,
+      "setDepositWhitelistHook",
+      { preferV2: this.config.getDefaultPreferV2() }
+    );
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      escrowAddress,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    return this.config.host.prepareResolvedOrchestratorTransaction({
+      orchestrator: orchestratorContext,
+      functionNames: ["setDepositWhitelistHook"],
+      args: [escrowAddress, parseRawDepositId(params.depositId), params.whitelistHook],
+      txOverrides: params.txOverrides
+    });
+  }
+  async prepareCleanupOrphanedIntents(params) {
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      escrowAddress: params.escrowAddress,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    return this.config.host.prepareResolvedOrchestratorTransaction({
+      orchestrator: orchestratorContext,
+      functionNames: ["cleanupOrphanedIntents"],
+      args: [params.intentHashes],
+      txOverrides: params.txOverrides
+    });
+  }
+  async getDepositPreIntentHook(depositId, options) {
+    const escrowAddress = this.config.host.resolveEscrowAddressOrThrow(
+      options?.escrowAddress,
+      depositId,
+      "getDepositPreIntentHook",
+      { preferV2: this.config.getDefaultPreferV2() }
+    );
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: options?.orchestratorAddress,
+      escrowAddress,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    const functionName = resolveAbiFunctionName(orchestratorContext.abi, [
+      "getDepositPreIntentHook"
+    ]);
+    return await this.config.getPublicClient().readContract({
+      address: orchestratorContext.address,
+      abi: orchestratorContext.abi,
+      functionName,
+      args: [escrowAddress, parseRawDepositId(depositId)]
+    });
+  }
+  async getDepositWhitelistHook(depositId, options) {
+    const escrowAddress = this.config.host.resolveEscrowAddressOrThrow(
+      options?.escrowAddress,
+      depositId,
+      "getDepositWhitelistHook",
+      { preferV2: this.config.getDefaultPreferV2() }
+    );
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: options?.orchestratorAddress,
+      escrowAddress,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    const functionName = resolveAbiFunctionName(orchestratorContext.abi, [
+      "getDepositWhitelistHook"
+    ]);
+    return await this.config.getPublicClient().readContract({
+      address: orchestratorContext.address,
+      abi: orchestratorContext.abi,
+      functionName,
+      args: [escrowAddress, parseRawDepositId(depositId)]
+    });
+  }
+  async prepareFulfillIntent(params) {
+    const intentHash = params.intentHash;
+    const orchestratorContext = await this.config.host.resolveOrchestratorContext({
+      orchestratorAddress: params.orchestratorAddress,
+      intentHash,
+      preferV2: this.config.getDefaultPreferV2()
+    });
+    const precomputed = params.precomputedAttestation;
+    let paymentProof;
+    let verificationData;
+    if (precomputed) {
+      if (!precomputed.paymentProof || !precomputed.verificationData) {
+        throw new Error("Precomputed attestation requires both proof and verification data");
+      }
+      paymentProof = precomputed.paymentProof;
+      verificationData = precomputed.verificationData;
+    } else {
+      const attestationServiceUrl = params.attestationServiceUrl ?? this.defaultAttestationService();
+      const inputs = await this.config.host.getFulfillIntentInputs(intentHash);
+      const paymentMethodHash = inputs.paymentMethodHash || "0x";
+      const catalog = getPaymentMethodsCatalog(
+        this.config.getChainId(),
+        this.config.getRuntimeEnv()
+      );
+      const platformName = resolvePaymentMethodNameFromHash(paymentMethodHash, catalog);
+      if (!platformName) {
+        throw new Error("Unknown paymentMethodHash for this network/env; update SDK catalogs.");
+      }
+      const platformConfig = resolvePlatformAttestationConfig(platformName);
+      const zkTlsProof = typeof params.proof === "string" ? params.proof : serializeProofInput(params.proof);
+      const payload = {
+        proofType: "reclaim",
+        proof: zkTlsProof,
+        chainId: this.config.getChainId(),
+        intent: {
+          intentHash,
+          amount: inputs.amount,
+          timestampMs: inputs.intentTimestampMs,
+          paymentMethod: paymentMethodHash,
+          fiatCurrency: inputs.fiatCurrency,
+          conversionRate: inputs.conversionRate,
+          payeeDetails: inputs.payeeDetails,
+          timestampBufferMs: params.timestampBufferMs ?? "300000"
+        }
+      };
+      const attestation = await apiCreatePaymentAttestation(
+        payload,
+        attestationServiceUrl,
+        platformConfig.actionPlatform,
+        platformConfig.actionType
+      );
+      paymentProof = encodePaymentAttestation(attestation);
+      verificationData = encodeVerifyPaymentData({
+        intentHash,
+        paymentProof,
+        data: encodeAddressAsBytes(attestation.responseObject.signer)
+      });
+    }
+    const args = [
+      {
+        paymentProof,
+        intentHash,
+        verificationData,
+        postIntentHookData: params.postIntentHookData ?? "0x"
+      }
+    ];
+    const { referrer } = params.txOverrides ?? {};
+    const data = encodeWithAttribution(
+      {
+        abi: orchestratorContext.abi,
+        functionName: "fulfillIntent",
+        args
+      },
+      referrer
+    );
+    return {
+      to: orchestratorContext.address,
+      data,
+      value: 0n,
+      chainId: this.config.getChainId(),
+      abi: orchestratorContext.abi,
+      functionName: "fulfillIntent",
+      args
+    };
+  }
+  defaultAttestationService() {
+    return this.config.getRuntimeEnv() === "staging" ? "https://attestation-service-staging.zkp2p.xyz" : "https://attestation-service.zkp2p.xyz";
+  }
+  async getFulfillIntentInputs(intentHash) {
+    try {
+      if (this.config.getProtocolViewerAddress() && this.config.getProtocolViewerAbi()) {
+        const view = await this.config.host.getPvIntent(intentHash);
+        const paymentMethodHash = view.intent.paymentMethod.toLowerCase();
+        const matched = (view.deposit.paymentMethods || []).find(
+          (pm) => pm.paymentMethod?.toLowerCase?.() === paymentMethodHash
+        );
+        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 (error) {
+      logger.debug("ProtocolViewer lookup failed, falling back to indexer", {
+        intentHash,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const response = await this.config.getIndexerClient().query({
+      query: (
+        /* GraphQL */
+        `
+        query GetIntentMinimal($hash: String!) {
+          Intent(where: { intentHash: { _eq: $hash } }, limit: 1) {
+            amount
+            fiatCurrency
+            conversionRate
+            paymentMethodHash
+            depositId
+            signalTimestamp
+            verifier
+          }
+        }
+      `
+      ),
+      variables: { hash: intentHash.toLowerCase() }
+    });
+    const record = response?.Intent?.[0];
+    if (!record) throw new Error("Intent not found on indexer");
+    if (!record.signalTimestamp) throw new Error("Intent signal timestamp not found on indexer");
+    const deposit = await this.config.getIndexerService().fetchDepositWithRelations(record.depositId, {
+      includeIntents: false
+    });
+    let payee;
+    const paymentMethodHashLower = (record.paymentMethodHash || "").toLowerCase();
+    for (const paymentMethod of deposit?.paymentMethods || []) {
+      if ((paymentMethod.paymentMethodHash || "").toLowerCase() === paymentMethodHashLower) {
+        payee = paymentMethod.payeeDetailsHash;
+        break;
+      }
+    }
+    if (!payee) throw new Error("Payee details not found for intent");
+    return {
+      amount: record.amount,
+      fiatCurrency: record.fiatCurrency,
+      conversionRate: record.conversionRate,
+      payeeDetails: payee,
+      intentTimestampMs: (BigInt(record.signalTimestamp) * 1000n).toString(),
+      paymentMethodHash: record.paymentMethodHash || "0x0000000000000000000000000000000000000000000000000000000000000000",
+      paymentVerifier: record.verifier || void 0
+    };
+  }
+};
+function serializeProofInput(proof) {
+  return JSON.stringify(
+    proof,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  );
+}
+function normalizeSignalIntentReferralFees(params) {
+  if (params.referralFees) {
+    return params.referralFees.map((referralFee) => ({
+      recipient: referralFee.recipient,
+      fee: typeof referralFee.fee === "bigint" ? referralFee.fee : BigInt(referralFee.fee)
+    }));
+  }
+  if (params.referrer && params.referrer.toLowerCase() !== ZERO_ADDRESS.toLowerCase()) {
+    const fee = params.referrerFee === void 0 ? 0n : typeof params.referrerFee === "bigint" ? params.referrerFee : BigInt(params.referrerFee);
+    return [{ recipient: params.referrer, fee }];
+  }
+  return [];
+}
+
+// src/client/ProtocolViewerReader.ts
+async function tryContexts(contexts, attempt, notFoundMessage) {
+  let attemptedRead = false;
+  let hadSuccessfulRead = false;
+  let lastError;
+  for (const context of contexts) {
+    attemptedRead = true;
+    try {
+      const result = await attempt(context);
+      hadSuccessfulRead = true;
+      if (result !== void 0) {
+        return result;
+      }
+    } catch (readError) {
+      lastError = readError;
+    }
+  }
+  if (!hadSuccessfulRead && attemptedRead && lastError) {
+    throw lastError;
+  }
+  throw new Error(notFoundMessage);
+}
+async function collectFromContexts(contexts, attempt) {
+  let attemptedRead = false;
+  let hadSuccessfulRead = false;
+  let lastError;
+  const results = [];
+  for (const context of contexts) {
+    attemptedRead = true;
+    try {
+      const items = await attempt(context);
+      hadSuccessfulRead = true;
+      results.push(...items);
+    } catch (readError) {
+      lastError = readError;
+    }
+  }
+  return { results, attemptedRead, hadSuccessfulRead, lastError };
+}
+var ProtocolViewerReader = class {
+  constructor(config) {
+    this.config = config;
+  }
+  requireProtocolViewer() {
+    const address = this.config.getProtocolViewerAddress();
+    const abi = this.config.getProtocolViewerAbi();
+    if (!address || !abi) {
+      throw new Error("ProtocolViewer not available for this network");
+    }
+    return { address, abi };
+  }
+  protocolViewerFunctionInputCount(functionName) {
+    const fn = getAbiFunction(this.config.getProtocolViewerAbi(), functionName);
+    if (!fn) return null;
+    const inputs = fn.inputs ?? [];
+    return inputs.length;
+  }
+  pvEntryFunctionInputCount(entry, functionName) {
+    const fn = getAbiFunction(entry.abi, functionName);
+    if (!fn) return null;
+    const inputs = fn.inputs ?? [];
+    return inputs.length;
+  }
+  isZeroAddressValue(value) {
+    return !value || value.toLowerCase() === ZERO_ADDRESS.toLowerCase();
+  }
+  toBigIntOrZero(value, fieldName = "numeric field") {
+    if (value === null || value === void 0) return 0n;
+    try {
+      return parseBigIntLike(value);
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(`Invalid ${fieldName}: ${detail}`);
+    }
+  }
+  buildProtocolViewerContexts(options) {
+    return this.config.getRouterBuildProtocolViewerContexts()(options);
+  }
+  isProtocolViewerDepositPopulated(view) {
+    return !this.isZeroAddressValue(view.deposit?.depositor);
+  }
+  isProtocolViewerIntentPopulated(view) {
+    return !this.isZeroAddressValue(view.intent?.owner);
+  }
+  buildDepositViewFromEscrowDeposit(rawDeposit, depositId) {
+    const deposit = rawDeposit ?? {};
+    const remaining = this.toBigIntOrZero(
+      deposit.remainingDeposits ?? deposit.remainingDepositAmount,
+      "deposit remaining amount"
+    );
+    const outstanding = this.toBigIntOrZero(
+      deposit.outstandingIntentAmount,
+      "deposit outstanding intent amount"
+    );
+    const amount = this.toBigIntOrZero(deposit.amount, "deposit amount") || remaining + outstanding;
+    return {
+      depositId,
+      deposit: {
+        depositor: normalizeAddress(deposit.depositor) ?? ZERO_ADDRESS,
+        delegate: normalizeAddress(deposit.delegate) ?? ZERO_ADDRESS,
+        token: normalizeAddress(deposit.token) ?? ZERO_ADDRESS,
+        amount,
+        intentAmountRange: {
+          min: this.toBigIntOrZero(
+            deposit.intentAmountRange?.min,
+            "minimum intent amount"
+          ),
+          max: this.toBigIntOrZero(
+            deposit.intentAmountRange?.max,
+            "maximum intent amount"
+          )
+        },
+        acceptingIntents: Boolean(deposit.acceptingIntents),
+        remainingDeposits: remaining,
+        outstandingIntentAmount: outstanding,
+        makerProtocolFee: this.toBigIntOrZero(deposit.makerProtocolFee, "maker protocol fee"),
+        reservedMakerFees: this.toBigIntOrZero(
+          deposit.reservedMakerFees,
+          "reserved maker fee amount"
+        ),
+        accruedMakerFees: this.toBigIntOrZero(deposit.accruedMakerFees, "accrued maker fee amount"),
+        accruedReferrerFees: this.toBigIntOrZero(
+          deposit.accruedReferrerFees,
+          "accrued referrer fee amount"
+        ),
+        intentGuardian: normalizeAddress(deposit.intentGuardian) ?? ZERO_ADDRESS,
+        retainOnEmpty: Boolean(deposit.retainOnEmpty),
+        referrer: normalizeAddress(deposit.referrer) ?? ZERO_ADDRESS,
+        referrerFee: this.toBigIntOrZero(deposit.referrerFee, "referrer fee")
+      },
+      availableLiquidity: remaining,
+      paymentMethods: [],
+      intentHashes: []
+    };
+  }
+  convertIndexerDepositToPvView(deposit) {
+    const paymentMethods = (deposit.paymentMethods ?? []).filter(
+      (paymentMethod) => paymentMethod.active !== false
+    );
+    const currenciesByPaymentMethod = /* @__PURE__ */ new Map();
+    for (const currency of deposit.currencies ?? []) {
+      const key = currency.paymentMethodHash.toLowerCase();
+      const existing = currenciesByPaymentMethod.get(key) ?? [];
+      existing.push(currency);
+      currenciesByPaymentMethod.set(key, existing);
+    }
+    const remaining = this.toBigIntOrZero(deposit.remainingDeposits, "remaining deposits");
+    const outstanding = this.toBigIntOrZero(
+      deposit.outstandingIntentAmount,
+      "outstanding intent amount"
+    );
+    const totalAmountTaken = this.toBigIntOrZero(deposit.totalAmountTaken, "total amount taken");
+    const totalWithdrawn = this.toBigIntOrZero(deposit.totalWithdrawn, "total withdrawn amount");
+    const depositAmount = remaining + outstanding + totalAmountTaken + totalWithdrawn;
+    return {
+      depositId: this.toBigIntOrZero(deposit.depositId, "deposit id"),
+      deposit: {
+        depositor: normalizeAddress(deposit.depositor) ?? ZERO_ADDRESS,
+        delegate: normalizeAddress(deposit.delegate ?? void 0) ?? ZERO_ADDRESS,
+        token: normalizeAddress(deposit.token) ?? ZERO_ADDRESS,
+        amount: depositAmount,
+        intentAmountRange: {
+          min: this.toBigIntOrZero(deposit.intentAmountMin, "minimum intent amount"),
+          max: this.toBigIntOrZero(deposit.intentAmountMax, "maximum intent amount")
+        },
+        acceptingIntents: Boolean(deposit.acceptingIntents),
+        remainingDeposits: remaining,
+        outstandingIntentAmount: outstanding,
+        makerProtocolFee: 0n,
+        reservedMakerFees: 0n,
+        accruedMakerFees: 0n,
+        accruedReferrerFees: 0n,
+        intentGuardian: ZERO_ADDRESS,
+        retainOnEmpty: Boolean(deposit.retainOnEmpty ?? false),
+        referrer: ZERO_ADDRESS,
+        referrerFee: 0n
+      },
+      availableLiquidity: remaining,
+      paymentMethods: paymentMethods.map((method) => ({
+        paymentMethod: method.paymentMethodHash,
+        verificationData: {
+          intentGatingService: normalizeAddress(method.intentGatingService) ?? ZERO_ADDRESS,
+          payeeDetails: method.payeeDetailsHash || "0x",
+          data: "0x"
+        },
+        currencies: (currenciesByPaymentMethod.get(method.paymentMethodHash.toLowerCase()) ?? []).map((currency) => ({
+          code: currency.currencyCode,
+          minConversionRate: this.toBigIntOrZero(
+            currency.conversionRate ?? currency.minConversionRate,
+            "conversion rate"
+          )
+        }))
+      })),
+      intentHashes: Array.from(new Set((deposit.intents ?? []).map((intent) => intent.intentHash)))
+    };
+  }
+  async getPvAccountDepositsFromIndexer(owner) {
+    const filter = { depositor: owner, status: "ACTIVE" };
+    const escrowAddresses = this.config.getEscrowAddresses();
+    if (escrowAddresses.length > 0) {
+      filter.escrowAddresses = escrowAddresses.map((escrow) => escrow);
+    }
+    const deposits = await this.config.getIndexerService().fetchDepositsWithRelations(
+      filter,
+      { limit: 1e3, orderBy: "timestamp", orderDirection: "desc" },
+      { includeIntents: true }
+    );
+    return deposits.map((deposit) => this.convertIndexerDepositToPvView(deposit));
+  }
+  async getPvDepositById(depositId, options) {
+    const id = typeof depositId === "bigint" ? depositId : parseRawDepositId(depositId);
+    const hintedEscrow = typeof depositId === "string" ? parseEscrowAddressFromCompositeDepositId(depositId) : void 0;
+    const strictEscrow = Boolean(options?.strictEscrow && hintedEscrow);
+    const protocolViewerContexts = strictEscrow && hintedEscrow ? this.config.host.buildProtocolViewerContexts({ escrowAddress: hintedEscrow }).filter((context) => context.escrow.toLowerCase() === hintedEscrow.toLowerCase()) : this.config.host.buildProtocolViewerContexts({ escrowAddress: hintedEscrow });
+    const protocolViewerAddress = this.config.getProtocolViewerAddress();
+    const protocolViewerAbi = this.config.getProtocolViewerAbi();
+    if (protocolViewerAddress && protocolViewerAbi) {
+      const { address, abi } = this.config.host.requireProtocolViewer();
+      const inputCount = this.config.host.protocolViewerFunctionInputCount("getDeposit");
+      if (inputCount === null) {
+        throw new Error("Configured ProtocolViewer ABI does not expose getDeposit");
+      }
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-QVG4JP23.mjs');
+      if (inputCount >= 3) {
+        return tryContexts(
+          protocolViewerContexts,
+          async (context) => {
+            const raw = await this.config.getPublicClient().readContract({
+              address,
+              abi,
+              functionName: "getDeposit",
+              args: [context.escrow, context.orchestrator, id]
+            });
+            const parsed = parseDepositView2(raw);
+            return this.config.host.isProtocolViewerDepositPopulated(parsed) ? parsed : void 0;
+          },
+          "Deposit not found in configured ProtocolViewer contexts"
+        );
+      }
+      if (inputCount >= 2) {
+        return tryContexts(
+          protocolViewerContexts,
+          async (context) => {
+            const raw = await this.config.getPublicClient().readContract({
+              address,
+              abi,
+              functionName: "getDeposit",
+              args: [context.escrow, id]
+            });
+            const parsed = parseDepositView2(raw);
+            return this.config.host.isProtocolViewerDepositPopulated(parsed) ? parsed : void 0;
+          },
+          "Deposit not found in configured ProtocolViewer escrows"
+        );
+      }
+      if (!strictEscrow) {
+        const raw = await this.config.getPublicClient().readContract({
+          address,
+          abi,
+          functionName: "getDeposit",
+          args: [id]
+        });
+        const parsed = parseDepositView2(raw);
+        if (this.config.host.isProtocolViewerDepositPopulated(parsed)) {
+          return parsed;
+        }
+        throw new Error("Deposit not found");
+      }
+    }
+    const contexts = strictEscrow && hintedEscrow ? this.config.host.getEscrowContexts().filter((context) => context.address.toLowerCase() === hintedEscrow.toLowerCase()) : this.config.host.getEscrowContexts();
+    if (!strictEscrow && hintedEscrow) {
+      contexts.sort((left, right) => {
+        const leftMatch = left.address.toLowerCase() === hintedEscrow.toLowerCase() ? 1 : 0;
+        const rightMatch = right.address.toLowerCase() === hintedEscrow.toLowerCase() ? 1 : 0;
+        return rightMatch - leftMatch;
+      });
+    }
+    return tryContexts(
+      contexts,
+      async (context) => {
+        const raw = await this.config.getPublicClient().readContract({
+          address: context.address,
+          abi: context.abi,
+          functionName: "getDeposit",
+          args: [id]
+        });
+        const parsed = this.config.host.buildDepositViewFromEscrowDeposit(raw, id);
+        return this.config.host.isProtocolViewerDepositPopulated(parsed) ? parsed : void 0;
+      },
+      "Failed to fetch deposit from configured escrows"
+    );
+  }
+  async getPvDepositsFromIds(ids) {
+    if (!ids.length) return [];
+    const inputCount = this.config.host.protocolViewerFunctionInputCount("getDepositFromIds");
+    const protocolViewerAddress = this.config.getProtocolViewerAddress();
+    const protocolViewerAbi = this.config.getProtocolViewerAbi();
+    if (!protocolViewerAddress || !protocolViewerAbi || inputCount === null || inputCount >= 3) {
+      return Promise.all(ids.map((id) => this.config.host.getPvDepositById(id)));
+    }
+    const bn = ids.map((id) => typeof id === "bigint" ? id : parseRawDepositId(id));
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-QVG4JP23.mjs');
+    if (inputCount >= 2) {
+      const requests = ids.map((id, index) => ({
+        index,
+        id,
+        rawId: bn[index],
+        hintedEscrow: typeof id === "string" ? parseEscrowAddressFromCompositeDepositId(id) : void 0
+      }));
+      const resolved = new Array(requests.length);
+      let attemptedBatchRead = false;
+      let hadSuccessfulBatchRead = false;
+      let lastBatchError;
+      const resolveBatch = async (escrow, entries) => {
+        if (!entries.length) return;
+        attemptedBatchRead = true;
+        try {
+          const raw2 = await this.config.getPublicClient().readContract({
+            address: protocolViewerAddress,
+            abi: protocolViewerAbi,
+            functionName: "getDepositFromIds",
+            args: [escrow, entries.map((entry) => entry.rawId)]
+          });
+          hadSuccessfulBatchRead = true;
+          const items = Array.isArray(raw2) ? raw2 : [];
+          if (items.length === entries.length) {
+            for (let index = 0; index < entries.length; index += 1) {
+              const entry = entries[index];
+              if (!entry || resolved[entry.index]) continue;
+              const parsed = parseDepositView2(items[index]);
+              if (this.config.host.isProtocolViewerDepositPopulated(parsed)) {
+                resolved[entry.index] = parsed;
+              }
+            }
+            return;
+          }
+          for (const item of items) {
+            const parsed = parseDepositView2(item);
+            if (!this.config.host.isProtocolViewerDepositPopulated(parsed)) continue;
+            const match = entries.find(
+              (entry) => !resolved[entry.index] && entry.rawId === parsed.depositId
+            );
+            if (match) {
+              resolved[match.index] = parsed;
+            }
+          }
+        } catch (batchError) {
+          lastBatchError = batchError;
+        }
+      };
+      const hintedGroups = /* @__PURE__ */ new Map();
+      for (const request of requests) {
+        if (!request.hintedEscrow) continue;
+        const key = request.hintedEscrow.toLowerCase();
+        const group = hintedGroups.get(key);
+        if (group) {
+          group.entries.push(request);
+        } else {
+          hintedGroups.set(key, { escrow: request.hintedEscrow, entries: [request] });
+        }
+      }
+      for (const { escrow, entries } of hintedGroups.values()) {
+        await resolveBatch(escrow, entries);
+      }
+      const escrows = [];
+      const seenEscrows = /* @__PURE__ */ new Set();
+      for (const context of this.config.host.buildProtocolViewerContexts()) {
+        const key = context.escrow.toLowerCase();
+        if (seenEscrows.has(key)) continue;
+        seenEscrows.add(key);
+        escrows.push(context.escrow);
+      }
+      for (const escrow of escrows) {
+        const pending = requests.filter(
+          (entry) => !entry.hintedEscrow && resolved[entry.index] === void 0
+        );
+        if (!pending.length) break;
+        await resolveBatch(escrow, pending);
+      }
+      if (requests.every((entry) => resolved[entry.index] !== void 0)) {
+        return resolved;
+      }
+      if (!hadSuccessfulBatchRead && attemptedBatchRead && lastBatchError) {
+        throw lastBatchError;
+      }
+      return Promise.all(
+        requests.map(
+          (entry) => resolved[entry.index] ?? this.config.host.getPvDepositById(entry.id)
+        )
+      );
+    }
+    const raw = await this.config.getPublicClient().readContract({
+      address: protocolViewerAddress,
+      abi: protocolViewerAbi,
+      functionName: "getDepositFromIds",
+      args: [bn]
+    });
+    return raw.map(parseDepositView2);
+  }
+  async getPvAccountDeposits(owner) {
+    const inputCount = this.config.host.protocolViewerFunctionInputCount("getAccountDeposits");
+    const protocolViewerAddress = this.config.getProtocolViewerAddress();
+    const protocolViewerAbi = this.config.getProtocolViewerAbi();
+    if (!protocolViewerAddress || !protocolViewerAbi || inputCount === null) {
+      return this.config.host.getPvAccountDepositsFromIndexer(owner);
+    }
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-QVG4JP23.mjs');
+    const { address, abi } = this.config.host.requireProtocolViewer();
+    if (inputCount >= 2) {
+      const readAndFilter = async (raw2) => {
+        const filtered = [];
+        for (const item of raw2) {
+          const parsed = parseDepositView2(item);
+          if (this.config.host.isProtocolViewerDepositPopulated(parsed)) {
+            filtered.push(parsed);
+          }
+        }
+        return filtered;
+      };
+      if (inputCount >= 3) {
+        const { results: results2, attemptedRead: attemptedRead2, hadSuccessfulRead: hadSuccessfulRead2, lastError: lastError2 } = await collectFromContexts(
+          this.config.host.buildProtocolViewerContexts(),
+          async (context) => {
+            const raw2 = await this.config.getPublicClient().readContract({
+              address,
+              abi,
+              functionName: "getAccountDeposits",
+              args: [context.escrow, context.orchestrator, owner]
+            });
+            return readAndFilter(raw2);
+          }
+        );
+        if (!hadSuccessfulRead2 && attemptedRead2 && lastError2) {
+          throw lastError2;
+        }
+        return results2;
+      }
+      const seenEscrows = /* @__PURE__ */ new Set();
+      const escrowAddresses = [
+        ...this.config.host.buildProtocolViewerContexts().map((context) => context.escrow),
+        ...this.config.host.getEscrowContexts().map((context) => context.address)
+      ].filter((escrow) => {
+        const key = escrow.toLowerCase();
+        if (seenEscrows.has(key)) return false;
+        seenEscrows.add(key);
+        return true;
+      });
+      const { results, attemptedRead, hadSuccessfulRead, lastError } = await collectFromContexts(
+        escrowAddresses,
+        async (escrow) => {
+          const raw2 = await this.config.getPublicClient().readContract({
+            address,
+            abi,
+            functionName: "getAccountDeposits",
+            args: [escrow, owner]
+          });
+          return readAndFilter(raw2);
+        }
+      );
+      if (!hadSuccessfulRead && attemptedRead && lastError) {
+        throw lastError;
+      }
+      return results;
+    }
+    const raw = await this.config.getPublicClient().readContract({
+      address,
+      abi,
+      functionName: "getAccountDeposits",
+      args: [owner]
+    });
+    return raw.map(parseDepositView2).filter((view) => this.config.host.isProtocolViewerDepositPopulated(view));
+  }
+  async getPvAccountIntents(owner) {
+    const protocolViewerEntries = this.config.getProtocolViewerEntries();
+    if (protocolViewerEntries.length === 0) {
+      throw new Error("ProtocolViewer not available for this network");
+    }
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-QVG4JP23.mjs');
+    const intentsByHash = /* @__PURE__ */ new Map();
+    let attemptedRead = false;
+    let hadSuccessfulRead = false;
+    let lastError;
+    const runtimeProcess = globalThis.process;
+    const protocolViewerDebugEnv = runtimeProcess?.env?.ZKP2P_DEBUG_PROTOCOL_VIEWER;
+    const isDebugLoggingEnabled = protocolViewerDebugEnv === "1" || protocolViewerDebugEnv === "true" || runtimeProcess?.env?.NODE_ENV === "development";
+    for (const pvEntry of protocolViewerEntries) {
+      const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getAccountIntents");
+      if (inputCount === null) continue;
+      if (inputCount >= 2) {
+        for (const context of this.config.host.buildProtocolViewerContexts()) {
+          if (isDebugLoggingEnabled) {
+            console.debug("[Zkp2pClient] getPvAccountIntents read context", {
+              protocolViewerAddress: pvEntry.address,
+              owner,
+              escrow: context.escrow,
+              orchestrator: context.orchestrator,
+              inputCount
+            });
+          }
+          attemptedRead = true;
+          try {
+            const args = inputCount >= 3 ? [context.escrow, context.orchestrator, owner] : [context.orchestrator, owner];
+            const raw = await this.config.getPublicClient().readContract({
+              address: pvEntry.address,
+              abi: pvEntry.abi,
+              functionName: "getAccountIntents",
+              args
+            });
+            hadSuccessfulRead = true;
+            for (const item of raw) {
+              const parsed = parseIntentView2(item);
+              if (!this.config.host.isProtocolViewerIntentPopulated(parsed)) continue;
+              intentsByHash.set(parsed.intentHash.toLowerCase(), parsed);
+            }
+          } catch (readError) {
+            lastError = readError;
+            if (isDebugLoggingEnabled) {
+              console.warn("[Zkp2pClient] getPvAccountIntents context read failed", {
+                protocolViewerAddress: pvEntry.address,
+                owner,
+                escrow: context.escrow,
+                orchestrator: context.orchestrator,
+                inputCount,
+                error: readError instanceof Error ? readError.message : String(readError)
+              });
+            }
+          }
+        }
+      } else {
+        if (isDebugLoggingEnabled) {
+          console.debug("[Zkp2pClient] getPvAccountIntents read legacy context", {
+            protocolViewerAddress: pvEntry.address,
+            owner,
+            inputCount
+          });
+        }
+        attemptedRead = true;
+        try {
+          const raw = await this.config.getPublicClient().readContract({
+            address: pvEntry.address,
+            abi: pvEntry.abi,
+            functionName: "getAccountIntents",
+            args: [owner]
+          });
+          hadSuccessfulRead = true;
+          for (const item of raw) {
+            const parsed = parseIntentView2(item);
+            if (!this.config.host.isProtocolViewerIntentPopulated(parsed)) continue;
+            if (!intentsByHash.has(parsed.intentHash.toLowerCase())) {
+              intentsByHash.set(parsed.intentHash.toLowerCase(), parsed);
+            }
+          }
+        } catch (readError) {
+          lastError = readError;
+          if (isDebugLoggingEnabled) {
+            console.warn("[Zkp2pClient] getPvAccountIntents legacy read failed", {
+              protocolViewerAddress: pvEntry.address,
+              owner,
+              inputCount,
+              error: readError instanceof Error ? readError.message : String(readError)
+            });
+          }
+        }
+      }
+    }
+    if (!hadSuccessfulRead && attemptedRead && lastError) {
+      throw lastError;
+    }
+    if (!attemptedRead && isDebugLoggingEnabled) {
+      console.warn(
+        "[Zkp2pClient] getPvAccountIntents did not execute any reads; verify ProtocolViewer ABI/configuration"
+      );
+    }
+    return Array.from(intentsByHash.values()).sort((left, right) => {
+      if (left.intent.timestamp === right.intent.timestamp) {
+        return left.intentHash.localeCompare(right.intentHash);
+      }
+      return left.intent.timestamp < right.intent.timestamp ? -1 : 1;
+    });
+  }
+  async getPvIntent(intentHash) {
+    const protocolViewerEntries = this.config.getProtocolViewerEntries();
+    if (protocolViewerEntries.length === 0) {
+      throw new Error("ProtocolViewer not available for this network");
+    }
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-QVG4JP23.mjs');
+    let lastError;
+    for (const pvEntry of protocolViewerEntries) {
+      const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
+      if (inputCount === null) continue;
+      if (inputCount >= 2) {
+        let routing = {};
+        try {
+          routing = await this.config.host.lookupIntentRouting(intentHash);
+        } catch (routingError) {
+          lastError = routingError;
+        }
+        for (const context of this.config.host.buildProtocolViewerContexts({
+          escrowAddress: routing.escrowAddress,
+          orchestratorAddress: routing.orchestratorAddress
+        })) {
+          try {
+            const args = inputCount >= 3 ? [context.escrow, context.orchestrator, intentHash] : [context.orchestrator, intentHash];
+            const raw = await this.config.getPublicClient().readContract({
+              address: pvEntry.address,
+              abi: pvEntry.abi,
+              functionName: "getIntent",
+              args
+            });
+            const parsed = parseIntentView2(raw);
+            if (this.config.host.isProtocolViewerIntentPopulated(parsed)) {
+              return parsed;
+            }
+            lastError = new Error("Intent not found");
+          } catch (readError) {
+            lastError = readError;
+          }
+        }
+      } else {
+        try {
+          const raw = await this.config.getPublicClient().readContract({
+            address: pvEntry.address,
+            abi: pvEntry.abi,
+            functionName: "getIntent",
+            args: [intentHash]
+          });
+          const parsed = parseIntentView2(raw);
+          if (this.config.host.isProtocolViewerIntentPopulated(parsed)) {
+            return parsed;
+          }
+          lastError = new Error("Intent not found");
+        } catch (readError) {
+          lastError = readError;
+        }
+      }
+    }
+    throw lastError ?? new Error("Intent not found");
+  }
+};
+
+// src/client/VaultOperations.ts
+var VaultOperations = class {
+  constructor(config) {
+    this.config = config;
+  }
+  supportsInlineOracleRateConfig(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params?.escrowAddress,
+      preferV2: params?.preferV2
+    });
+    return escrowCurrencyHasOracleConfig(escrowContext.abi);
+  }
+  resolveRateManagerRegistryContract(registryAddress) {
+    const abi = this.config.getRateManagerRegistryAbi();
+    if (!abi) {
+      throw this.buildRateManagerUnavailableError("Rate manager registry not available");
+    }
+    if (registryAddress) {
+      return {
+        address: registryAddress,
+        abi
+      };
+    }
+    const address = this.config.getRateManagerRegistryAddress();
+    if (!address) {
+      throw this.buildRateManagerUnavailableError("Rate manager registry not available");
+    }
+    return {
+      address,
+      abi
+    };
+  }
+  buildRateManagerUnavailableError(reason) {
+    const initError = this.config.getRateManagerInitError();
+    if (!initError) {
+      return new Error(reason);
+    }
+    return new Error(
+      `${reason}. Rate manager contracts failed to initialize: ${initError.message}`
+    );
+  }
+  buildCreateRateManagerConfig(config) {
+    const registryAbi = this.config.getRateManagerRegistryAbi();
+    const includeDepositHook = abiTupleHasComponent(
+      registryAbi,
+      "createRateManager",
+      "depositHook"
+    );
+    const includeMinLiquidity = abiTupleHasComponent(
+      registryAbi,
+      "createRateManager",
+      "minLiquidity"
+    );
+    const result = {
+      manager: config.manager,
+      feeRecipient: config.feeRecipient,
+      maxFee: config.maxFee,
+      fee: config.fee
+    };
+    if (includeDepositHook) {
+      result.depositHook = config.depositHook ?? ZERO_ADDRESS;
+    }
+    if (includeMinLiquidity) {
+      result.minLiquidity = config.minLiquidity ?? 0n;
+    }
+    result.name = config.name;
+    result.uri = config.uri;
+    return result;
+  }
+  buildSetRateManagerConfigArgs(params) {
+    const registryAbi = this.config.getRateManagerRegistryAbi();
+    const includeHook = abiFunctionHasInput(registryAbi, "setRateManagerConfig", "_newHook") || abiFunctionHasInput(registryAbi, "setRateManagerConfig", "newHook");
+    if (includeHook) {
+      return [
+        params.rateManagerId,
+        params.newManager,
+        params.newFeeRecipient,
+        params.newHook ?? ZERO_ADDRESS,
+        params.newName,
+        params.newUri
+      ];
+    }
+    return [
+      params.rateManagerId,
+      params.newManager,
+      params.newFeeRecipient,
+      params.newName,
+      params.newUri
+    ];
+  }
+  prepareRateManagerRegistryTransaction(opts) {
+    const contract = this.resolveRateManagerRegistryContract(opts.registry);
+    const functionName = resolveAbiFunctionName(contract.abi, opts.functionNames);
+    return this.config.host.prepareContractTransaction({
+      address: contract.address,
+      abi: contract.abi,
+      functionName,
+      args: opts.args,
+      txOverrides: opts.txOverrides
+    });
+  }
+  prepareCreateRateManagerTransaction(params) {
+    return this.prepareRateManagerRegistryTransaction({
+      functionNames: ["createRateManager"],
+      args: [this.buildCreateRateManagerConfig(params.config)],
+      txOverrides: params.txOverrides
+    });
+  }
+  prepareSetVaultRateTransaction(params) {
+    return this.prepareRateManagerRegistryTransaction({
+      functionNames: ["setRate", "setMinRate"],
+      args: [params.rateManagerId, params.paymentMethodHash, params.currencyHash, params.rate],
+      txOverrides: params.txOverrides
+    });
+  }
+  prepareSetVaultRatesBatchTransaction(params) {
+    return this.prepareRateManagerRegistryTransaction({
+      functionNames: ["setRateBatch", "setMinRatesBatch"],
+      args: [params.rateManagerId, params.paymentMethods, params.currencies, params.rates],
+      txOverrides: params.txOverrides
+    });
+  }
+  prepareSetOracleRateConfigTransaction(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrowAddress,
+      depositId: params.depositId,
+      preferV2: true
+    });
+    if (escrowContext.version !== "v2") {
+      throw new Error("setOracleRateConfig requires EscrowV2");
+    }
+    const functionName = resolveAbiFunctionName(escrowContext.abi, ["setOracleRateConfig"]);
+    return this.config.host.prepareEscrowTransaction({
+      functionName,
+      args: [
+        parseRawDepositId(params.depositId),
+        params.paymentMethodHash,
+        params.currencyHash,
+        normalizeOracleRateConfig(params.config)
+      ],
+      txOverrides: params.txOverrides,
+      escrowAddress: escrowContext.address,
+      escrowAbi: escrowContext.abi
+    });
+  }
+  prepareRemoveOracleRateConfigTransaction(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrowAddress,
+      depositId: params.depositId,
+      preferV2: true
+    });
+    if (escrowContext.version !== "v2") {
+      throw new Error("removeOracleRateConfig requires EscrowV2");
+    }
+    const functionName = resolveAbiFunctionName(escrowContext.abi, ["removeOracleRateConfig"]);
+    return this.config.host.prepareEscrowTransaction({
+      functionName,
+      args: [parseRawDepositId(params.depositId), params.paymentMethodHash, params.currencyHash],
+      txOverrides: params.txOverrides,
+      escrowAddress: escrowContext.address,
+      escrowAbi: escrowContext.abi
+    });
+  }
+  prepareSetOracleRateConfigBatchTransaction(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrowAddress,
+      depositId: params.depositId,
+      preferV2: true
+    });
+    if (escrowContext.version !== "v2") {
+      throw new Error("setOracleRateConfigBatch requires EscrowV2");
+    }
+    const functionName = resolveAbiFunctionName(escrowContext.abi, ["setOracleRateConfigBatch"]);
+    return this.config.host.prepareEscrowTransaction({
+      functionName,
+      args: [
+        parseRawDepositId(params.depositId),
+        params.paymentMethods,
+        params.currencies,
+        params.configs.map((group) => group.map((config) => normalizeOracleRateConfig(config)))
+      ],
+      txOverrides: params.txOverrides,
+      escrowAddress: escrowContext.address,
+      escrowAbi: escrowContext.abi
+    });
+  }
+  prepareUpdateCurrencyConfigBatchTransaction(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrowAddress,
+      depositId: params.depositId,
+      preferV2: true
+    });
+    if (escrowContext.version !== "v2") {
+      throw new Error("updateCurrencyConfigBatch requires EscrowV2");
+    }
+    const functionName = resolveAbiFunctionName(escrowContext.abi, ["updateCurrencyConfigBatch"]);
+    return this.config.host.prepareEscrowTransaction({
+      functionName,
+      args: [
+        parseRawDepositId(params.depositId),
+        params.paymentMethods,
+        params.updates.map(
+          (group) => group.map((update) => ({
+            code: update.code,
+            minConversionRate: typeof update.minConversionRate === "bigint" ? update.minConversionRate : BigInt(update.minConversionRate),
+            updateOracle: update.updateOracle,
+            oracleRateConfig: normalizeOracleRateConfig(update.oracleRateConfig)
+          }))
+        )
+      ],
+      txOverrides: params.txOverrides,
+      escrowAddress: escrowContext.address,
+      escrowAbi: escrowContext.abi
+    });
+  }
+  prepareDeactivateCurrenciesBatchTransaction(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrowAddress,
+      depositId: params.depositId,
+      preferV2: true
+    });
+    if (escrowContext.version !== "v2") {
+      throw new Error("deactivateCurrenciesBatch requires EscrowV2");
+    }
+    const functionName = resolveAbiFunctionName(escrowContext.abi, ["deactivateCurrenciesBatch"]);
+    return this.config.host.prepareEscrowTransaction({
+      functionName,
+      args: [parseRawDepositId(params.depositId), params.paymentMethods, params.currencyCodes],
+      txOverrides: params.txOverrides,
+      escrowAddress: escrowContext.address,
+      escrowAbi: escrowContext.abi
+    });
+  }
+  prepareSetVaultConfigTransaction(params) {
+    return this.prepareRateManagerRegistryTransaction({
+      functionNames: ["setRateManagerConfig"],
+      args: this.buildSetRateManagerConfigArgs(params),
+      txOverrides: params.txOverrides
+    });
+  }
+  async getDepositRateManager(escrow, depositId) {
+    const id = parseRawDepositId(depositId);
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: escrow,
+      depositId
+    });
+    if (getRateManagerReadFunction(escrowContext.abi, "getDepositRateManager")) {
+      const result = await this.config.getPublicClient().readContract({
+        address: escrowContext.address,
+        abi: escrowContext.abi,
+        functionName: "getDepositRateManager",
+        args: [id]
+      });
+      if (result && result.length >= 2) {
+        return {
+          registry: result[0],
+          rateManagerId: result[1]
+        };
+      }
+    }
+    const controllerAddress = this.config.getRateManagerControllerAddress();
+    const controllerAbi = this.config.getRateManagerControllerAbi();
+    if (!controllerAddress || !controllerAbi) {
+      throw this.buildRateManagerUnavailableError("Rate manager controller not available");
+    }
+    const legacyResult = await this.config.getPublicClient().readContract({
+      address: controllerAddress,
+      abi: controllerAbi,
+      functionName: "getDepositRateManager",
+      args: [escrow, id]
+    });
+    return {
+      registry: legacyResult[0],
+      rateManagerId: legacyResult[1]
+    };
+  }
+  async getManagerFee(escrow, depositId) {
+    const id = parseRawDepositId(depositId);
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: escrow,
+      depositId
+    });
+    if (getRateManagerReadFunction(escrowContext.abi, "getManagerFee")) {
+      const result2 = await this.config.getPublicClient().readContract({
+        address: escrowContext.address,
+        abi: escrowContext.abi,
+        functionName: "getManagerFee",
+        args: [id]
+      });
+      return parseManagerFeeFromRead(result2);
+    }
+    const controllerAddress = this.config.getRateManagerControllerAddress();
+    const controllerAbi = this.config.getRateManagerControllerAbi();
+    if (!controllerAddress || !controllerAbi) {
+      throw this.buildRateManagerUnavailableError("Rate manager controller not available");
+    }
+    const result = await this.config.getPublicClient().readContract({
+      address: controllerAddress,
+      abi: controllerAbi,
+      functionName: "getManagerFee",
+      args: [escrow, id]
+    });
+    return parseManagerFeeFromRead(result);
+  }
+  async getEffectiveRate(params) {
+    const escrowContext = this.config.host.resolveEscrowContext({
+      escrowAddress: params.escrow,
+      depositId: params.depositId
+    });
+    const id = parseRawDepositId(params.depositId);
+    return await this.config.getPublicClient().readContract({
+      address: escrowContext.address,
+      abi: escrowContext.abi,
+      functionName: "getEffectiveRate",
+      args: [id, params.paymentMethod, params.fiatCurrency]
+    });
+  }
+};
+var getRateManagerReadFunction = (abi, functionName) => Array.isArray(abi) && abi.some(
+  (item) => item.type === "function" && item.name === functionName
+);
+
+// src/indexer/client.ts
+var IndexerHttpError = class extends Error {
+  constructor(status, statusText, options) {
+    super(`Indexer request failed: ${status} ${statusText}`);
+    this.name = "IndexerHttpError";
+    this.status = status;
+    this.retryAfterSeconds = options?.retryAfterSeconds;
+  }
+};
+function parseRetryAfterSeconds(rawHeader) {
+  if (!rawHeader) return void 0;
+  const parsedSeconds = Number(rawHeader);
+  if (Number.isFinite(parsedSeconds) && parsedSeconds >= 0) {
+    return Math.ceil(parsedSeconds);
+  }
+  const parsedDateMs = Date.parse(rawHeader);
+  if (!Number.isFinite(parsedDateMs)) return void 0;
+  const secondsUntilRetry = Math.ceil((parsedDateMs - Date.now()) / 1e3);
+  return Math.max(0, secondsUntilRetry);
+}
+function createAbortError() {
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function delay(ms, signal) {
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(createAbortError());
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+    signal?.addEventListener("abort", onAbort);
+  });
+}
+var IndexerClient = class {
+  constructor(endpoint, options = {}) {
+    this.endpoint = endpoint;
+    this.options = options;
+    this.hasLoggedTokenProviderError = false;
+  }
+  async resolveAuthorizationToken() {
+    if (this.options.getAuthorizationToken) {
+      try {
+        const token = await this.options.getAuthorizationToken();
+        return token ?? void 0;
+      } catch (error) {
+        if (this.options.onAuthorizationTokenError) {
+          this.options.onAuthorizationTokenError(error);
+        } else if (!this.hasLoggedTokenProviderError) {
+          this.hasLoggedTokenProviderError = true;
+          console.warn(
+            "[IndexerClient] getAuthorizationToken failed; continuing without Authorization header",
+            error
+          );
+        }
+        return void 0;
+      }
+    }
+    return this.options.authorizationToken;
+  }
+  async _post(request, init) {
+    const token = await this.resolveAuthorizationToken();
+    const headers2 = new Headers(init?.headers);
+    if (!headers2.has("Content-Type")) {
+      headers2.set("Content-Type", "application/json");
+    }
+    if (token && !headers2.has("Authorization")) {
+      headers2.set("Authorization", token.startsWith("Bearer ") ? token : `Bearer ${token}`);
+    }
+    if (this.options.apiKey && !headers2.has("x-api-key")) {
+      headers2.set("x-api-key", this.options.apiKey);
+    }
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: headers2,
+      body: JSON.stringify(request),
+      cache: "no-store",
+      ...init
+    });
+    if (!res.ok) {
+      throw new IndexerHttpError(res.status, res.statusText, {
+        retryAfterSeconds: parseRetryAfterSeconds(res.headers.get("Retry-After"))
+      });
+    }
+    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 = Math.max(0, init?.retries ?? 1);
+    const rateLimitRetries = Math.max(0, init?.rateLimitRetries ?? 2);
+    const maxAttempts = 1 + Math.max(retries, rateLimitRetries);
+    const {
+      retries: _unusedRetries,
+      rateLimitRetries: _unusedRateLimitRetries,
+      ...requestInit
+    } = init ?? {};
+    let attempts = 0;
+    let rateLimitAttempt = 0;
     let standardRetryAttempt = 0;
     let lastErr;
     while (attempts < maxAttempts) {
@@ -1442,6 +3487,21 @@ function normalizeAddress2(value) {
   if (!value) return ZERO;
   return value.startsWith("0x") ? value : ZERO;
 }
+function resolveActiveConversionRate(currency) {
+  const candidates = [
+    currency.effectiveOracleRate,
+    currency.conversionRate,
+    currency.minConversionRate
+  ];
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === void 0) continue;
+    const parsed = toBigInt(candidate);
+    if (parsed > 0n) {
+      return candidate;
+    }
+  }
+  return currency.effectiveOracleRate ?? currency.conversionRate ?? currency.minConversionRate;
+}
 function extractDepositId(compositeId) {
   const parts = compositeId.split("_");
   return parts[1] || "0";
@@ -1469,7 +3529,7 @@ function convertIndexerDepositToEscrowView(deposit, _chainId, _escrowAddress) {
     },
     currencies: (currenciesByPaymentMethod.get(pm.paymentMethodHash) ?? []).map((cur) => ({
       code: cur.currencyCode,
-      conversionRate: toBigInt(cur.conversionRate ?? cur.minConversionRate)
+      conversionRate: toBigInt(resolveActiveConversionRate(cur))
     })),
     methodHash: pm.paymentMethodHash
   }));
@@ -1525,6 +3585,14 @@ function convertIndexerIntentsToEscrowViews(intents, depositViewsById) {
   return result;
 }
 
+// src/indexer/schemaCompatibility.ts
+function isSchemaCompatibilityError(error) {
+  if (!(error instanceof Error)) return false;
+  const message = error.message.toLowerCase();
+  if (!message.includes("graphql errors")) return false;
+  return message.includes("cannot query field") || message.includes("does not exist") || message.includes("not found in type");
+}
+
 // src/indexer/service.ts
 function groupByDepositId(items) {
   const map = /* @__PURE__ */ new Map();
@@ -1539,13 +3607,7 @@ function groupByDepositId(items) {
 }
 var DEFAULT_LIMIT = 100;
 var DEFAULT_ORDER_FIELD = "remainingDeposits";
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-function isSchemaCompatibilityError(error) {
-  if (!(error instanceof Error)) return false;
-  const message = error.message.toLowerCase();
-  if (!message.includes("graphql errors")) return false;
-  return message.includes("cannot query field") || message.includes("does not exist") || message.includes("not found in type");
-}
+var ZERO_ADDRESS3 = "0x0000000000000000000000000000000000000000";
 var IndexerDepositService = class {
   constructor(client) {
     this.client = client;
@@ -1574,7 +3636,7 @@ var IndexerDepositService = class {
     if (filter.delegate) {
       where.delegate = { _ilike: filter.delegate };
     } else if (filter.delegateIsSet !== void 0) {
-      where.delegate = filter.delegateIsSet ? { _neq: ZERO_ADDRESS } : { _eq: ZERO_ADDRESS };
+      where.delegate = filter.delegateIsSet ? { _neq: ZERO_ADDRESS3 } : { _eq: ZERO_ADDRESS3 };
     }
     if (filter.chainId) where.chainId = { _eq: filter.chainId };
     if (filter.escrowAddresses && filter.escrowAddresses.length) {
@@ -1912,12 +3974,6 @@ function normalizeRateManagerId2(value) {
   if (!value) return "";
   return value.toLowerCase();
 }
-function isSchemaCompatibilityError2(error) {
-  if (!(error instanceof Error)) return false;
-  const message = error.message.toLowerCase();
-  if (!message.includes("graphql errors")) return false;
-  return message.includes("cannot query field") || message.includes("does not exist") || message.includes("not found in type");
-}
 function normalizeAddress3(value) {
   if (!value) return "";
   return value.toLowerCase();
@@ -2217,7 +4273,7 @@ var IndexerRateManagerService = class {
         offset += RATE_MANAGER_HISTORY_PAGE_SIZE;
       }
     } catch (error) {
-      if (!isSchemaCompatibilityError2(error)) {
+      if (!isSchemaCompatibilityError(error)) {
         throw error;
       }
     }
@@ -2326,7 +4382,7 @@ var IndexerRateManagerService = class {
         (stats) => (normalizeAddress3(stats.rateManagerAddress) || extractRateManagerAddressFromScopedId(stats.id)) === scopedRateManagerAddress
       ) ?? result.ManagerAggregateStats?.[0] ?? null;
     } catch (error) {
-      if (!isSchemaCompatibilityError2(error)) {
+      if (!isSchemaCompatibilityError(error)) {
         throw error;
       }
       const legacyResult = await this.client.query({
@@ -2380,7 +4436,7 @@ var IndexerRateManagerService = class {
       });
       return (result.Deposit ?? []).map((deposit) => toDelegationEntityFromDeposit(deposit)).filter((delegation) => Boolean(delegation));
     } catch (error) {
-      if (!isSchemaCompatibilityError2(error)) {
+      if (!isSchemaCompatibilityError(error)) {
         throw error;
       }
       const legacyResult = await this.client.query({
@@ -2418,7 +4474,7 @@ var IndexerRateManagerService = class {
       });
       return result.ManagerDailySnapshot ?? [];
     } catch (error) {
-      if (!isSchemaCompatibilityError2(error)) {
+      if (!isSchemaCompatibilityError(error)) {
         throw error;
       }
       return [];
@@ -2440,7 +4496,7 @@ var IndexerRateManagerService = class {
       }
       return toDelegationEntityFromDeposit(delegationDeposit) ?? null;
     } catch (error) {
-      if (!isSchemaCompatibilityError2(error)) {
+      if (!isSchemaCompatibilityError(error)) {
         throw error;
       }
       const legacyResult = await this.client.query({
@@ -2481,7 +4537,7 @@ var IndexerRateManagerService = class {
         minRate: e.minRate ?? e.rate ?? "0"
       })).sort((a, b) => compareEventCursorIdsByRecency(a.id, b.id));
     } catch (error) {
-      if (!isSchemaCompatibilityError2(error)) {
+      if (!isSchemaCompatibilityError(error)) {
         throw error;
       }
       return [];
@@ -2536,7 +4592,7 @@ var IndexerRateManagerService = class {
         spreadBps: e.spreadBps ?? 0
       })).sort((a, b) => compareEventCursorIdsByRecency(a.id, b.id));
     } catch (error) {
-      if (isSchemaCompatibilityError2(error)) ; else {
+      if (isSchemaCompatibilityError(error)) ; else {
         throw error;
       }
       const legacyResult = await this.client.query({
@@ -2573,162 +4629,7 @@ async function fetchFulfillmentAndPayment(client, intentHash) {
   return client.query({
     query: FULFILLMENT_AND_PAYMENT_QUERY,
     variables: { intentHash }
-  });
-}
-
-// 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/verification.ts
-function createHeaders(apiKey, authorizationToken) {
-  const headers2 = { "Content-Type": "application/json" };
-  if (apiKey) headers2["x-api-key"] = apiKey;
-  if (authorizationToken)
-    headers2["Authorization"] = authorizationToken.startsWith("Bearer ") ? authorizationToken : `Bearer ${authorizationToken}`;
-  return headers2;
-}
-async function postSignIntentWithRetry(endpoint, request, opts) {
-  const url = `${opts.baseApiUrl.replace(/\/$/, "")}${endpoint}`;
-  return withRetry(
-    async () => {
-      let res;
-      try {
-        res = await fetch(url, {
-          method: "POST",
-          headers: createHeaders(opts.apiKey, opts.authorizationToken),
-          body: JSON.stringify(request)
-        });
-      } catch (error) {
-        throw new NetworkError("Failed to connect to API server", { endpoint, error });
-      }
-      if (!res.ok) {
-        const text = await res.text().catch(() => "");
-        throw parseAPIError(res, text);
-      }
-      return await res.json();
-    },
-    3,
-    1e3,
-    opts.timeoutMs
-  );
-}
-async function apiSignIntentV3(request, opts) {
-  const json = await postSignIntentWithRetry("/v3/intent", request, opts);
-  const sig = json?.responseObject?.signedIntent;
-  const expStr = json?.responseObject?.intentData?.signatureExpiration ?? json?.responseObject?.signatureExpiration;
-  const preIntentHookData = json?.responseObject?.intentData?.preIntentHookData ?? json?.responseObject?.preIntentHookData;
-  if (!sig || !expStr) throw new Error("v3/intent missing signature or expiration");
-  return {
-    signature: sig,
-    signatureExpiration: BigInt(expStr),
-    preIntentHookData
-  };
-}
-async function apiSignIntentV2(request, opts) {
-  const json = await postSignIntentWithRetry(
-    "/v2/verify/intent",
-    request,
-    opts
-  );
-  const sig = json?.responseObject?.signedIntent;
-  const expStr = json?.responseObject?.intentData?.signatureExpiration ?? json?.responseObject?.signatureExpiration;
-  const preIntentHookData = json?.responseObject?.intentData?.preIntentHookData ?? json?.responseObject?.preIntentHookData;
-  if (!sig || !expStr) throw new Error("verify/intent missing signature or expiration");
-  return {
-    signature: sig,
-    signatureExpiration: BigInt(expStr),
-    preIntentHookData
-  };
-}
-
-// 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
@@ -2986,7 +4887,7 @@ async function apiGetOwnerDeposits(req, apiKey, baseApiUrl, authToken, timeoutMs
     statusCode: 200
   };
 }
-async function apiGetTakerTier(req, apiKey, baseApiUrl, authToken, timeoutMs) {
+async function apiGetTakerTier(req, apiKey, baseApiUrl, timeoutMs) {
   const normalizedOwner = req.owner.toLowerCase();
   const query = new URLSearchParams({
     owner: normalizedOwner,
@@ -2997,10 +4898,102 @@ async function apiGetTakerTier(req, apiKey, baseApiUrl, authToken, timeoutMs) {
     url: `${withApiBase(baseApiUrl)}${endpoint}`,
     method: "GET",
     apiKey,
-    authToken,
     timeoutMs
   });
 }
+var formatTokenAmountForDisplay = (amount, decimals) => {
+  const formatted = formatUnits(amount, decimals);
+  if (!formatted.includes(".")) {
+    return formatted;
+  }
+  const trimmed = formatted.replace(/\.?0+$/, "");
+  return trimmed.length > 0 ? trimmed : "0";
+};
+var applyReferrerFeeDisplayFieldsToTokenAmount = (tokenAmount, referrerFeeConfig, decimals) => {
+  try {
+    const grossAmount = BigInt(tokenAmount);
+    const feeAmount = grossAmount * BigInt(referrerFeeConfig.feeBps) / 10000n;
+    const netAmount = grossAmount - feeAmount;
+    return {
+      tokenAmount: netAmount.toString(),
+      tokenAmountFormatted: formatTokenAmountForDisplay(netAmount, decimals),
+      referrerFeeAmount: feeAmount.toString(),
+      referrerFeeAmountFormatted: formatTokenAmountForDisplay(feeAmount, decimals),
+      referrerFeeBps: referrerFeeConfig.feeBps,
+      signalIntentAmount: grossAmount.toString(),
+      signalIntentAmountFormatted: formatTokenAmountForDisplay(grossAmount, decimals)
+    };
+  } catch {
+    return null;
+  }
+};
+var applyReferrerFeeDisplayFieldsToQuote = (quote, referrerFeeConfig, decimals) => {
+  const adjusted = applyReferrerFeeDisplayFieldsToTokenAmount(
+    quote.tokenAmount,
+    referrerFeeConfig,
+    decimals
+  );
+  if (!adjusted) {
+    return quote;
+  }
+  return {
+    ...quote,
+    ...adjusted
+  };
+};
+var appendReferrerFeeDisplayFields = (quoteResponse, referrerFeeConfig) => {
+  if (!referrerFeeConfig) {
+    return quoteResponse;
+  }
+  const decimals = quoteResponse.responseObject?.token?.decimals ?? 6;
+  const enrichedQuotes = (quoteResponse.responseObject?.quotes ?? []).map(
+    (quote) => applyReferrerFeeDisplayFieldsToQuote(quote, referrerFeeConfig, decimals)
+  );
+  const enrichedNearbySuggestions = quoteResponse.responseObject?.nearbySuggestions ? {
+    below: quoteResponse.responseObject.nearbySuggestions.below.map((suggestion) => {
+      const adjustedSuggestionAmount = suggestion.suggestedTokenAmount ? applyReferrerFeeDisplayFieldsToTokenAmount(
+        suggestion.suggestedTokenAmount,
+        referrerFeeConfig,
+        decimals
+      ) : null;
+      return {
+        ...suggestion,
+        suggestedTokenAmount: adjustedSuggestionAmount?.tokenAmount ?? suggestion.suggestedTokenAmount,
+        suggestedTokenAmountFormatted: adjustedSuggestionAmount?.tokenAmountFormatted ?? suggestion.suggestedTokenAmountFormatted,
+        quote: applyReferrerFeeDisplayFieldsToQuote(
+          suggestion.quote,
+          referrerFeeConfig,
+          decimals
+        )
+      };
+    }),
+    above: quoteResponse.responseObject.nearbySuggestions.above.map((suggestion) => {
+      const adjustedSuggestionAmount = suggestion.suggestedTokenAmount ? applyReferrerFeeDisplayFieldsToTokenAmount(
+        suggestion.suggestedTokenAmount,
+        referrerFeeConfig,
+        decimals
+      ) : null;
+      return {
+        ...suggestion,
+        suggestedTokenAmount: adjustedSuggestionAmount?.tokenAmount ?? suggestion.suggestedTokenAmount,
+        suggestedTokenAmountFormatted: adjustedSuggestionAmount?.tokenAmountFormatted ?? suggestion.suggestedTokenAmountFormatted,
+        quote: applyReferrerFeeDisplayFieldsToQuote(
+          suggestion.quote,
+          referrerFeeConfig,
+          decimals
+        )
+      };
+    })
+  } : void 0;
+  return {
+    ...quoteResponse,
+    responseObject: {
+      ...quoteResponse.responseObject,
+      quotes: enrichedQuotes,
+      nearbySuggestions: enrichedNearbySuggestions
+    }
+  };
+};
 
 // src/utils/erc20.ts
 var ERC20_ABI = [
@@ -3025,72 +5018,9 @@ var ERC20_ABI = [
     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]);
-}
-function encodeWithAttribution(request, referrer) {
-  const functionData = encodeFunctionData({
-    abi: request.abi,
-    functionName: request.functionName,
-    args: request.args || []
-  });
-  return appendAttributionToCalldata(functionData, referrer);
-}
-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 ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
-var _Zkp2pClient = class _Zkp2pClient {
+var Zkp2pClient = class {
   /**
    * Creates a new Zkp2pClient instance.
    *
@@ -3199,6 +5129,46 @@ var _Zkp2pClient = class _Zkp2pClient {
         }
       }
     );
+    /**
+     * Batch update currency min-rate and oracle-config entries for an EscrowV2 deposit.
+     */
+    this.updateCurrencyConfigBatch = Object.assign(
+      async (params) => {
+        const prepared = this.prepareUpdateCurrencyConfigBatchTransaction(params);
+        return this.executePreparedTransaction(prepared, params.txOverrides);
+      },
+      {
+        prepare: async (params) => {
+          const prepared = this.prepareUpdateCurrencyConfigBatchTransaction(params);
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
+    /**
+     * Batch deactivate currencies for an EscrowV2 deposit.
+     */
+    this.deactivateCurrenciesBatch = Object.assign(
+      async (params) => {
+        const prepared = this.prepareDeactivateCurrenciesBatchTransaction(params);
+        return this.executePreparedTransaction(prepared, params.txOverrides);
+      },
+      {
+        prepare: async (params) => {
+          const prepared = this.prepareDeactivateCurrenciesBatchTransaction(params);
+          return {
+            to: prepared.to,
+            data: prepared.data,
+            value: prepared.value,
+            chainId: prepared.chainId
+          };
+        }
+      }
+    );
     /**
      * Adds additional funds to an existing deposit.
      * Requires prior approval of the token amount.
@@ -3612,8 +5582,9 @@ var _Zkp2pClient = class _Zkp2pClient {
      * @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.referralFees - Optional referral fee recipients and fee amounts
+     * @param params.referrer - Deprecated legacy single-referrer address
+     * @param params.referrerFee - Deprecated legacy single-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)
@@ -3976,7 +5947,8 @@ var _Zkp2pClient = class _Zkp2pClient {
         if (!this.rateManagerControllerAbi && rateManagerContracts.abis.controller) {
           this.rateManagerControllerAbi = rateManagerContracts.abis.controller;
         }
-      } catch {
+      } catch (error) {
+        this._rateManagerInitError = error instanceof Error ? error : new Error(String(error));
       }
     }
     this._router = new ContractRouter({
@@ -4015,316 +5987,144 @@ var _Zkp2pClient = class _Zkp2pClient {
     this.apiKey = opts.apiKey;
     this.authorizationToken = opts.authorizationToken;
     this.apiTimeoutMs = opts.timeouts?.api ?? 15e3;
+    this._pvReader = new ProtocolViewerReader({
+      getPublicClient: () => this.publicClient,
+      getProtocolViewerAddress: () => this.protocolViewerAddress,
+      getProtocolViewerAbi: () => this.protocolViewerAbi,
+      getProtocolViewerEntries: () => this._protocolViewerEntries,
+      getEscrowAddresses: () => this.escrowAddresses,
+      getIndexerService: () => this._indexerService,
+      getRouterBuildProtocolViewerContexts: () => this._router.buildProtocolViewerContexts.bind(this._router),
+      host: {
+        requireProtocolViewer: () => this.requireProtocolViewer(),
+        protocolViewerFunctionInputCount: (functionName) => this.protocolViewerFunctionInputCount(functionName),
+        buildProtocolViewerContexts: (options) => this.buildProtocolViewerContexts(options),
+        isProtocolViewerDepositPopulated: (view) => this.isProtocolViewerDepositPopulated(view),
+        isProtocolViewerIntentPopulated: (view) => this.isProtocolViewerIntentPopulated(view),
+        buildDepositViewFromEscrowDeposit: (rawDeposit, depositId) => this.buildDepositViewFromEscrowDeposit(rawDeposit, depositId),
+        getPvAccountDepositsFromIndexer: (owner) => this.getPvAccountDepositsFromIndexer(owner),
+        getPvDepositById: (depositId, options) => options === void 0 ? this.getPvDepositById(depositId) : this.getPvDepositById(depositId, options),
+        getEscrowContexts: () => this.getEscrowContexts(),
+        lookupIntentRouting: (intentHash) => this.lookupIntentRouting(intentHash)
+      }
+    });
+    this._vaultOps = new VaultOperations({
+      getPublicClient: () => this.publicClient,
+      getRateManagerRegistryAddress: () => this.rateManagerRegistryAddress,
+      getRateManagerRegistryAbi: () => this.rateManagerRegistryAbi,
+      getRateManagerControllerAddress: () => this.rateManagerControllerAddress,
+      getRateManagerControllerAbi: () => this.rateManagerControllerAbi,
+      getRateManagerInitError: () => this._rateManagerInitError,
+      host: {
+        resolveEscrowContext: (options) => this.resolveEscrowContext(options),
+        prepareEscrowTransaction: (tx) => this.prepareEscrowTransaction(tx),
+        prepareContractTransaction: (tx) => this.prepareContractTransaction(tx)
+      }
+    });
+    this._intentOps = new IntentOperations({
+      getWalletClient: () => this.walletClient,
+      getPublicClient: () => this.publicClient,
+      getChainId: () => this.chainId,
+      getRuntimeEnv: () => this.runtimeEnv,
+      getBaseApiUrl: () => this.baseApiUrl,
+      getApiKey: () => this.apiKey,
+      getAuthorizationToken: () => this.authorizationToken,
+      getApiTimeoutMs: () => this.apiTimeoutMs,
+      getProtocolViewerAddress: () => this.protocolViewerAddress,
+      getProtocolViewerAbi: () => this.protocolViewerAbi,
+      getIndexerClient: () => this._indexerClient,
+      getIndexerService: () => this._indexerService,
+      getDefaultPreferV2: () => this._router.defaultPreferV2,
+      host: {
+        resolveEscrowContext: (options) => this.resolveEscrowContext(options),
+        resolveOrchestratorContext: (options) => this.resolveOrchestratorContext(options),
+        resolveEscrowAddressOrThrow: (escrowAddress, depositId, methodName, options) => this.resolveEscrowAddressOrThrow(escrowAddress, depositId, methodName, options),
+        prepareResolvedOrchestratorTransaction: (tx) => this.prepareResolvedOrchestratorTransaction(tx),
+        getFulfillIntentInputs: (intentHash) => this.getFulfillIntentInputs(intentHash),
+        getPvIntent: (intentHash) => this.getPvIntent(intentHash)
+      }
+    });
   }
   isValidHexAddress(addr) {
-    if (typeof addr !== "string") return false;
-    return /^0x[0-9a-fA-F]{40}$/.test(addr);
+    return isValidHexAddress(addr);
   }
   normalizeAddress(addr) {
-    if (!this.isValidHexAddress(addr)) return void 0;
-    return addr;
+    return normalizeAddress(addr);
   }
   parseEscrowAddressFromCompositeDepositId(depositId) {
-    if (typeof depositId !== "string") return void 0;
-    const parts = depositId.split("_");
-    if (parts.length < 2) return void 0;
-    const maybeEscrow = parts.length >= 3 ? parts[parts.length - 2] : parts[0];
-    return this.normalizeAddress(maybeEscrow);
+    return parseEscrowAddressFromCompositeDepositId(depositId);
   }
   parseRawDepositId(depositId) {
-    if (typeof depositId === "bigint") return depositId;
-    if (typeof depositId === "number") return parseBigIntLike(depositId, "Invalid deposit id");
-    const parts = depositId.split("_");
-    const raw = parts[parts.length - 1] ?? depositId;
-    return parseBigIntLike(raw, "Invalid deposit id");
+    return parseRawDepositId(depositId);
   }
   normalizeOracleRateConfig(config) {
-    const spreadBps = Number(config.spreadBps);
-    if (!Number.isFinite(spreadBps) || spreadBps < 0 || spreadBps > 65535) {
-      throw new Error("Oracle spreadBps must be between 0 and 65535");
-    }
-    const maxStaleness = Number(config.maxStaleness);
-    if (!Number.isFinite(maxStaleness) || maxStaleness < 0 || maxStaleness > 4294967295) {
-      throw new Error("Oracle maxStaleness must be between 0 and 4294967295");
-    }
-    return {
-      adapter: config.adapter,
-      adapterConfig: config.adapterConfig,
-      spreadBps: Math.round(spreadBps),
-      maxStaleness: Math.round(maxStaleness)
-    };
+    return normalizeOracleRateConfig(config);
   }
-  /**
-   * Checks whether the Currency struct in the ABI includes an `oracleRateConfig` component.
-   * This is a deep check: createDeposit takes a top-level tuple with a `currencies` field
-   * that is a tuple[][] — each inner tuple is a Currency struct.
-   */
   escrowCurrencyHasOracleConfig(abi) {
-    if (!Array.isArray(abi)) return false;
-    const fnNames = ["createDeposit", "addPaymentMethods", "addCurrencies"];
-    for (const fnName of fnNames) {
-      const fn = abi.find(
-        (item) => item.type === "function" && item.name === fnName
-      );
-      if (!fn) continue;
-      const inputs = fn.inputs ?? [];
-      const hasCurrencyOracle = (items) => {
-        for (const item of items) {
-          const components = item.components ?? [];
-          if (components.some((c) => c.name === "code") && components.some((c) => c.name === "oracleRateConfig")) {
-            return true;
-          }
-          if (components.length > 0 && hasCurrencyOracle(components)) return true;
-        }
-        return false;
-      };
-      if (hasCurrencyOracle(inputs)) return true;
-    }
-    return false;
+    return escrowCurrencyHasOracleConfig(abi);
   }
   /**
    * Normalizes currency tuples by appending an empty `oracleRateConfig` when the ABI
    * requires it and the caller hasn't provided one.
    */
   normalizeCurrencyTuples(currencies, escrowAbi) {
-    const needsOracle = this.escrowCurrencyHasOracleConfig(escrowAbi);
-    if (!needsOracle) {
-      return currencies.map((c) => ({
-        code: c.code,
-        minConversionRate: c.minConversionRate
-      }));
-    }
-    return currencies.map((c) => ({
-      code: c.code,
-      minConversionRate: c.minConversionRate,
-      oracleRateConfig: c.oracleRateConfig ? this.normalizeOracleRateConfig(c.oracleRateConfig) : _Zkp2pClient.EMPTY_ORACLE_RATE_CONFIG
-    }));
+    return normalizeCurrencyTuples(currencies, escrowAbi);
   }
   supportsInlineOracleRateConfig(params) {
-    const escrowContext = this.resolveEscrowContext({
+    return this._vaultOps.supportsInlineOracleRateConfig({
       escrowAddress: params?.escrowAddress,
       preferV2: params?.preferV2 ?? this._router.defaultPreferV2
     });
-    return this.escrowCurrencyHasOracleConfig(escrowContext.abi);
   }
   parseManagerFeeFromRead(result) {
-    if (Array.isArray(result)) {
-      const candidate = result.length > 1 ? result[1] : result[0];
-      return parseBigIntLike(candidate, "Unexpected numeric response");
-    }
-    return parseBigIntLike(result, "Unexpected numeric response");
+    return parseManagerFeeFromRead(result);
   }
   getAbiFunction(abi, ...names) {
-    if (!Array.isArray(abi)) return null;
-    for (const name of names) {
-      const match = abi.find(
-        (item) => item.type === "function" && item.name === name
-      );
-      if (match) return match;
-    }
-    return null;
+    return getAbiFunction(abi, ...names);
   }
   resolveAbiFunctionName(abi, names) {
-    const match = this.getAbiFunction(abi, ...names);
-    const resolved = match?.name;
-    if (typeof resolved === "string") return resolved;
-    throw new Error(`Contract does not expose any of: ${names.join(", ")}`);
+    return resolveAbiFunctionName(abi, names);
   }
   abiTupleHasComponent(abi, functionName, componentName) {
-    const fn = this.getAbiFunction(abi, functionName);
-    const inputs = fn?.inputs ?? [];
-    const tupleInput = inputs.find((input) => input.type === "tuple");
-    const components = tupleInput?.components ?? [];
-    return components.some((component) => component.name === componentName);
+    return abiTupleHasComponent(abi, functionName, componentName);
   }
   abiFunctionHasInput(abi, functionName, inputName) {
-    const fn = this.getAbiFunction(abi, functionName);
-    const inputs = fn?.inputs ?? [];
-    return inputs.some((input) => input.name === inputName);
+    return abiFunctionHasInput(abi, functionName, inputName);
   }
   resolveEscrowAddressOrThrow(escrowAddress, depositId, methodName, options) {
-    const resolved = escrowAddress ?? this.parseEscrowAddressFromCompositeDepositId(depositId);
-    if (resolved) return resolved;
-    if (options?.preferV2 !== void 0) {
-      return this.resolveEscrowContext({ preferV2: options.preferV2 }).address;
-    }
-    throw new Error(`${methodName} requires escrowAddress or composite depositId`);
-  }
-  resolveRateManagerRegistryContract(registryAddress) {
-    if (!this.rateManagerRegistryAbi) {
-      throw new Error("Rate manager registry not available");
-    }
-    if (registryAddress) {
-      return {
-        address: registryAddress,
-        abi: this.rateManagerRegistryAbi
-      };
-    }
-    if (!this.rateManagerRegistryAddress) {
-      throw new Error("Rate manager registry not available");
-    }
-    return {
-      address: this.rateManagerRegistryAddress,
-      abi: this.rateManagerRegistryAbi
-    };
-  }
-  buildCreateRateManagerConfig(config) {
-    const includeDepositHook = this.abiTupleHasComponent(
-      this.rateManagerRegistryAbi,
-      "createRateManager",
-      "depositHook"
-    );
-    const includeMinLiquidity = this.abiTupleHasComponent(
-      this.rateManagerRegistryAbi,
-      "createRateManager",
-      "minLiquidity"
-    );
-    const result = {
-      manager: config.manager,
-      feeRecipient: config.feeRecipient,
-      maxFee: config.maxFee,
-      fee: config.fee
-    };
-    if (includeDepositHook) {
-      result.depositHook = config.depositHook ?? ZERO_ADDRESS2;
-    }
-    if (includeMinLiquidity) {
-      result.minLiquidity = config.minLiquidity ?? 0n;
-    }
-    result.name = config.name;
-    result.uri = config.uri;
-    return result;
-  }
-  buildSetRateManagerConfigArgs(params) {
-    const includeHook = this.abiFunctionHasInput(this.rateManagerRegistryAbi, "setRateManagerConfig", "_newHook") || this.abiFunctionHasInput(this.rateManagerRegistryAbi, "setRateManagerConfig", "newHook");
-    if (includeHook) {
-      return [
-        params.rateManagerId,
-        params.newManager,
-        params.newFeeRecipient,
-        params.newHook ?? ZERO_ADDRESS2,
-        params.newName,
-        params.newUri
-      ];
-    }
-    return [
-      params.rateManagerId,
-      params.newManager,
-      params.newFeeRecipient,
-      params.newName,
-      params.newUri
-    ];
-  }
-  prepareRateManagerRegistryTransaction(opts) {
-    const contract = this.resolveRateManagerRegistryContract(opts.registry);
-    const functionName = this.resolveAbiFunctionName(contract.abi, opts.functionNames);
-    return this.prepareContractTransaction({
-      address: contract.address,
-      abi: contract.abi,
-      functionName,
-      args: opts.args,
-      txOverrides: opts.txOverrides
-    });
-  }
-  prepareCreateRateManagerTransaction(params) {
-    return this.prepareRateManagerRegistryTransaction({
-      functionNames: ["createRateManager"],
-      args: [this.buildCreateRateManagerConfig(params.config)],
-      txOverrides: params.txOverrides
-    });
-  }
-  prepareSetVaultRateTransaction(params) {
-    return this.prepareRateManagerRegistryTransaction({
-      functionNames: ["setRate", "setMinRate"],
-      args: [params.rateManagerId, params.paymentMethodHash, params.currencyHash, params.rate],
-      txOverrides: params.txOverrides
-    });
-  }
-  prepareSetVaultRatesBatchTransaction(params) {
-    return this.prepareRateManagerRegistryTransaction({
-      functionNames: ["setRateBatch", "setMinRatesBatch"],
-      args: [params.rateManagerId, params.paymentMethods, params.currencies, params.rates],
-      txOverrides: params.txOverrides
-    });
-  }
-  prepareSetOracleRateConfigTransaction(params) {
-    const escrowContext = this.resolveEscrowContext({
-      escrowAddress: params.escrowAddress,
-      depositId: params.depositId,
-      preferV2: true
-    });
-    if (escrowContext.version !== "v2") {
-      throw new Error("setOracleRateConfig requires EscrowV2");
-    }
-    const functionName = this.resolveAbiFunctionName(escrowContext.abi, ["setOracleRateConfig"]);
-    return this.prepareEscrowTransaction({
-      functionName,
-      args: [
-        this.parseRawDepositId(params.depositId),
-        params.paymentMethodHash,
-        params.currencyHash,
-        this.normalizeOracleRateConfig(params.config)
-      ],
-      txOverrides: params.txOverrides,
-      escrowAddress: escrowContext.address,
-      escrowAbi: escrowContext.abi
-    });
+    const resolved = escrowAddress ?? this.parseEscrowAddressFromCompositeDepositId(depositId);
+    if (resolved) return resolved;
+    if (options?.preferV2 !== void 0) {
+      return this.resolveEscrowContext({ preferV2: options.preferV2 }).address;
+    }
+    throw new Error(`${methodName} requires escrowAddress or composite depositId`);
+  }
+  prepareCreateRateManagerTransaction(params) {
+    return this._vaultOps.prepareCreateRateManagerTransaction(params);
+  }
+  prepareSetVaultRateTransaction(params) {
+    return this._vaultOps.prepareSetVaultRateTransaction(params);
+  }
+  prepareSetVaultRatesBatchTransaction(params) {
+    return this._vaultOps.prepareSetVaultRatesBatchTransaction(params);
+  }
+  prepareSetOracleRateConfigTransaction(params) {
+    return this._vaultOps.prepareSetOracleRateConfigTransaction(params);
   }
   prepareRemoveOracleRateConfigTransaction(params) {
-    const escrowContext = this.resolveEscrowContext({
-      escrowAddress: params.escrowAddress,
-      depositId: params.depositId,
-      preferV2: true
-    });
-    if (escrowContext.version !== "v2") {
-      throw new Error("removeOracleRateConfig requires EscrowV2");
-    }
-    const functionName = this.resolveAbiFunctionName(escrowContext.abi, ["removeOracleRateConfig"]);
-    return this.prepareEscrowTransaction({
-      functionName,
-      args: [
-        this.parseRawDepositId(params.depositId),
-        params.paymentMethodHash,
-        params.currencyHash
-      ],
-      txOverrides: params.txOverrides,
-      escrowAddress: escrowContext.address,
-      escrowAbi: escrowContext.abi
-    });
+    return this._vaultOps.prepareRemoveOracleRateConfigTransaction(params);
   }
   prepareSetOracleRateConfigBatchTransaction(params) {
-    const escrowContext = this.resolveEscrowContext({
-      escrowAddress: params.escrowAddress,
-      depositId: params.depositId,
-      preferV2: true
-    });
-    if (escrowContext.version !== "v2") {
-      throw new Error("setOracleRateConfigBatch requires EscrowV2");
-    }
-    const functionName = this.resolveAbiFunctionName(escrowContext.abi, [
-      "setOracleRateConfigBatch"
-    ]);
-    return this.prepareEscrowTransaction({
-      functionName,
-      args: [
-        this.parseRawDepositId(params.depositId),
-        params.paymentMethods,
-        params.currencies,
-        params.configs.map(
-          (group) => group.map((config) => this.normalizeOracleRateConfig(config))
-        )
-      ],
-      txOverrides: params.txOverrides,
-      escrowAddress: escrowContext.address,
-      escrowAbi: escrowContext.abi
-    });
+    return this._vaultOps.prepareSetOracleRateConfigBatchTransaction(params);
+  }
+  prepareUpdateCurrencyConfigBatchTransaction(params) {
+    return this._vaultOps.prepareUpdateCurrencyConfigBatchTransaction(params);
+  }
+  prepareDeactivateCurrenciesBatchTransaction(params) {
+    return this._vaultOps.prepareDeactivateCurrenciesBatchTransaction(params);
   }
   prepareSetVaultConfigTransaction(params) {
-    return this.prepareRateManagerRegistryTransaction({
-      functionNames: ["setRateManagerConfig"],
-      args: this.buildSetRateManagerConfigArgs(params),
-      txOverrides: params.txOverrides
-    });
+    return this._vaultOps.prepareSetVaultConfigTransaction(params);
   }
   getEscrowContextByAddress(address) {
     return this._router.getEscrowContextByAddress(address);
@@ -4346,6 +6146,7 @@ var _Zkp2pClient = class _Zkp2pClient {
     }
     const rawDepositId = this.parseRawDepositId(options.depositId);
     const matches = [];
+    const probeErrors = [];
     for (const context of contexts) {
       try {
         const raw = await this.publicClient.readContract({
@@ -4358,7 +6159,8 @@ var _Zkp2pClient = class _Zkp2pClient {
         if (this.isProtocolViewerDepositPopulated(parsed)) {
           matches.push(context);
         }
-      } catch {
+      } catch (error) {
+        probeErrors.push(error);
       }
     }
     if (matches.length === 1) {
@@ -4369,6 +6171,12 @@ var _Zkp2pClient = class _Zkp2pClient {
         `${options?.methodName ?? "Deposit mutation"} is ambiguous for depositId ${rawDepositId.toString()}: found in multiple escrows. Pass escrowAddress or composite depositId.`
       );
     }
+    if (probeErrors.length > 0) {
+      const probeFailureMessage = probeErrors.map((error) => error instanceof Error ? error.message : String(error)).join("; ");
+      throw new Error(
+        `${options?.methodName ?? "Deposit mutation"} could not verify depositId ${rawDepositId.toString()} across configured escrows because one or more escrow probes failed: ${probeFailureMessage}`
+      );
+    }
     return this.resolveEscrowContext(options);
   }
   getEscrowContexts() {
@@ -4400,18 +6208,29 @@ var _Zkp2pClient = class _Zkp2pClient {
       const orchestratorAddress = this.normalizeAddress(intent?.orchestratorAddress ?? void 0);
       const escrowAddress = intent?.depositId && intent.depositId.includes("_") ? this.parseEscrowAddressFromCompositeDepositId(intent.depositId) : void 0;
       return { orchestratorAddress, escrowAddress };
-    } catch {
-      return {};
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown indexer routing error";
+      throw new Error(`Failed to resolve intent routing for ${intentHash}: ${message}`);
     }
   }
   async lookupIntentEscrowOnchain(intentHash) {
     try {
       const view = await this.getPvIntent(intentHash);
       return this.normalizeAddress(view?.intent?.escrow);
-    } catch {
-      return void 0;
+    } catch (error) {
+      if (error instanceof Error && error.message === "Intent not found") {
+        return void 0;
+      }
+      const message = error instanceof Error ? error.message : "Unknown on-chain routing error";
+      throw new Error(`Failed to resolve intent escrow on-chain for ${intentHash}: ${message}`);
     }
   }
+  warnOrchestratorFallback(intentHash, source, error) {
+    const message = error instanceof Error ? error.message : "Unknown routing error";
+    console.warn(
+      `[Zkp2pClient] ${source} failed for ${intentHash}; continuing with configured orchestrator fallback. ${message}`
+    );
+  }
   async resolveOrchestratorContext(options) {
     const explicit = this.getOrchestratorContextByAddress(options?.orchestratorAddress);
     if (explicit) return explicit;
@@ -4434,17 +6253,32 @@ var _Zkp2pClient = class _Zkp2pClient {
       return { address: addr, abi, version };
     }
     if (options?.intentHash) {
-      const routing = await this.lookupIntentRouting(options.intentHash);
-      const fromIntent = this.getOrchestratorContextByAddress(routing.orchestratorAddress);
-      if (fromIntent) return fromIntent;
-      const fromIntentEscrow = this.resolveOrchestratorForEscrow(
-        routing.escrowAddress,
-        options.preferV2
-      );
-      if (fromIntentEscrow) return fromIntentEscrow;
-      const onchainEscrow = await this.lookupIntentEscrowOnchain(options.intentHash);
-      const fromOnchainEscrow = this.resolveOrchestratorForEscrow(onchainEscrow, options.preferV2);
-      if (fromOnchainEscrow) return fromOnchainEscrow;
+      try {
+        const routing = await this.lookupIntentRouting(options.intentHash);
+        const fromIntent = this.getOrchestratorContextByAddress(routing.orchestratorAddress);
+        if (fromIntent) return fromIntent;
+        if (routing.escrowAddress) {
+          const fromIntentEscrow = this.resolveOrchestratorForEscrow(
+            routing.escrowAddress,
+            options.preferV2
+          );
+          if (fromIntentEscrow) return fromIntentEscrow;
+        }
+      } catch (error) {
+        this.warnOrchestratorFallback(options.intentHash, "Indexer intent routing lookup", error);
+      }
+      try {
+        const onchainEscrow = await this.lookupIntentEscrowOnchain(options.intentHash);
+        if (onchainEscrow) {
+          const fromOnchainEscrow = this.resolveOrchestratorForEscrow(
+            onchainEscrow,
+            options.preferV2
+          );
+          if (fromOnchainEscrow) return fromOnchainEscrow;
+        }
+      } catch (error) {
+        this.warnOrchestratorFallback(options.intentHash, "On-chain intent escrow lookup", error);
+      }
     }
     if (options?.escrowAddress) {
       const fromEscrow = this.resolveOrchestratorForEscrow(options.escrowAddress, options.preferV2);
@@ -5103,8 +6937,6 @@ var _Zkp2pClient = class _Zkp2pClient {
    * `createDeposit` to obtain `payeeDetailsHashes`, or use it independently to
    * register maker payment details with the curator service.
    *
-   * Requires `apiKey` or `authorizationToken` to be set.
-   *
    * @param params.processorNames - Payment platforms (e.g., ['wise', 'revolut'])
    * @param params.depositData - Payee details per processor (e.g., [{ email: '...' }])
    * @returns The posted deposit details and their corresponding hashed on-chain IDs
@@ -5125,9 +6957,6 @@ var _Zkp2pClient = class _Zkp2pClient {
     if (params.processorNames.length !== params.depositData.length) {
       throw new Error("processorNames and depositData length mismatch");
     }
-    if (!this.apiKey && !this.authorizationToken) {
-      throw new Error("registerPayeeDetails requires apiKey or authorizationToken");
-    }
     const baseApiUrl = (this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
     const depositDetails = params.processorNames.map(
       (processorName, index) => ({
@@ -5268,7 +7097,7 @@ var _Zkp2pClient = class _Zkp2pClient {
           throw new Error("payeeDetailsHashes length must match processorNames length");
         }
         hashedOnchainIds = params.payeeDetailsHashes;
-      } else if (this.apiKey || this.authorizationToken) {
+      } else {
         const baseApiUrl = (this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(/\/$/, "");
         const apiResponses = await Promise.all(
           depositDetails.map(
@@ -5288,10 +7117,6 @@ var _Zkp2pClient = class _Zkp2pClient {
         hashedOnchainIds = apiResponses.map(
           (r) => r.responseObject?.hashedOnchainId
         );
-      } else {
-        throw new Error(
-          "createDeposit requires either payeeDetailsHashes (from registerPayeeDetails) or apiKey/authorizationToken"
-        );
       }
       paymentMethodData = hashedOnchainIds.map((hid) => ({
         intentGatingService,
@@ -5312,7 +7137,7 @@ var _Zkp2pClient = class _Zkp2pClient {
           }
         }
       });
-      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-5RZ6VCEA.mjs');
+      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-PKI2EGJD.mjs');
       const normalized = params.conversionRates.map(
         (group) => group.map((r) => ({ currency: r.currency, conversionRate: r.conversionRate }))
       );
@@ -5351,415 +7176,66 @@ var _Zkp2pClient = class _Zkp2pClient {
    * Read controller delegation state for a deposit.
    */
   async getDepositRateManager(escrow, depositId) {
-    const id = this.parseRawDepositId(depositId);
-    const escrowContext = this.resolveEscrowContext({ escrowAddress: escrow, depositId });
-    try {
-      const result = await this.publicClient.readContract({
-        address: escrowContext.address,
-        abi: escrowContext.abi,
-        functionName: "getDepositRateManager",
-        args: [id]
-      });
-      if (result && result.length >= 2) {
-        return {
-          registry: result[0],
-          rateManagerId: result[1]
-        };
-      }
-    } catch {
-    }
-    if (!this.rateManagerControllerAddress || !this.rateManagerControllerAbi) {
-      throw new Error("Rate manager controller not available");
-    }
-    const legacyResult = await this.publicClient.readContract({
-      address: this.rateManagerControllerAddress,
-      abi: this.rateManagerControllerAbi,
-      functionName: "getDepositRateManager",
-      args: [escrow, id]
-    });
-    return {
-      registry: legacyResult[0],
-      rateManagerId: legacyResult[1]
-    };
+    return this._vaultOps.getDepositRateManager(escrow, depositId);
   }
   /**
    * Read effective manager fee for a deposit.
-   */
-  async getManagerFee(escrow, depositId) {
-    const id = this.parseRawDepositId(depositId);
-    const escrowContext = this.resolveEscrowContext({ escrowAddress: escrow, depositId });
-    try {
-      const result = await this.publicClient.readContract({
-        address: escrowContext.address,
-        abi: escrowContext.abi,
-        functionName: "getManagerFee",
-        args: [id]
-      });
-      return this.parseManagerFeeFromRead(result);
-    } catch {
-      if (!this.rateManagerControllerAddress || !this.rateManagerControllerAbi) {
-        throw new Error("Rate manager controller not available");
-      }
-      const result = await this.publicClient.readContract({
-        address: this.rateManagerControllerAddress,
-        abi: this.rateManagerControllerAbi,
-        functionName: "getManagerFee",
-        args: [escrow, id]
-      });
-      return this.parseManagerFeeFromRead(result);
-    }
-  }
-  /**
-   * Read the effective conversion rate on EscrowV2.
-   */
-  async getEffectiveRate(params) {
-    const escrowContext = this.resolveEscrowContext({
-      escrowAddress: params.escrow,
-      depositId: params.depositId
-    });
-    const id = this.parseRawDepositId(params.depositId);
-    return await this.publicClient.readContract({
-      address: escrowContext.address,
-      abi: escrowContext.abi,
-      functionName: "getEffectiveRate",
-      args: [id, params.paymentMethod, params.fiatCurrency]
-    });
-  }
-  /**
-   * Prepare signalIntent transaction (all logic except simulation/send).
-   * Returns the prepared transaction with encoded calldata.
-   */
-  async prepareSignalIntent(params) {
-    const escrowContext = this.resolveEscrowContext({
-      escrowAddress: params.escrowAddress,
-      depositId: params.depositId,
-      preferV2: this._router.defaultPreferV2
-    });
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      escrowAddress: escrowContext.address,
-      preferV2: this._router.defaultPreferV2
-    });
-    const catalog = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
-    const paymentMethod = resolvePaymentMethodHashFromCatalog(params.processorName, catalog);
-    const fiatCurrency = resolveFiatCurrencyBytes32(params.fiatCurrencyCode);
-    const depositId = this.parseRawDepositId(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;
-    let preIntentHookData = params.preIntentHookData;
-    if ((!gatingServiceSignature || !signatureExpiration) && this.baseApiUrl && (this.apiKey || this.authorizationToken)) {
-      const baseRequest = {
-        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: orchestratorContext.address,
-        escrowAddress: escrowContext.address
-      };
-      const apiOpts = {
-        baseApiUrl: this.baseApiUrl,
-        apiKey: this.apiKey,
-        authorizationToken: this.authorizationToken,
-        timeoutMs: this.apiTimeoutMs
-      };
-      const resp = orchestratorContext.version === "v2" ? await apiSignIntentV3(
-        {
-          ...baseRequest,
-          callerAddress: this.walletClient.account.address,
-          referrer: params.referrer ?? "0x0000000000000000000000000000000000000000",
-          referrerFee: referrerFee.toString()
-        },
-        apiOpts
-      ) : await apiSignIntentV2(baseRequest, apiOpts);
-      gatingServiceSignature = resp.signature;
-      signatureExpiration = resp.signatureExpiration;
-      preIntentHookData = resp.preIntentHookData ?? preIntentHookData;
-    }
-    if (!gatingServiceSignature || !signatureExpiration)
-      throw new Error("Missing gatingServiceSignature/signatureExpiration");
-    const args = [
-      {
-        escrow: escrowContext.address,
-        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",
-        preIntentHookData: preIntentHookData ?? "0x",
-        data: params.data ?? "0x"
-      }
-    ];
-    const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
-      {
-        abi: orchestratorContext.abi,
-        functionName: "signalIntent",
-        args
-      },
-      referrer
-    );
-    return {
-      to: orchestratorContext.address,
-      data,
-      value: 0n,
-      chainId: this.chainId,
-      abi: orchestratorContext.abi,
-      functionName: "signalIntent",
-      args
-    };
-  }
-  /**
-   * Prepare cancelIntent transaction (all logic except simulation/send).
-   */
-  async prepareCancelIntent(params) {
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      intentHash: params.intentHash,
-      preferV2: this._router.defaultPreferV2
-    });
-    const args = [params.intentHash];
-    const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
-      {
-        abi: orchestratorContext.abi,
-        functionName: "cancelIntent",
-        args
-      },
-      referrer
-    );
-    return {
-      to: orchestratorContext.address,
-      data,
-      value: 0n,
-      chainId: this.chainId,
-      abi: orchestratorContext.abi,
-      functionName: "cancelIntent",
-      args
-    };
-  }
-  async prepareReleaseFundsToPayer(params) {
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      intentHash: params.intentHash,
-      preferV2: this._router.defaultPreferV2
-    });
-    const args = [params.intentHash];
-    const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
-      {
-        abi: orchestratorContext.abi,
-        functionName: "releaseFundsToPayer",
-        args
-      },
-      referrer
-    );
-    return {
-      to: orchestratorContext.address,
-      data,
-      value: 0n,
-      chainId: this.chainId,
-      abi: orchestratorContext.abi,
-      functionName: "releaseFundsToPayer",
-      args
-    };
+   */
+  async getManagerFee(escrow, depositId) {
+    return this._vaultOps.getManagerFee(escrow, depositId);
+  }
+  /**
+   * Read the effective conversion rate on EscrowV2.
+   */
+  async getEffectiveRate(params) {
+    return this._vaultOps.getEffectiveRate(params);
+  }
+  /**
+   * Prepare signalIntent transaction (all logic except simulation/send).
+   * Returns the prepared transaction with encoded calldata.
+   */
+  async prepareSignalIntent(params) {
+    return this._intentOps.prepareSignalIntent(params);
+  }
+  /**
+   * Prepare cancelIntent transaction (all logic except simulation/send).
+   */
+  async prepareCancelIntent(params) {
+    return this._intentOps.prepareCancelIntent(params);
+  }
+  async prepareReleaseFundsToPayer(params) {
+    return this._intentOps.prepareReleaseFundsToPayer(params);
   }
   async prepareSetDepositPreIntentHook(params) {
-    const escrowAddress = this.resolveEscrowAddressOrThrow(
-      params.escrowAddress,
-      params.depositId,
-      "setDepositPreIntentHook",
-      { preferV2: this._router.defaultPreferV2 }
-    );
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      escrowAddress,
-      preferV2: this._router.defaultPreferV2
-    });
-    return this.prepareResolvedOrchestratorTransaction({
-      orchestrator: orchestratorContext,
-      functionNames: ["setDepositPreIntentHook"],
-      args: [escrowAddress, this.parseRawDepositId(params.depositId), params.preIntentHook],
-      txOverrides: params.txOverrides
-    });
+    return this._intentOps.prepareSetDepositPreIntentHook(params);
   }
   async prepareSetDepositWhitelistHook(params) {
-    const escrowAddress = this.resolveEscrowAddressOrThrow(
-      params.escrowAddress,
-      params.depositId,
-      "setDepositWhitelistHook",
-      { preferV2: this._router.defaultPreferV2 }
-    );
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      escrowAddress,
-      preferV2: this._router.defaultPreferV2
-    });
-    return this.prepareResolvedOrchestratorTransaction({
-      orchestrator: orchestratorContext,
-      functionNames: ["setDepositWhitelistHook"],
-      args: [escrowAddress, this.parseRawDepositId(params.depositId), params.whitelistHook],
-      txOverrides: params.txOverrides
-    });
+    return this._intentOps.prepareSetDepositWhitelistHook(params);
   }
   async prepareCleanupOrphanedIntents(params) {
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      escrowAddress: params.escrowAddress,
-      preferV2: this._router.defaultPreferV2
-    });
-    return this.prepareResolvedOrchestratorTransaction({
-      orchestrator: orchestratorContext,
-      functionNames: ["cleanupOrphanedIntents"],
-      args: [params.intentHashes],
-      txOverrides: params.txOverrides
-    });
+    return this._intentOps.prepareCleanupOrphanedIntents(params);
   }
   /**
    * Read configured pre-intent hook for a deposit from OrchestratorV2.
    */
   async getDepositPreIntentHook(depositId, options) {
-    const escrowAddress = this.resolveEscrowAddressOrThrow(
-      options?.escrowAddress,
-      depositId,
-      "getDepositPreIntentHook",
-      { preferV2: this._router.defaultPreferV2 }
-    );
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: options?.orchestratorAddress,
-      escrowAddress,
-      preferV2: this._router.defaultPreferV2
-    });
-    const functionName = this.resolveAbiFunctionName(orchestratorContext.abi, [
-      "getDepositPreIntentHook"
-    ]);
-    const result = await this.publicClient.readContract({
-      address: orchestratorContext.address,
-      abi: orchestratorContext.abi,
-      functionName,
-      args: [escrowAddress, this.parseRawDepositId(depositId)]
-    });
-    return result;
+    return this._intentOps.getDepositPreIntentHook(depositId, options);
   }
   /**
    * Read configured whitelist hook for a deposit from OrchestratorV2.
    */
   async getDepositWhitelistHook(depositId, options) {
-    const escrowAddress = this.resolveEscrowAddressOrThrow(
-      options?.escrowAddress,
-      depositId,
-      "getDepositWhitelistHook",
-      { preferV2: this._router.defaultPreferV2 }
-    );
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: options?.orchestratorAddress,
-      escrowAddress,
-      preferV2: this._router.defaultPreferV2
-    });
-    const functionName = this.resolveAbiFunctionName(orchestratorContext.abi, [
-      "getDepositWhitelistHook"
-    ]);
-    const result = await this.publicClient.readContract({
-      address: orchestratorContext.address,
-      abi: orchestratorContext.abi,
-      functionName,
-      args: [escrowAddress, this.parseRawDepositId(depositId)]
-    });
-    return result;
+    return this._intentOps.getDepositWhitelistHook(depositId, options);
   }
   /**
    * Prepare fulfillIntent transaction (all logic except simulation/send).
    * Includes fetching intent inputs and calling attestation service.
    */
   async prepareFulfillIntent(params) {
-    const intentHash = params.intentHash;
-    const orchestratorContext = await this.resolveOrchestratorContext({
-      orchestratorAddress: params.orchestratorAddress,
-      intentHash,
-      preferV2: this._router.defaultPreferV2
-    });
-    const attUrl = params.attestationServiceUrl ?? this.defaultAttestationService();
-    const inputs = await this.getFulfillIntentInputs(intentHash);
-    const paymentMethodHash = inputs.paymentMethodHash || "0x";
-    const amount = inputs.amount;
-    const fiatCurrency = inputs.fiatCurrency;
-    const conversionRate = inputs.conversionRate;
-    const payeeDetails = inputs.payeeDetails;
-    const timestampMs = inputs.intentTimestampMs;
-    const timestampBufferMs = params.timestampBufferMs ?? "300000";
-    const catalog = getPaymentMethodsCatalog(this.chainId, this.runtimeEnv);
-    const { resolvePaymentMethodNameFromHash: resolvePaymentMethodNameFromHash2 } = await import('./paymentResolution-3TC4HRHU.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-YK56UVLH.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,
-      intent: {
-        intentHash,
-        amount,
-        timestampMs,
-        paymentMethod: paymentMethodHash,
-        fiatCurrency,
-        conversionRate,
-        payeeDetails,
-        timestampBufferMs
-      }
-    };
-    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 { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
-      {
-        abi: orchestratorContext.abi,
-        functionName: "fulfillIntent",
-        args
-      },
-      referrer
-    );
-    return {
-      to: orchestratorContext.address,
-      data,
-      value: 0n,
-      chainId: this.chainId,
-      abi: orchestratorContext.abi,
-      functionName: "fulfillIntent",
-      args
-    };
+    return this._intentOps.prepareFulfillIntent(params);
   }
   defaultAttestationService() {
-    return this.runtimeEnv === "staging" ? "https://attestation-service-staging.zkp2p.xyz" : "https://attestation-service.zkp2p.xyz";
+    return this._intentOps.defaultAttestationService();
   }
   // ───────────────────────────────────────────────────────────────────────────
   // SUPPORTING: QUOTES API
@@ -5807,6 +7283,7 @@ var _Zkp2pClient = class _Zkp2pClient {
    * ```
    */
   async getQuote(req, opts) {
+    const referrerFeeConfig = assertValidReferrerFeeConfig(req.referrerFeeConfig, "getQuote");
     const baseApiUrl = (opts?.baseApiUrl ?? this.baseApiUrl ?? "https://api.zkp2p.xyz").replace(
       /\/$/,
       ""
@@ -5833,7 +7310,7 @@ var _Zkp2pClient = class _Zkp2pClient {
         q.payeeData = maker.depositData;
       }
     }
-    return quote;
+    return appendReferrerFeeDisplayFields(quote, referrerFeeConfig);
   }
   // ───────────────────────────────────────────────────────────────────────────
   // SUPPORTING: TAKER TIER
@@ -5842,8 +7319,6 @@ var _Zkp2pClient = class _Zkp2pClient {
   /**
    * **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
@@ -5856,249 +7331,57 @@ var _Zkp2pClient = class _Zkp2pClient {
       ""
     );
     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);
+    return apiGetTakerTier(req, this.apiKey, baseApiUrl, 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 };
+    return this._pvReader.requireProtocolViewer();
   }
   protocolViewerFunctionInputCount(functionName) {
-    const fn = this.getAbiFunction(this.protocolViewerAbi, functionName);
-    if (!fn) return null;
-    const inputs = fn.inputs ?? [];
-    return inputs.length;
+    return this._pvReader.protocolViewerFunctionInputCount(functionName);
   }
   /**
    * Returns the input count for a function on a specific PV entry's ABI.
    * Used to branch between 1-input (V1) and 2-input (V2) PV call signatures.
    */
   pvEntryFunctionInputCount(entry, functionName) {
-    const fn = this.getAbiFunction(entry.abi, functionName);
-    if (!fn) return null;
-    const inputs = fn.inputs ?? [];
-    return inputs.length;
+    return this._pvReader.pvEntryFunctionInputCount(entry, functionName);
   }
   isZeroAddressValue(value) {
-    return !value || value.toLowerCase() === ZERO_ADDRESS2.toLowerCase();
+    return this._pvReader.isZeroAddressValue(value);
   }
-  toBigIntOrZero(value) {
-    if (value === null || value === void 0) return 0n;
-    try {
-      return parseBigIntLike(value);
-    } catch {
-      return 0n;
-    }
+  toBigIntOrZero(value, fieldName = "numeric field") {
+    return this._pvReader.toBigIntOrZero(value, fieldName);
   }
   buildProtocolViewerContexts(options) {
-    return this._router.buildProtocolViewerContexts(options);
+    return this._pvReader.buildProtocolViewerContexts(options);
   }
   isProtocolViewerDepositPopulated(view) {
-    return !this.isZeroAddressValue(view.deposit?.depositor);
+    return this._pvReader.isProtocolViewerDepositPopulated(view);
   }
   isProtocolViewerIntentPopulated(view) {
-    return !this.isZeroAddressValue(view.intent?.owner);
-  }
-  buildDepositViewFromEscrowDeposit(rawDeposit, depositId) {
-    const deposit = rawDeposit ?? {};
-    const remaining = this.toBigIntOrZero(
-      deposit.remainingDeposits ?? deposit.remainingDepositAmount
-    );
-    const outstanding = this.toBigIntOrZero(deposit.outstandingIntentAmount);
-    const amount = this.toBigIntOrZero(deposit.amount) || remaining + outstanding;
-    return {
-      depositId,
-      deposit: {
-        depositor: this.normalizeAddress(deposit.depositor) ?? ZERO_ADDRESS2,
-        delegate: this.normalizeAddress(deposit.delegate) ?? ZERO_ADDRESS2,
-        token: this.normalizeAddress(deposit.token) ?? ZERO_ADDRESS2,
-        amount,
-        intentAmountRange: {
-          min: this.toBigIntOrZero(
-            deposit.intentAmountRange?.min
-          ),
-          max: this.toBigIntOrZero(
-            deposit.intentAmountRange?.max
-          )
-        },
-        acceptingIntents: Boolean(deposit.acceptingIntents),
-        remainingDeposits: remaining,
-        outstandingIntentAmount: outstanding,
-        makerProtocolFee: this.toBigIntOrZero(deposit.makerProtocolFee),
-        reservedMakerFees: this.toBigIntOrZero(deposit.reservedMakerFees),
-        accruedMakerFees: this.toBigIntOrZero(deposit.accruedMakerFees),
-        accruedReferrerFees: this.toBigIntOrZero(deposit.accruedReferrerFees),
-        intentGuardian: this.normalizeAddress(deposit.intentGuardian) ?? ZERO_ADDRESS2,
-        referrer: this.normalizeAddress(deposit.referrer) ?? ZERO_ADDRESS2,
-        referrerFee: this.toBigIntOrZero(deposit.referrerFee)
-      },
-      availableLiquidity: remaining,
-      paymentMethods: [],
-      intentHashes: []
-    };
-  }
-  convertIndexerDepositToPvView(deposit) {
-    const paymentMethods = (deposit.paymentMethods ?? []).filter(
-      (pm) => pm.active !== false
-    );
-    const currenciesByPaymentMethod = /* @__PURE__ */ new Map();
-    for (const currency of deposit.currencies ?? []) {
-      const key = currency.paymentMethodHash.toLowerCase();
-      const existing = currenciesByPaymentMethod.get(key) ?? [];
-      existing.push(currency);
-      currenciesByPaymentMethod.set(key, existing);
-    }
-    const remaining = this.toBigIntOrZero(deposit.remainingDeposits);
-    const outstanding = this.toBigIntOrZero(deposit.outstandingIntentAmount);
-    const totalAmountTaken = this.toBigIntOrZero(deposit.totalAmountTaken);
-    const totalWithdrawn = this.toBigIntOrZero(deposit.totalWithdrawn);
-    const depositAmount = remaining + outstanding + totalAmountTaken + totalWithdrawn;
-    return {
-      depositId: this.toBigIntOrZero(deposit.depositId),
-      deposit: {
-        depositor: this.normalizeAddress(deposit.depositor) ?? ZERO_ADDRESS2,
-        delegate: this.normalizeAddress(deposit.delegate ?? void 0) ?? ZERO_ADDRESS2,
-        token: this.normalizeAddress(deposit.token) ?? ZERO_ADDRESS2,
-        amount: depositAmount,
-        intentAmountRange: {
-          min: this.toBigIntOrZero(deposit.intentAmountMin),
-          max: this.toBigIntOrZero(deposit.intentAmountMax)
-        },
-        acceptingIntents: Boolean(deposit.acceptingIntents),
-        remainingDeposits: remaining,
-        outstandingIntentAmount: outstanding,
-        makerProtocolFee: 0n,
-        reservedMakerFees: 0n,
-        accruedMakerFees: 0n,
-        accruedReferrerFees: 0n,
-        intentGuardian: ZERO_ADDRESS2,
-        referrer: ZERO_ADDRESS2,
-        referrerFee: 0n
-      },
-      availableLiquidity: remaining,
-      paymentMethods: paymentMethods.map((method) => ({
-        paymentMethod: method.paymentMethodHash,
-        verificationData: {
-          intentGatingService: this.normalizeAddress(method.intentGatingService) ?? ZERO_ADDRESS2,
-          payeeDetails: method.payeeDetailsHash || "0x",
-          data: "0x"
-        },
-        currencies: (currenciesByPaymentMethod.get(method.paymentMethodHash.toLowerCase()) ?? []).map((currency) => ({
-          code: currency.currencyCode,
-          minConversionRate: this.toBigIntOrZero(
-            currency.conversionRate ?? currency.minConversionRate
-          )
-        }))
-      })),
-      intentHashes: Array.from(new Set((deposit.intents ?? []).map((intent) => intent.intentHash)))
-    };
-  }
-  async getPvAccountDepositsFromIndexer(owner) {
-    const filter = { depositor: owner, status: "ACTIVE" };
-    if (this.escrowAddresses.length > 0) {
-      filter.escrowAddresses = this.escrowAddresses.map((escrow) => escrow);
-    }
-    const deposits = await this._indexerService.fetchDepositsWithRelations(
-      filter,
-      { limit: 1e3, orderBy: "timestamp", orderDirection: "desc" },
-      { includeIntents: true }
-    );
-    return deposits.map((deposit) => this.convertIndexerDepositToPvView(deposit));
+    return this._pvReader.isProtocolViewerIntentPopulated(view);
   }
-  /**
-   * 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 : this.parseRawDepositId(depositId);
-    const hintedEscrow = typeof depositId === "string" ? this.parseEscrowAddressFromCompositeDepositId(depositId) : void 0;
-    try {
-      const { address, abi } = this.requireProtocolViewer();
-      const inputCount = this.protocolViewerFunctionInputCount("getDeposit");
-      if (inputCount === null) {
-        throw new Error("Configured ProtocolViewer ABI does not expose getDeposit");
-      }
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EUBHHIPL.mjs');
-      if (inputCount >= 3) {
-        for (const context of this.buildProtocolViewerContexts({ escrowAddress: hintedEscrow })) {
-          const raw2 = await this.publicClient.readContract({
-            address,
-            abi,
-            functionName: "getDeposit",
-            args: [context.escrow, context.orchestrator, id]
-          });
-          const parsed2 = parseDepositView2(raw2);
-          if (this.isProtocolViewerDepositPopulated(parsed2)) {
-            return parsed2;
-          }
-        }
-        throw new Error("Deposit not found in configured ProtocolViewer contexts");
-      }
-      if (inputCount >= 2) {
-        for (const context of this.buildProtocolViewerContexts({ escrowAddress: hintedEscrow })) {
-          const raw2 = await this.publicClient.readContract({
-            address,
-            abi,
-            functionName: "getDeposit",
-            args: [context.escrow, id]
-          });
-          const parsed2 = parseDepositView2(raw2);
-          if (this.isProtocolViewerDepositPopulated(parsed2)) {
-            return parsed2;
-          }
-        }
-        throw new Error("Deposit not found in configured ProtocolViewer escrows");
-      }
-      const raw = await this.publicClient.readContract({
-        address,
-        abi,
-        functionName: "getDeposit",
-        args: [id]
-      });
-      const parsed = parseDepositView2(raw);
-      if (this.isProtocolViewerDepositPopulated(parsed)) {
-        return parsed;
-      }
-      throw new Error("Deposit not found");
-    } catch {
-      let lastError;
-      const contexts = this.getEscrowContexts();
-      if (hintedEscrow) {
-        contexts.sort((left, right) => {
-          const leftMatch = left.address.toLowerCase() === hintedEscrow.toLowerCase() ? 1 : 0;
-          const rightMatch = right.address.toLowerCase() === hintedEscrow.toLowerCase() ? 1 : 0;
-          return rightMatch - leftMatch;
-        });
-      }
-      for (const context of contexts) {
-        try {
-          const raw = await this.publicClient.readContract({
-            address: context.address,
-            abi: context.abi,
-            functionName: "getDeposit",
-            args: [id]
-          });
-          const parsed = this.buildDepositViewFromEscrowDeposit(raw, id);
-          if (this.isProtocolViewerDepositPopulated(parsed)) {
-            return parsed;
-          }
-          lastError = new Error(`Deposit ${id.toString()} not found in escrow ${context.address}`);
-        } catch (readError) {
-          lastError = readError;
-        }
-      }
-      throw lastError ?? new Error("Failed to fetch deposit from configured escrows");
-    }
+  buildDepositViewFromEscrowDeposit(rawDeposit, depositId) {
+    return this._pvReader.buildDepositViewFromEscrowDeposit(rawDeposit, depositId);
+  }
+  convertIndexerDepositToPvView(deposit) {
+    return this._pvReader.convertIndexerDepositToPvView(deposit);
+  }
+  async getPvAccountDepositsFromIndexer(owner) {
+    return this._pvReader.getPvAccountDepositsFromIndexer(owner);
+  }
+  /**
+   * 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, options) {
+    return this._pvReader.getPvDepositById(depositId, options);
   }
   /**
    * Fetches multiple deposits by ID from on-chain in a batch call.
@@ -6107,98 +7390,7 @@ var _Zkp2pClient = class _Zkp2pClient {
    * @returns Array of parsed deposit views
    */
   async getPvDepositsFromIds(ids) {
-    if (!ids.length) return [];
-    const inputCount = this.protocolViewerFunctionInputCount("getDepositFromIds");
-    if (!this.protocolViewerAddress || !this.protocolViewerAbi || inputCount === null || inputCount >= 3) {
-      return Promise.all(ids.map((id) => this.getPvDepositById(id)));
-    }
-    const bn = ids.map((id) => typeof id === "bigint" ? id : this.parseRawDepositId(id));
-    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EUBHHIPL.mjs');
-    if (inputCount >= 2) {
-      const requests = ids.map((id, index) => ({
-        index,
-        id,
-        rawId: bn[index],
-        hintedEscrow: typeof id === "string" ? this.parseEscrowAddressFromCompositeDepositId(id) : void 0
-      }));
-      const resolved = new Array(requests.length);
-      const resolveBatch = async (escrow, entries) => {
-        if (!entries.length) return;
-        try {
-          const raw2 = await this.publicClient.readContract({
-            address: this.protocolViewerAddress,
-            abi: this.protocolViewerAbi,
-            functionName: "getDepositFromIds",
-            args: [escrow, entries.map((entry) => entry.rawId)]
-          });
-          const items = Array.isArray(raw2) ? raw2 : [];
-          if (items.length === entries.length) {
-            for (let index = 0; index < entries.length; index++) {
-              const entry = entries[index];
-              if (!entry || resolved[entry.index]) continue;
-              const parsed = parseDepositView2(items[index]);
-              if (this.isProtocolViewerDepositPopulated(parsed)) {
-                resolved[entry.index] = parsed;
-              }
-            }
-            return;
-          }
-          for (const item of items) {
-            const parsed = parseDepositView2(item);
-            if (!this.isProtocolViewerDepositPopulated(parsed)) continue;
-            const match = entries.find(
-              (entry) => !resolved[entry.index] && entry.rawId === parsed.depositId
-            );
-            if (match) {
-              resolved[match.index] = parsed;
-            }
-          }
-        } catch {
-        }
-      };
-      const hintedGroups = /* @__PURE__ */ new Map();
-      for (const request of requests) {
-        if (!request.hintedEscrow) continue;
-        const key = request.hintedEscrow.toLowerCase();
-        const group = hintedGroups.get(key);
-        if (group) {
-          group.entries.push(request);
-        } else {
-          hintedGroups.set(key, { escrow: request.hintedEscrow, entries: [request] });
-        }
-      }
-      for (const { escrow, entries } of hintedGroups.values()) {
-        await resolveBatch(escrow, entries);
-      }
-      const escrows = [];
-      const seenEscrows = /* @__PURE__ */ new Set();
-      for (const context of this.buildProtocolViewerContexts()) {
-        const key = context.escrow.toLowerCase();
-        if (seenEscrows.has(key)) continue;
-        seenEscrows.add(key);
-        escrows.push(context.escrow);
-      }
-      for (const escrow of escrows) {
-        const pending = requests.filter(
-          (entry) => !entry.hintedEscrow && resolved[entry.index] === void 0
-        );
-        if (!pending.length) break;
-        await resolveBatch(escrow, pending);
-      }
-      if (resolved.every((view) => Boolean(view))) {
-        return resolved;
-      }
-      return Promise.all(
-        requests.map((entry) => resolved[entry.index] ?? this.getPvDepositById(entry.id))
-      );
-    }
-    const raw = await this.publicClient.readContract({
-      address: this.protocolViewerAddress,
-      abi: this.protocolViewerAbi,
-      functionName: "getDepositFromIds",
-      args: [bn]
-    });
-    return raw.map(parseDepositView2);
+    return this._pvReader.getPvDepositsFromIds(ids);
   }
   /**
    * Fetches all deposits owned by an address from on-chain.
@@ -6207,41 +7399,7 @@ var _Zkp2pClient = class _Zkp2pClient {
    * @returns Array of parsed deposit views
    */
   async getPvAccountDeposits(owner) {
-    const inputCount = this.protocolViewerFunctionInputCount("getAccountDeposits");
-    if (!this.protocolViewerAddress || !this.protocolViewerAbi || inputCount === null) {
-      return this.getPvAccountDepositsFromIndexer(owner);
-    }
-    try {
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-EUBHHIPL.mjs');
-      const { address, abi } = this.requireProtocolViewer();
-      if (inputCount >= 3) {
-        const merged = [];
-        for (const context of this.buildProtocolViewerContexts()) {
-          const raw2 = await this.publicClient.readContract({
-            address,
-            abi,
-            functionName: "getAccountDeposits",
-            args: [context.escrow, context.orchestrator, owner]
-          });
-          for (const item of raw2) {
-            const parsed = parseDepositView2(item);
-            if (this.isProtocolViewerDepositPopulated(parsed)) {
-              merged.push(parsed);
-            }
-          }
-        }
-        return merged;
-      }
-      const raw = await this.publicClient.readContract({
-        address,
-        abi,
-        functionName: "getAccountDeposits",
-        args: [owner]
-      });
-      return raw.map(parseDepositView2).filter((view) => this.isProtocolViewerDepositPopulated(view));
-    } catch {
-      return this.getPvAccountDepositsFromIndexer(owner);
-    }
+    return this._pvReader.getPvAccountDeposits(owner);
   }
   /**
    * Fetches all intents created by an address from on-chain.
@@ -6252,57 +7410,7 @@ var _Zkp2pClient = class _Zkp2pClient {
    * @returns Array of parsed intent views (deduplicated by intentHash)
    */
   async getPvAccountIntents(owner) {
-    if (this._protocolViewerEntries.length === 0) {
-      throw new Error("ProtocolViewer not available for this network");
-    }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-EUBHHIPL.mjs');
-    const intentsByHash = /* @__PURE__ */ new Map();
-    for (const pvEntry of this._protocolViewerEntries) {
-      const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getAccountIntents");
-      if (inputCount === null) continue;
-      if (inputCount >= 2) {
-        for (const context of this.buildProtocolViewerContexts()) {
-          try {
-            const args = inputCount >= 3 ? [context.escrow, context.orchestrator, owner] : [context.orchestrator, owner];
-            const raw = await this.publicClient.readContract({
-              address: pvEntry.address,
-              abi: pvEntry.abi,
-              functionName: "getAccountIntents",
-              args
-            });
-            for (const item of raw) {
-              const parsed = parseIntentView2(item);
-              if (!this.isProtocolViewerIntentPopulated(parsed)) continue;
-              intentsByHash.set(parsed.intentHash.toLowerCase(), parsed);
-            }
-          } catch {
-          }
-        }
-      } else {
-        try {
-          const raw = await this.publicClient.readContract({
-            address: pvEntry.address,
-            abi: pvEntry.abi,
-            functionName: "getAccountIntents",
-            args: [owner]
-          });
-          for (const item of raw) {
-            const parsed = parseIntentView2(item);
-            if (!this.isProtocolViewerIntentPopulated(parsed)) continue;
-            if (!intentsByHash.has(parsed.intentHash.toLowerCase())) {
-              intentsByHash.set(parsed.intentHash.toLowerCase(), parsed);
-            }
-          }
-        } catch {
-        }
-      }
-    }
-    return Array.from(intentsByHash.values()).sort((a, b) => {
-      if (a.intent.timestamp === b.intent.timestamp) {
-        return a.intentHash.localeCompare(b.intentHash);
-      }
-      return a.intent.timestamp < b.intent.timestamp ? -1 : 1;
-    });
+    return this._pvReader.getPvAccountIntents(owner);
   }
   /**
    * Fetches a single intent by hash from on-chain.
@@ -6312,56 +7420,7 @@ var _Zkp2pClient = class _Zkp2pClient {
    * @returns Parsed intent view with deposit context
    */
   async getPvIntent(intentHash) {
-    if (this._protocolViewerEntries.length === 0) {
-      throw new Error("ProtocolViewer not available for this network");
-    }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-EUBHHIPL.mjs');
-    let lastError;
-    for (const pvEntry of this._protocolViewerEntries) {
-      const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
-      if (inputCount === null) continue;
-      if (inputCount >= 2) {
-        const routing = await this.lookupIntentRouting(intentHash);
-        for (const context of this.buildProtocolViewerContexts({
-          escrowAddress: routing.escrowAddress,
-          orchestratorAddress: routing.orchestratorAddress
-        })) {
-          try {
-            const args = inputCount >= 3 ? [context.escrow, context.orchestrator, intentHash] : [context.orchestrator, intentHash];
-            const raw = await this.publicClient.readContract({
-              address: pvEntry.address,
-              abi: pvEntry.abi,
-              functionName: "getIntent",
-              args
-            });
-            const parsed = parseIntentView2(raw);
-            if (this.isProtocolViewerIntentPopulated(parsed)) {
-              return parsed;
-            }
-            lastError = new Error("Intent not found");
-          } catch (readError) {
-            lastError = readError;
-          }
-        }
-      } else {
-        try {
-          const raw = await this.publicClient.readContract({
-            address: pvEntry.address,
-            abi: pvEntry.abi,
-            functionName: "getIntent",
-            args: [intentHash]
-          });
-          const parsed = parseIntentView2(raw);
-          if (this.isProtocolViewerIntentPopulated(parsed)) {
-            return parsed;
-          }
-          lastError = new Error("Intent not found");
-        } catch (readError) {
-          lastError = readError;
-        }
-      }
-    }
-    throw lastError ?? new Error("Intent not found");
+    return this._pvReader.getPvIntent(intentHash);
   }
   // ╔═══════════════════════════════════════════════════════════════════════════╗
   // ║ CORE: UTILITIES                                                          ║
@@ -6409,80 +7468,9 @@ var _Zkp2pClient = class _Zkp2pClient {
    * @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
-          verifier
-        }
-      }
-    `
-    );
-    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",
-      paymentVerifier: rec.verifier || void 0
-    };
+    return this._intentOps.getFulfillIntentInputs(intentHash);
   }
 };
-_Zkp2pClient.EMPTY_ORACLE_RATE_CONFIG = {
-  adapter: ZERO_ADDRESS2,
-  adapterConfig: "0x",
-  spreadBps: 0,
-  maxStaleness: 0
-};
-var Zkp2pClient = _Zkp2pClient;
 
 // src/extension.ts
 var PEER_EXTENSION_CHROME_URL = "https://chromewebstore.google.com/detail/peerauth-authenticate-and/ijpgccednehjpeclfcllnjjcmiohdjih";
@@ -6660,7 +7648,6 @@ var buildOnrampQueryString = (params) => {
     "recipientAddress",
     normalizeOptionalString(validated.recipientAddress, "recipientAddress")
   );
-  setParam("callbackUrl", normalizeOptionalUrl(validated.callbackUrl, "callbackUrl"));
   setParam("intentHash", normalizeIntentHash(validated.intentHash));
   return searchParams.toString();
 };
@@ -6670,51 +7657,13 @@ var createPeerExtensionSdk = (options = {}) => ({
   checkConnectionStatus: () => requirePeer(options).checkConnectionStatus(),
   openSidebar: (route) => requirePeer(options).openSidebar(route),
   onramp: (params) => requirePeer(options).onramp(buildOnrampQueryString(params)),
-  onProofComplete: (callback) => requirePeer(options).onProofComplete(callback),
+  onIntentFulfilled: (callback) => requirePeer(options).onIntentFulfilled(callback),
   getVersion: () => requirePeer(options).getVersion(),
   openInstallPage: () => openPeerExtensionInstallPage(options),
   getState: () => getPeerExtensionState(options)
 });
 var peerExtensionSdk = createPeerExtensionSdk();
 
-// 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, ContractRouter, IndexerClient, IndexerDepositService, IndexerRateManagerService, Zkp2pClient as OfframpClient, PEER_EXTENSION_CHROME_URL, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetTakerTier, apiPostDepositDetails, apiValidatePayeeDetails, appendAttributionToCalldata, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createPeerExtensionSdk, defaultIndexerEndpoint, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, isPeerExtensionAvailable, logger, openPeerExtensionInstallPage, peerExtensionSdk, sendTransactionWithAttribution, setLogLevel };
+export { BASE_BUILDER_CODE, CHAINLINK_ORACLE_ADAPTER, CHAINLINK_ORACLE_FEEDS, ContractRouter, DEFAULT_ORACLE_MAX_STALENESS_SECONDS, IndexerClient, IndexerDepositService, IndexerRateManagerService, Zkp2pClient as OfframpClient, PAYMENT_PLATFORMS, PEER_EXTENSION_CHROME_URL, PLATFORM_METADATA, PYTH_CONTRACT_BASE, PYTH_ORACLE_ADAPTER, PYTH_ORACLE_FEEDS, SPREAD_ORACLE_FEEDS, SUPPORTED_CHAIN_IDS, TOKEN_METADATA, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetTakerTier, apiPostDepositDetails, apiValidatePayeeDetails, appendAttributionToCalldata, assertValidReferrerFeeConfig, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createPeerExtensionSdk, defaultIndexerEndpoint, encodePythAdapterConfig, encodeSpreadOracleAdapterConfig, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, getSpreadOracleConfig, isPeerExtensionAvailable, isValidReferrerFeeBps, isValidReferrerFeeRecipient, logger, openPeerExtensionInstallPage, parseReferrerFeeConfig, peerExtensionSdk, referrerFeeConfigToPreciseUnits, sendTransactionWithAttribution, setLogLevel, validateOracleFeedsOnChain };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map