@zkp2p/sdk 0.12.2-rc.2 → 0.12.2-rc.4

package/dist/index.mjs

@@ -2,15 +2,15 @@ import { IntentGuardianOperations } from './chunk-YA67SM3A.mjs';
 export { ZERO_RATE_MANAGER_ID, classifyDelegationState, classifyIntentGuardianError, getDelegationRoute, isZeroRateManagerId, normalizeRateManagerId, normalizeRegistry } from './chunk-YA67SM3A.mjs';
 import { NetworkError, ValidationError, APIError } from './chunk-3J4FPMPW.mjs';
 export { APIError, ContractError, ErrorCode, NetworkError, ValidationError, ZKP2PError } from './chunk-3J4FPMPW.mjs';
-import { OrchestratorRegistry_default, DisputeProtectionPolicy_default, METHOD_NAME_TO_HASH, matchesQuotePaymentMethod, matchesPaymentMethodNameAndHash, getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, SUPPORTED_PAYMENT_METHOD_HASHES, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash, OrchestratorV3_default, MultiAttestationVerifier_default, DisputeNullifierRegistry_default, DisputeVerifier_default, WhitelistPolicy_default, StakeVault_default, IntentLifecycleHookV1_default } from './chunk-67JSDBUL.mjs';
-export { DISPUTE_PROTECTION_POLICY_ABI, ORCHESTRATOR_V3_ABI, PAYMENT_PLATFORMS, STAKE_VAULT_ABI, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getDisputeProtectionPolicyContract, getGatingServiceAddress, getIntentGuardianContract, getOrchestratorV3Contract, getPaymentMethodsCatalog, getRateManagerContracts, getStakeVaultContract, hasIntentGuardian, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-67JSDBUL.mjs';
+import { OrchestratorRegistry_default, DISPUTE_PROTECTION_POLICY_ABI, DisputeProtectionPolicy_default, METHOD_NAME_TO_HASH, matchesQuotePaymentMethod, matchesPaymentMethodNameAndHash, MultiAttestationVerifier_default, getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, SUPPORTED_PAYMENT_METHOD_HASHES, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash, OrchestratorV3_default, DisputeNullifierRegistry_default, DisputeVerifier_default, WhitelistPolicy_default, StakeVault_default, IntentLifecycleHookV1_default } from './chunk-6XJOOLD5.mjs';
+export { DISPUTE_PROTECTION_POLICY_ABI2 as DISPUTE_PROTECTION_POLICY_ABI, ORCHESTRATOR_V3_ABI, PAYMENT_PLATFORMS, STAKE_VAULT_ABI, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getDisputeProtectionPolicyContract, getGatingServiceAddress, getIntentGuardianContract, getOrchestratorV3Contract, getPaymentMethodsCatalog, getRateManagerContracts, getStakeVaultContract, hasIntentGuardian, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-6XJOOLD5.mjs';
 import { Currency, currencyKeccak256 } from './chunk-ZB22BZLZ.mjs';
 export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-ZB22BZLZ.mjs';
-import { define_ZKP2P_SDK_BUILD_METADATA_default } from './chunk-UQEKVVIN.mjs';
-import { concatHex, encodeFunctionData, encodeAbiParameters, createPublicClient, http, isAddress, zeroAddress, keccak256, formatUnits } from 'viem';
+import { define_ZKP2P_SDK_BUILD_METADATA_default } from './chunk-ALXVPWTM.mjs';
+import { keccak256, concatHex, encodeFunctionData, encodeAbiParameters, createPublicClient, http, isAddress, zeroAddress, formatUnits } from 'viem';
 import { hardhat, base } from 'viem/chains';
 import { createEncryptedBuyerTeeSessionMaterial as createEncryptedBuyerTeeSessionMaterial$1, createEncryptedSellerCredentialUpload } from '@zkp2p/zkp2p-attestation';
-export { createNitroAttestationClient } from '@zkp2p/zkp2p-attestation';
+export { createNitroAttestationClient, verifyDisputeAttestation } from '@zkp2p/zkp2p-attestation';
 import { AbiCoder } from 'ethers';
 import { Attribution } from 'ox/erc8021';
 
@@ -352,12 +352,12 @@ function parseAPIError(response, responseText) {
   }
   return new APIError(message, response.status, { url: response.url, responseBody: parsedBody });
 }
-async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs) {
+async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs, shouldRetry) {
   let lastErr;
   for (let i = 0; i < maxRetries; i++) {
     try {
       if (timeoutMs) {
-        const { withTimeout } = await import('./timeout-CQ4Y2Z4T.mjs');
+        const { withTimeout } = await import('./timeout-EL45PCAU.mjs');
         return await withTimeout(fn(), timeoutMs, `Operation timed out after ${timeoutMs}ms`);
       }
       return await fn();
@@ -365,7 +365,7 @@ async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs) {
       lastErr = err;
       const isNetwork = err instanceof NetworkError;
       const isRateLimit = err instanceof APIError && err.status === 429;
-      const retryable = isNetwork || isRateLimit;
+      const retryable = isNetwork || isRateLimit || shouldRetry?.(err) === true;
       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));
@@ -377,6 +377,8 @@ async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs) {
 
 // src/adapters/verification.ts
 var ENFORCED_ON_CHAIN_MESSAGE = /enforced on-chain/i;
+var RETRYABLE_SIGN_INTENT_STATUSES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var isRetryableSignIntentError = (error) => error instanceof APIError && error.status !== void 0 && RETRYABLE_SIGN_INTENT_STATUSES.has(error.status);
 var readCuratorMessage = (body) => {
   try {
     const parsed = JSON.parse(body);
@@ -418,7 +420,8 @@ async function apiSignIntentV3Raw(request, opts) {
     },
     3,
     1e3,
-    opts.timeoutMs
+    opts.timeoutMs,
+    isRetryableSignIntentError
   );
 }
 async function apiSignIntentV3(request, opts) {
@@ -535,6 +538,7 @@ function createAttestationTransport(primaryBaseUrl, options = {}) {
 }
 
 // src/adapters/attestation.ts
+var isAttestationMaterialTimeout = (error) => error instanceof Error && "code" in error && error.code === "TIMEOUT";
 function headers() {
   return { "Content-Type": "application/json" };
 }
@@ -552,35 +556,42 @@ async function createEncryptedSellerCredentialUploadForPlatform({
   platform,
   timeoutMs
 }) {
-  if (platform === "wise") {
-    if (!isWiseCredentialUploadInput(payload)) {
-      throw new Error("apiToken is required for wise seller credential uploads");
+  try {
+    if (platform === "wise") {
+      if (!isWiseCredentialUploadInput(payload)) {
+        throw new Error("apiToken is required for wise seller credential uploads");
+      }
+      return await createEncryptedSellerCredentialUpload({
+        attestationServiceUrl,
+        platform: "wise",
+        ...payload.callerAddress ? { callerAddress: payload.callerAddress } : {},
+        sessionMaterial: payload.sessionMaterial,
+        ...typeof timeoutMs === "number" ? { timeoutMs } : {},
+        fetch: attestationTransport.fetch,
+        ...cryptoRuntime?.subtle ? { subtle: cryptoRuntime.subtle } : {},
+        ...cryptoRuntime?.getRandomValues ? { getRandomValues: cryptoRuntime.getRandomValues } : {}
+      });
+    }
+    if (!isPayeeBoundSellerCredentialUploadInput(payload)) {
+      throw new Error(`payeeId is required for ${platform} seller credential uploads`);
     }
-    return createEncryptedSellerCredentialUpload({
+    return await createEncryptedSellerCredentialUpload({
       attestationServiceUrl,
-      platform: "wise",
+      platform,
       ...payload.callerAddress ? { callerAddress: payload.callerAddress } : {},
+      payeeId: payload.payeeId,
       sessionMaterial: payload.sessionMaterial,
       ...typeof timeoutMs === "number" ? { timeoutMs } : {},
       fetch: attestationTransport.fetch,
       ...cryptoRuntime?.subtle ? { subtle: cryptoRuntime.subtle } : {},
       ...cryptoRuntime?.getRandomValues ? { getRandomValues: cryptoRuntime.getRandomValues } : {}
     });
+  } catch (error) {
+    if (isAttestationMaterialTimeout(error)) {
+      throw new NetworkError(error.message, { cause: error });
+    }
+    throw error;
   }
-  if (!isPayeeBoundSellerCredentialUploadInput(payload)) {
-    throw new Error(`payeeId is required for ${platform} seller credential uploads`);
-  }
-  return createEncryptedSellerCredentialUpload({
-    attestationServiceUrl,
-    platform,
-    ...payload.callerAddress ? { callerAddress: payload.callerAddress } : {},
-    payeeId: payload.payeeId,
-    sessionMaterial: payload.sessionMaterial,
-    ...typeof timeoutMs === "number" ? { timeoutMs } : {},
-    fetch: attestationTransport.fetch,
-    ...cryptoRuntime?.subtle ? { subtle: cryptoRuntime.subtle } : {},
-    ...cryptoRuntime?.getRandomValues ? { getRandomValues: cryptoRuntime.getRandomValues } : {}
-  });
 }
 async function apiVerifyBuyerTeePayment(payload, attestationServiceUrl, platform, actionType, options = {}) {
   return withRetry(async () => {
@@ -852,7 +863,7 @@ async function sendTransactionWithAttribution(walletClient, request, referrer, o
 // src/utils/constants.ts
 var DEFAULT_BASE_API_URL = "https://api.zkp2p.xyz";
 
-// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.6_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.4.3/node_modules/@zkp2p/contracts-v2/oracleFeeds/chainlink.json
+// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.9_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.5.4/node_modules/@zkp2p/contracts-v2/oracleFeeds/chainlink.json
 var chainlink_default = {
   feeds: [
     {
@@ -1898,7 +1909,7 @@ var ProtocolViewerReader = class {
       if (inputCount === null) {
         throw new Error("Configured ProtocolViewer ABI does not expose getDeposit");
       }
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-QE6LWS3W.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-CB3CJ2TB.mjs');
       if (inputCount >= 3) {
         return tryContexts(
           protocolViewerContexts,
@@ -1984,7 +1995,7 @@ var ProtocolViewerReader = class {
       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-QE6LWS3W.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-CB3CJ2TB.mjs');
     if (inputCount >= 2) {
       const requests = ids.map((id, index) => ({
         index,
@@ -2089,7 +2100,7 @@ var ProtocolViewerReader = class {
     if (!protocolViewerAddress || !protocolViewerAbi || inputCount === null) {
       return this.config.host.getPvAccountDepositsFromIndexer(owner);
     }
-    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-QE6LWS3W.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-CB3CJ2TB.mjs');
     const { address, abi } = this.config.host.requireProtocolViewer();
     if (inputCount >= 2) {
       const readAndFilter = async (raw2) => {
@@ -2160,7 +2171,7 @@ var ProtocolViewerReader = class {
     if (protocolViewerEntries.length === 0) {
       throw new Error("ProtocolViewer not available for this network");
     }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-QE6LWS3W.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-CB3CJ2TB.mjs');
     const intentsByHash = /* @__PURE__ */ new Map();
     let attemptedRead = false;
     let hadSuccessfulRead = false;
@@ -2268,7 +2279,7 @@ var ProtocolViewerReader = class {
     if (protocolViewerEntries.length === 0) {
       throw new Error("ProtocolViewer not available for this network");
     }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-QE6LWS3W.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-CB3CJ2TB.mjs');
     let lastError;
     for (const pvEntry of protocolViewerEntries) {
       const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
@@ -3625,6 +3636,23 @@ var STAKING_STATE_QUERY = (
   }
 `
 );
+var TAKER_STAKE_AUTHORIZATIONS_QUERY = (
+  /* GraphQL */
+  `
+  query TakerStakeAuthorizations($where: TakerStakeAuthorization_bool_exp!, $limit: Int!) {
+    TakerStakeAuthorization(where: $where, order_by: [{ id: asc }], limit: $limit) {
+      id
+      chainId
+      vaultAddress
+      taker
+      stakeOwner
+      authorized
+      updatedAtBlockNumber
+      updatedAt
+    }
+  }
+`
+);
 var STAKE_LOCKS_QUERY = (
   /* GraphQL */
   `
@@ -4317,6 +4345,602 @@ var REFERRAL_SIGNATURE_TYPES = {
     { name: "issuedAt", type: "uint256" }
   ]
 };
+var currencyKeccak2562 = (inputString) => {
+  const bytes = new TextEncoder().encode(inputString);
+  return keccak256(bytes);
+};
+var Currency2 = {
+  AED: "AED",
+  ARS: "ARS",
+  AUD: "AUD",
+  BRL: "BRL",
+  CAD: "CAD",
+  CHF: "CHF",
+  CNY: "CNY",
+  CZK: "CZK",
+  DKK: "DKK",
+  EUR: "EUR",
+  GBP: "GBP",
+  HKD: "HKD",
+  HUF: "HUF",
+  IDR: "IDR",
+  ILS: "ILS",
+  INR: "INR",
+  JPY: "JPY",
+  KES: "KES",
+  NOK: "NOK",
+  MXN: "MXN",
+  MYR: "MYR",
+  NZD: "NZD",
+  PHP: "PHP",
+  PLN: "PLN",
+  RON: "RON",
+  SAR: "SAR",
+  SEK: "SEK",
+  SGD: "SGD",
+  THB: "THB",
+  TRY: "TRY",
+  UGX: "UGX",
+  USD: "USD",
+  VND: "VND",
+  ZAR: "ZAR"
+};
+var currencyInfo2 = {
+  [Currency2.AED]: {
+    currency: Currency2.AED,
+    currencyCode: "AED",
+    currencyName: "United Arab Emirates Dirham",
+    currencyCodeHash: currencyKeccak2562("AED"),
+    currencySymbol: "\u062F.\u0625",
+    countryCode: "ae"
+  },
+  [Currency2.ARS]: {
+    currency: Currency2.ARS,
+    currencyCode: "ARS",
+    currencyName: "Argentine Peso",
+    currencyCodeHash: currencyKeccak2562("ARS"),
+    currencySymbol: "$",
+    countryCode: "ar"
+  },
+  [Currency2.AUD]: {
+    currency: Currency2.AUD,
+    currencyCode: "AUD",
+    currencyName: "Australian Dollar",
+    currencyCodeHash: currencyKeccak2562("AUD"),
+    currencySymbol: "A$",
+    countryCode: "au"
+  },
+  [Currency2.BRL]: {
+    currency: Currency2.BRL,
+    currencyCode: "BRL",
+    currencyName: "Brazilian Real",
+    currencyCodeHash: currencyKeccak2562("BRL"),
+    currencySymbol: "R$",
+    countryCode: "br"
+  },
+  [Currency2.CAD]: {
+    currency: Currency2.CAD,
+    currencyCode: "CAD",
+    currencyName: "Canadian Dollar",
+    currencyCodeHash: currencyKeccak2562("CAD"),
+    currencySymbol: "C$",
+    countryCode: "ca"
+  },
+  [Currency2.CHF]: {
+    currency: Currency2.CHF,
+    currencyCode: "CHF",
+    currencyName: "Swiss Franc",
+    currencyCodeHash: currencyKeccak2562("CHF"),
+    currencySymbol: "Fr",
+    countryCode: "ch"
+  },
+  [Currency2.CNY]: {
+    currency: Currency2.CNY,
+    currencyCode: "CNY",
+    currencyName: "Chinese Yuan",
+    currencyCodeHash: currencyKeccak2562("CNY"),
+    currencySymbol: "\xA5",
+    countryCode: "cn"
+  },
+  [Currency2.CZK]: {
+    currency: Currency2.CZK,
+    currencyCode: "CZK",
+    currencyName: "Czech Koruna",
+    currencyCodeHash: currencyKeccak2562("CZK"),
+    currencySymbol: "K\u010D",
+    countryCode: "cz"
+  },
+  [Currency2.DKK]: {
+    currency: Currency2.DKK,
+    currencyCode: "DKK",
+    currencyName: "Danish Krone",
+    currencyCodeHash: currencyKeccak2562("DKK"),
+    currencySymbol: "kr",
+    countryCode: "dk"
+  },
+  [Currency2.EUR]: {
+    currency: Currency2.EUR,
+    currencyCode: "EUR",
+    currencyName: "Euro",
+    currencyCodeHash: currencyKeccak2562("EUR"),
+    currencySymbol: "\u20AC",
+    countryCode: "eu"
+  },
+  [Currency2.GBP]: {
+    currency: Currency2.GBP,
+    currencyCode: "GBP",
+    currencyName: "British Pound",
+    currencyCodeHash: currencyKeccak2562("GBP"),
+    currencySymbol: "\xA3",
+    countryCode: "gb"
+  },
+  [Currency2.HKD]: {
+    currency: Currency2.HKD,
+    currencyCode: "HKD",
+    currencyName: "Hong Kong Dollar",
+    currencyCodeHash: currencyKeccak2562("HKD"),
+    currencySymbol: "HK$",
+    countryCode: "hk"
+  },
+  [Currency2.HUF]: {
+    currency: Currency2.HUF,
+    currencyCode: "HUF",
+    currencyName: "Hungarian Forint",
+    currencyCodeHash: currencyKeccak2562("HUF"),
+    currencySymbol: "Ft",
+    countryCode: "hu"
+  },
+  [Currency2.IDR]: {
+    currency: Currency2.IDR,
+    currencyCode: "IDR",
+    currencyName: "Indonesian Rupiah",
+    currencyCodeHash: currencyKeccak2562("IDR"),
+    currencySymbol: "Rp",
+    countryCode: "id"
+  },
+  [Currency2.INR]: {
+    currency: Currency2.INR,
+    currencyCode: "INR",
+    currencyName: "Indian Rupee",
+    currencyCodeHash: currencyKeccak2562("INR"),
+    currencySymbol: "\u20B9",
+    countryCode: "in"
+  },
+  [Currency2.ILS]: {
+    currency: Currency2.ILS,
+    currencyCode: "ILS",
+    currencyName: "Israeli New Shekel",
+    currencyCodeHash: currencyKeccak2562("ILS"),
+    currencySymbol: "\u20AA",
+    countryCode: "il"
+  },
+  [Currency2.JPY]: {
+    currency: Currency2.JPY,
+    currencyCode: "JPY",
+    currencyName: "Japanese Yen",
+    currencyCodeHash: currencyKeccak2562("JPY"),
+    currencySymbol: "\xA5",
+    countryCode: "jp"
+  },
+  [Currency2.KES]: {
+    currency: Currency2.KES,
+    currencyCode: "KES",
+    currencyName: "Kenyan Shilling",
+    currencyCodeHash: currencyKeccak2562("KES"),
+    currencySymbol: "KSh",
+    countryCode: "ke"
+  },
+  [Currency2.MXN]: {
+    currency: Currency2.MXN,
+    currencyCode: "MXN",
+    currencyName: "Mexican Peso",
+    currencyCodeHash: currencyKeccak2562("MXN"),
+    currencySymbol: "$",
+    countryCode: "mx"
+  },
+  [Currency2.MYR]: {
+    currency: Currency2.MYR,
+    currencyCode: "MYR",
+    currencyName: "Malaysian Ringgit",
+    currencyCodeHash: currencyKeccak2562("MYR"),
+    currencySymbol: "RM",
+    countryCode: "my"
+  },
+  [Currency2.NOK]: {
+    currency: Currency2.NOK,
+    currencyCode: "NOK",
+    currencyName: "Norwegian Krone",
+    currencyCodeHash: currencyKeccak2562("NOK"),
+    currencySymbol: "kr",
+    countryCode: "no"
+  },
+  [Currency2.NZD]: {
+    currency: Currency2.NZD,
+    currencyCode: "NZD",
+    currencyName: "New Zealand Dollar",
+    currencyCodeHash: currencyKeccak2562("NZD"),
+    currencySymbol: "NZ$",
+    countryCode: "nz"
+  },
+  [Currency2.PHP]: {
+    currency: Currency2.PHP,
+    currencyCode: "PHP",
+    currencyName: "Philippine Peso",
+    currencyCodeHash: currencyKeccak2562("PHP"),
+    currencySymbol: "\u20B1",
+    countryCode: "ph"
+  },
+  [Currency2.PLN]: {
+    currency: Currency2.PLN,
+    currencyCode: "PLN",
+    currencyName: "Polish Z\u0142oty",
+    currencyCodeHash: currencyKeccak2562("PLN"),
+    currencySymbol: "z\u0142",
+    countryCode: "pl"
+  },
+  [Currency2.RON]: {
+    currency: Currency2.RON,
+    currencyCode: "RON",
+    currencyName: "Romanian Leu",
+    currencyCodeHash: currencyKeccak2562("RON"),
+    currencySymbol: "lei",
+    countryCode: "ro"
+  },
+  [Currency2.SAR]: {
+    currency: Currency2.SAR,
+    currencyCode: "SAR",
+    currencyName: "Saudi Riyal",
+    currencyCodeHash: currencyKeccak2562("SAR"),
+    currencySymbol: "\uFDFC",
+    countryCode: "sa"
+  },
+  [Currency2.SEK]: {
+    currency: Currency2.SEK,
+    currencyCode: "SEK",
+    currencyName: "Swedish Krona",
+    currencyCodeHash: currencyKeccak2562("SEK"),
+    currencySymbol: "kr",
+    countryCode: "se"
+  },
+  [Currency2.SGD]: {
+    currency: Currency2.SGD,
+    currencyCode: "SGD",
+    currencyName: "Singapore Dollar",
+    currencyCodeHash: currencyKeccak2562("SGD"),
+    currencySymbol: "S$",
+    countryCode: "sg"
+  },
+  [Currency2.THB]: {
+    currency: Currency2.THB,
+    currencyCode: "THB",
+    currencyName: "Thai Baht",
+    currencyCodeHash: currencyKeccak2562("THB"),
+    currencySymbol: "\u0E3F",
+    countryCode: "th"
+  },
+  [Currency2.TRY]: {
+    currency: Currency2.TRY,
+    currencyCode: "TRY",
+    currencyName: "Turkish Lira",
+    currencyCodeHash: currencyKeccak2562("TRY"),
+    currencySymbol: "\u20BA",
+    countryCode: "tr"
+  },
+  [Currency2.UGX]: {
+    currency: Currency2.UGX,
+    currencyCode: "UGX",
+    currencyName: "Ugandan Shilling",
+    currencyCodeHash: currencyKeccak2562("UGX"),
+    currencySymbol: "USh",
+    countryCode: "ug"
+  },
+  [Currency2.USD]: {
+    currency: Currency2.USD,
+    currencyCode: "USD",
+    currencyName: "United States Dollar",
+    currencyCodeHash: currencyKeccak2562("USD"),
+    currencySymbol: "$",
+    countryCode: "us"
+  },
+  [Currency2.VND]: {
+    currency: Currency2.VND,
+    currencyCode: "VND",
+    currencyName: "Vietnamese Dong",
+    currencyCodeHash: currencyKeccak2562("VND"),
+    currencySymbol: "\u20AB",
+    countryCode: "vn"
+  },
+  [Currency2.ZAR]: {
+    currency: Currency2.ZAR,
+    currencyCode: "ZAR",
+    currencyName: "South African Rand",
+    currencyCodeHash: currencyKeccak2562("ZAR"),
+    currencySymbol: "R",
+    countryCode: "za"
+  }
+};
+var PaymentPlatform = {
+  VENMO: "venmo",
+  CASHAPP: "cashapp",
+  CHIME: "chime",
+  LUXON: "luxon",
+  REVOLUT: "revolut",
+  WISE: "wise",
+  MERCADO_PAGO: "mercadopago",
+  ZELLE: "zelle",
+  PAYPAL: "paypal",
+  MONZO: "monzo",
+  N26: "n26",
+  ALIPAY: "alipay",
+  UPI: "upi"
+};
+[...Object.values(PaymentPlatform)];
+var encodeZelleRecipientId = (recipientId) => {
+  const payload = {
+    name: "",
+    action: "payment",
+    token: recipientId
+  };
+  return btoa(JSON.stringify(payload));
+};
+var zelleBankOfAmericaSendConfig = {
+  paymentMethodName: "Bank of America",
+  paymentMethodIcon: void 0,
+  // Icon provided by client-side assets
+  defaultPaymentMode: "QR_CODE",
+  useCustomQRCode: true,
+  troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://www.bankofamerica.com/`,
+  getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => {
+    return `https://www.bankofamerica.com/movemoney`;
+  },
+  deepLinkEmbedsRecipient: false,
+  supportsSendingPaymentOnWeb: true,
+  showTroubleScanningQRCodeLink: true,
+  sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
+    return `Send exactly ${amountFiatToSend} ${currencyInfo2[sendCurrency].currencyCode} in a single payment through Bank of America's Zelle.`;
+  },
+  sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
+    return `Only use Bank of America. Scan the QR code and manually enter the recipient email. Double-check the email before sending.`;
+  },
+  sendPaymentDos: (sendCurrency, amountFiatToSend) => [
+    { text: "Use Bank of America", emphasize: ["Bank of America"] },
+    {
+      text: "Scan the QR code and manually enter the recipient email",
+      emphasize: ["manually", "recipient email"]
+    },
+    {
+      text: "Double-check the email before sending",
+      emphasize: ["Double-check"]
+    },
+    {
+      text: `Send exactly ${amountFiatToSend} ${currencyInfo2[sendCurrency].currencyCode} in a single payment`,
+      emphasize: [
+        "exactly",
+        amountFiatToSend,
+        currencyInfo2[sendCurrency].currencyCode,
+        "single"
+      ]
+    }
+  ],
+  sendPaymentDonts: () => [
+    { text: "Do not use any other bank", emphasize: ["Do not"] }
+  ]
+};
+var zelleBankOfAmericaVerifyConfig = {
+  authLink: "https://www.bankofamerica.com/",
+  actionType: "transfer_zelle_bofa",
+  actionPlatform: PaymentPlatform.ZELLE,
+  buyerTeeParams: {
+    includeMetadataIndex: true
+  },
+  numPaymentsFetched: 15,
+  minExtensionVersion: "0.6.3",
+  supportsAppclip: false,
+  totalProofs: 1,
+  parseMetadata: (metadata) => {
+    const amountStr = metadata.amount ?? "";
+    let dateStr = metadata.date ?? "";
+    if (dateStr && dateStr.length === 10) {
+      dateStr = `${dateStr}T23:59:59`;
+    }
+    const recipientIdStr = metadata.recipient || "";
+    return {
+      amount: amountStr,
+      parsedAmount: amountStr !== "",
+      date: dateStr,
+      parsedDate: dateStr !== "",
+      recipientId: recipientIdStr,
+      parsedRecipientId: false,
+      currency: Currency2.USD,
+      parsedCurrency: true
+    };
+  },
+  getSubjectText: (metadata) => {
+    if (!metadata.amount || !metadata.recipient) {
+      return "";
+    }
+    return `Transfer of $${Number(metadata.amount)} to ${metadata.recipient}`;
+  }
+};
+var zelleChaseSendConfig = {
+  paymentMethodName: "Chase",
+  paymentMethodIcon: void 0,
+  // Icon provided by client-side assets
+  defaultPaymentMode: "QR_CODE",
+  useCustomQRCode: true,
+  troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://secure.chase.com/web/auth/dashboard#/dashboard/singleDoor/singleDoorController/index`,
+  getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => {
+    const encodedRecipientId = encodeZelleRecipientId(recipientId);
+    return `https://enroll.zellepay.com/qr-codes?data=${encodedRecipientId}`;
+  },
+  deepLinkEmbedsRecipient: true,
+  supportsSendingPaymentOnWeb: true,
+  showTroubleScanningQRCodeLink: true,
+  sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
+    return `Send exactly ${amountFiatToSend} ${currencyInfo2[sendCurrency].currencyCode} in a single payment through Chase's Zelle.`;
+  },
+  sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
+    return `Do not send using any other bank.`;
+  },
+  sendPaymentDos: (sendCurrency, amountFiatToSend) => [
+    { text: "Use Chase for this payment", emphasize: ["Chase"] },
+    {
+      text: `Send exactly ${amountFiatToSend} ${currencyInfo2[sendCurrency].currencyCode} in a single payment`,
+      emphasize: [
+        "exactly",
+        amountFiatToSend,
+        currencyInfo2[sendCurrency].currencyCode,
+        "single"
+      ]
+    }
+  ],
+  sendPaymentDonts: () => [
+    { text: "Do not send using any other bank", emphasize: ["Do not"] }
+  ]
+};
+var zelleChaseVerifyConfig = {
+  authLink: "https://secure.chase.com/web/auth/dashboard#/dashboard/singleDoor/payments/activity;params=qp,sentactivity",
+  actionType: "transfer_zelle_chase",
+  actionPlatform: PaymentPlatform.ZELLE,
+  buyerTeeParams: {
+    includeMetadataIndex: true
+  },
+  numPaymentsFetched: 15,
+  minExtensionVersion: "0.6.3",
+  supportsAppclip: false,
+  totalProofs: 2,
+  parseMetadata: (metadata) => {
+    const amountStr = metadata.amount ?? "";
+    let dateStr = metadata.date ?? "";
+    if (dateStr && dateStr.length === 8) {
+      const year = dateStr.substring(0, 4);
+      const month = dateStr.substring(4, 6);
+      const day = dateStr.substring(6, 8);
+      dateStr = `${year}-${month}-${day}T23:59:59`;
+    }
+    const recipientIdStr = metadata.recipient || "";
+    return {
+      amount: amountStr,
+      parsedAmount: amountStr !== "",
+      date: dateStr,
+      parsedDate: dateStr !== "",
+      recipientId: recipientIdStr,
+      parsedRecipientId: false,
+      currency: Currency2.USD,
+      parsedCurrency: true
+    };
+  },
+  getSubjectText: (metadata) => {
+    if (!metadata.amount || !metadata.recipient) {
+      return "";
+    }
+    return `Transfer of $${Number(metadata.amount)} to ${metadata.recipient}`;
+  }
+};
+var zelleCitiSendConfig = {
+  paymentMethodName: "Citi",
+  paymentMethodIcon: void 0,
+  // Icon provided by client-side assets
+  defaultPaymentMode: "QR_CODE",
+  useCustomQRCode: true,
+  troubleScanningQRCodeLink: (recipientId, sendCurrency, amountFiatToSend) => `https://online.citi.com/US/nga/zelle/transfer`,
+  getFormattedSendLink: (recipientId, sendCurrency, amountFiatToSend) => {
+    const encodedRecipientId = encodeZelleRecipientId(recipientId);
+    return `https://enroll.zellepay.com/qr-codes?data=${encodedRecipientId}`;
+  },
+  deepLinkEmbedsRecipient: true,
+  supportsSendingPaymentOnWeb: true,
+  showTroubleScanningQRCodeLink: true,
+  sendPaymentWarning: (sendCurrency, amountFiatToSend) => {
+    return `Send exactly ${amountFiatToSend} ${currencyInfo2[sendCurrency].currencyCode} in a single payment through Citi's Zelle.`;
+  },
+  sendPaymentInfo: (sendCurrency, amountFiatToSend) => {
+    return `Do not send using any other bank.`;
+  },
+  sendPaymentDos: (sendCurrency, amountFiatToSend) => [
+    { text: "Use Citi for this payment", emphasize: ["Citi"] },
+    {
+      text: `Send exactly ${amountFiatToSend} ${currencyInfo2[sendCurrency].currencyCode} in a single payment`,
+      emphasize: [
+        "exactly",
+        amountFiatToSend,
+        currencyInfo2[sendCurrency].currencyCode,
+        "single"
+      ]
+    }
+  ],
+  sendPaymentDonts: () => [
+    { text: "Do not send using any other bank", emphasize: ["Do not"] }
+  ]
+};
+var zelleCitiVerifyConfig = {
+  authLink: "https://online.citi.com/US/nga/zelle/transfer",
+  actionType: "transfer_zelle_citi",
+  actionPlatform: PaymentPlatform.ZELLE,
+  buyerTeeParams: {
+    includeMetadataIndex: true
+  },
+  numPaymentsFetched: 15,
+  minExtensionVersion: "0.6.3",
+  supportsAppclip: false,
+  totalProofs: 1,
+  parseMetadata: (metadata) => {
+    const amountStr = metadata.amount ?? "";
+    let dateStr = metadata.date ?? "";
+    if (dateStr && dateStr.length === 8) {
+      const year = dateStr.substring(0, 4);
+      const month = dateStr.substring(4, 6);
+      const day = dateStr.substring(6, 8);
+      dateStr = `${year}-${month}-${day}T23:59:59`;
+    }
+    const recipientIdStr = metadata.recipient || "";
+    return {
+      amount: amountStr,
+      parsedAmount: amountStr !== "",
+      date: dateStr,
+      parsedDate: dateStr !== "",
+      recipientId: recipientIdStr,
+      parsedRecipientId: recipientIdStr !== "",
+      currency: Currency2.USD,
+      parsedCurrency: true
+    };
+  },
+  getSubjectText: (metadata) => {
+    if (!metadata.amount || !metadata.recipient) {
+      return "";
+    }
+    return `Transfer of $${Number(metadata.amount)} to ${metadata.recipient}`;
+  }
+};
+var genericZelleBankRoutes = [
+  {
+    bankId: "chase",
+    sendConfig: zelleChaseSendConfig,
+    verifyConfig: zelleChaseVerifyConfig
+  },
+  {
+    bankId: "bofa",
+    sendConfig: zelleBankOfAmericaSendConfig,
+    verifyConfig: zelleBankOfAmericaVerifyConfig
+  },
+  {
+    bankId: "citi",
+    sendConfig: zelleCitiSendConfig,
+    verifyConfig: zelleCitiVerifyConfig
+  }
+];
+genericZelleBankRoutes.map(({ sendConfig, verifyConfig }) => ({
+  sendConfig,
+  verifyConfig
+}));
+var DISPUTE_PROTECTION_STAKE_PLATFORMS = [
+  PaymentPlatform.VENMO,
+  PaymentPlatform.PAYPAL
+];
+new Set(
+  DISPUTE_PROTECTION_STAKE_PLATFORMS
+);
+var isCanonicalDisputeProtectionProjection = (projection) => typeof projection.disputeProtectionOptedOut === "boolean" && typeof projection.disputeProtectionRequiresStake === "boolean" && (!projection.disputeProtectionRequiresStake || !projection.disputeProtectionOptedOut);
 
 // src/adapters/api.ts
 function createHeaders(apiKey, authorizationToken, extraHeaders) {
@@ -4851,7 +5475,7 @@ function resolveSignalableEscrow(chainId, runtimeEnv) {
   }
 }
 function hasDisputeProtectionFields(row) {
-  return typeof row.disputeProtectionOptedIn === "boolean" && typeof row.disputeProtectionRequiresStake === "boolean";
+  return isCanonicalDisputeProtectionProjection(row);
 }
 function isSignalableEscrowRow(rowEscrowAddress, signalableEscrow) {
   if (!signalableEscrow) return true;
@@ -5416,6 +6040,11 @@ var getRateManagerReadFunction = (abi, functionName) => Array.isArray(abi) && ab
 );
 
 // src/client/AccessPolicyOperations.ts
+var PEER_PAY_MERCHANT_GROUP_ID_BY_ENVIRONMENT = {
+  production: "0x174b8a29536721a3eae290bfd55651b85a53fc334b971d993fa93ed8dde15e48",
+  preproduction: "0x174b8a29536721a3eae290bfd55651b85a53fc334b971d993fa93ed8dde15e48",
+  staging: "0xc82c20c00033046a2f017b65532d7148a337282f17c73296663a530e49ba00f7"
+};
 var AccessPolicyUnsupportedError = class extends Error {
   constructor(contract) {
     super(`${contract} is not deployed for this environment.`);
@@ -5450,7 +6079,7 @@ var AccessPolicyOperations = class {
       address,
       abi,
       functionName: "enabled",
-      args: [params.escrow, params.depositId]
+      args: [params.escrow, params.depositId, params.paymentMethod]
     });
   }
   /** Groups are enumerable onchain; direct addresses deliberately are not. */
@@ -5460,7 +6089,7 @@ var AccessPolicyOperations = class {
       address,
       abi,
       functionName: "getAllowedGroups",
-      args: [params.escrow, params.depositId]
+      args: [params.escrow, params.depositId, params.paymentMethod]
     });
   }
   /**
@@ -5476,12 +6105,12 @@ var AccessPolicyOperations = class {
       args: [params.escrow, params.depositId, params.taker]
     });
   }
-  async maxGroupsPerDeposit() {
+  async maxGroupsPerDepositPaymentMethod() {
     const { address, abi } = this.requirePolicy();
     return await this.config.getPublicClient().readContract({
       address,
       abi,
-      functionName: "MAX_GROUPS_PER_DEPOSIT"
+      functionName: "MAX_GROUPS_PER_DEPOSIT_PAYMENT_METHOD"
     });
   }
   async groupExists(groupId) {
@@ -5514,38 +6143,31 @@ var AccessPolicyOperations = class {
       txOverrides
     });
   }
-  prepareConfigureDeposit(params) {
+  /** Configure the fixed Peer Pay merchant default while creating a sell deposit. */
+  prepareConfigurePeerPayMerchantDeposit(params) {
+    const runtimeEnv = this.config.getRuntimeEnv?.();
+    if (!runtimeEnv) {
+      throw new Error("Runtime environment is required to configure the Peer Pay merchant policy.");
+    }
+    const merchantGroupId = PEER_PAY_MERCHANT_GROUP_ID_BY_ENVIRONMENT[runtimeEnv];
     return this.preparePolicyCall(
       "configureDeposit",
-      [params.escrow, params.depositId, params.enabled, params.groupIds, params.takers],
+      [params.escrow, params.depositId, params.paymentMethod, true, [merchantGroupId], []],
       params.txOverrides
     );
   }
-  prepareSetEnabled(params) {
+  /** Fail open before removing historical policy entries. */
+  prepareDisable(params) {
     return this.preparePolicyCall(
       "setEnabled",
-      [params.escrow, params.depositId, params.enabled],
-      params.txOverrides
-    );
-  }
-  prepareAddAllowedGroups(params) {
-    return this.preparePolicyCall(
-      "addAllowedGroups",
-      [params.escrow, params.depositId, params.groupIds],
+      [params.escrow, params.depositId, params.paymentMethod, false],
       params.txOverrides
     );
   }
   prepareRemoveAllowedGroups(params) {
     return this.preparePolicyCall(
       "removeAllowedGroups",
-      [params.escrow, params.depositId, params.groupIds],
-      params.txOverrides
-    );
-  }
-  prepareAddWhitelistedAddresses(params) {
-    return this.preparePolicyCall(
-      "addWhitelistedAddresses",
-      [params.escrow, params.depositId, params.takers],
+      [params.escrow, params.depositId, params.paymentMethod, params.groupIds],
       params.txOverrides
     );
   }
@@ -5556,68 +6178,6 @@ var AccessPolicyOperations = class {
       params.txOverrides
     );
   }
-  /** Encodes one planner step. */
-  preparePlanStep(params) {
-    const { escrow, depositId, step, txOverrides } = params;
-    switch (step.kind) {
-      case "configureDeposit":
-        return this.prepareConfigureDeposit({
-          escrow,
-          depositId,
-          enabled: step.enabled,
-          groupIds: step.groupIds,
-          takers: step.takers,
-          txOverrides
-        });
-      case "setEnabled":
-        return this.prepareSetEnabled({ escrow, depositId, enabled: step.enabled, txOverrides });
-      case "addAllowedGroups":
-        return this.prepareAddAllowedGroups({
-          escrow,
-          depositId,
-          groupIds: step.groupIds,
-          txOverrides
-        });
-      case "removeAllowedGroups":
-        return this.prepareRemoveAllowedGroups({
-          escrow,
-          depositId,
-          groupIds: step.groupIds,
-          txOverrides
-        });
-      case "addWhitelistedAddresses":
-        return this.prepareAddWhitelistedAddresses({
-          escrow,
-          depositId,
-          takers: step.takers,
-          txOverrides
-        });
-      case "removeWhitelistedAddresses":
-        return this.prepareRemoveWhitelistedAddresses({
-          escrow,
-          depositId,
-          takers: step.takers,
-          txOverrides
-        });
-    }
-  }
-  /**
-   * Encodes a whole plan, in order.
-   *
-   * A plan with violations encodes to nothing: an invalid draft must be
-   * rejected before a wallet is ever opened.
-   */
-  preparePlan(params) {
-    if (params.plan.violations.length > 0) return [];
-    return params.plan.steps.map(
-      (step) => this.preparePlanStep({
-        escrow: params.escrow,
-        depositId: params.depositId,
-        step,
-        txOverrides: params.txOverrides
-      })
-    );
-  }
 };
 var StakeOperations = class {
   constructor(config) {
@@ -5690,9 +6250,13 @@ var StakeOperations = class {
   getRiskWindow(paymentMethodHash) {
     return this.readPolicy("getRiskWindow", [paymentMethodHash]);
   }
-  /** Whether a specific escrow deposit has opted into dispute protection. */
-  isDisputeProtectionEnabled(escrow, depositId) {
-    return this.readPolicy("isDisputeProtectionEnabled", [escrow, depositId]);
+  /** Whether a specific escrow deposit payment method has opted into dispute protection. */
+  isDisputeProtectionEnabled(escrow, depositId, paymentMethod) {
+    return this.readPolicy("isDisputeProtectionEnabled", [
+      escrow,
+      depositId,
+      paymentMethod
+    ]);
   }
   async getStakeVaultState(params) {
     const taker = params.taker ?? params.staker;
@@ -6495,13 +7059,13 @@ function decodeCursor(cursor, prefix, validate) {
     throw new ValidationError(`cursor must be a valid ${prefix} cursor`, "cursor");
   }
 }
-function decodeLockCursor(cursor) {
-  return decodeCursor(cursor, "zkp2p-lock-v1", (value) => {
+function decodeIdCursor(cursor, prefix) {
+  return decodeCursor(cursor, prefix, (value) => {
     if (typeof value !== "object" || value === null || typeof Reflect.get(value, "id") !== "string") {
-      throw new Error("invalid lock cursor");
+      throw new Error("invalid id cursor");
     }
     const id = Reflect.get(value, "id");
-    if (id.length === 0) throw new Error("invalid lock cursor");
+    if (id.length === 0) throw new Error("invalid id cursor");
     return id;
   });
 }
@@ -6578,7 +7142,7 @@ function normalizeActivityKind(value, field) {
   }
   return value;
 }
-function latestLockAsOf(items) {
+function latestUpdatedAsOf(items) {
   if (items.length === 0) return null;
   const latest = items.reduce(
     (current, item) => BigInt(item.updatedAtBlockNumber) > BigInt(current.updatedAtBlockNumber) ? item : current
@@ -6620,6 +7184,35 @@ function normalizeStakeLockRow(row, index, scope) {
     updatedAt: normalizeDecimal(row.updatedAt, `${field}.updatedAt`)
   };
 }
+function normalizeTakerStakeAuthorizationRow(row, index, scope) {
+  const field = `TakerStakeAuthorization[${index}]`;
+  if (row.chainId !== scope.chainId) throw new Error(`${field}.chainId does not match the query`);
+  if (normalizeAddress4(row.vaultAddress, `${field}.vaultAddress`) !== scope.vaultAddress) {
+    throw new Error(`${field}.vaultAddress does not match the query`);
+  }
+  const taker = normalizeAddress4(row.taker, `${field}.taker`);
+  const stakeOwner = normalizeAddress4(row.stakeOwner, `${field}.stakeOwner`);
+  const scoped = scope.side === "stakeOwner" ? stakeOwner : taker;
+  if (scoped !== scope.scopedAddress) {
+    throw new Error(`${field}.${scope.side} does not match the query`);
+  }
+  if (typeof row.authorized !== "boolean") {
+    throw new Error(`${field}.authorized must be a boolean`);
+  }
+  if (scope.authorized !== void 0 && row.authorized !== scope.authorized) {
+    throw new Error(`${field}.authorized does not match the query`);
+  }
+  return {
+    taker,
+    stakeOwner,
+    authorized: row.authorized,
+    updatedAtBlockNumber: normalizeDecimal(
+      row.updatedAtBlockNumber,
+      `${field}.updatedAtBlockNumber`
+    ),
+    updatedAt: normalizeDecimal(row.updatedAt, `${field}.updatedAt`)
+  };
+}
 function normalizeStakeActivityRow(row, index, scope) {
   const field = `StakeActivity[${index}]`;
   if (row.chainId !== scope.chainId) throw new Error(`${field}.chainId does not match the query`);
@@ -6770,7 +7363,7 @@ var IndexerStakingService = class {
     const vaultAddress = normalizeAddress4(params.vaultAddress, "vaultAddress");
     const stakeOwner = normalizeAddress4(params.stakeOwner, "stakeOwner");
     const status = params.status ? normalizeLockStatus(params.status, "status") : void 0;
-    const afterId = params.cursor ? decodeLockCursor(params.cursor) : void 0;
+    const afterId = params.cursor ? decodeIdCursor(params.cursor, "zkp2p-lock-v1") : void 0;
     const filters = [
       { chainId: { _eq: params.chainId } },
       { vaultAddress: { _eq: vaultAddress } },
@@ -6807,7 +7400,67 @@ var IndexerStakingService = class {
     return {
       items,
       nextCursor: normalized.length > limit ? encodeCursor("zkp2p-lock-v1", { id: visible[visible.length - 1].id }) : null,
-      asOf: latestLockAsOf(items)
+      asOf: latestUpdatedAsOf(items)
+    };
+  }
+  /**
+   * Pages one side of the vault's authorization graph: takers a stake owner
+   * has authorized, or stake owners that have authorized a taker. Exactly one
+   * of `stakeOwner` or `taker` scopes the page.
+   */
+  async fetchTakerStakeAuthorizations(params, init) {
+    validateChainId(params.chainId);
+    const limit = validateLimit(params.limit);
+    const vaultAddress = normalizeAddress4(params.vaultAddress, "vaultAddress");
+    if (params.stakeOwner === void 0 === (params.taker === void 0)) {
+      throw new ValidationError(
+        "exactly one of stakeOwner or taker must be provided",
+        "stakeOwner"
+      );
+    }
+    const scope = params.stakeOwner !== void 0 ? {
+      side: "stakeOwner",
+      address: normalizeAddress4(params.stakeOwner, "stakeOwner")
+    } : { side: "taker", address: normalizeAddress4(params.taker, "taker") };
+    const afterId = params.cursor ? decodeIdCursor(params.cursor, "zkp2p-stake-auth-v1") : void 0;
+    const filters = [
+      { chainId: { _eq: params.chainId } },
+      { vaultAddress: { _eq: vaultAddress } },
+      { [scope.side]: { _eq: scope.address } }
+    ];
+    if (params.authorized !== void 0) filters.push({ authorized: { _eq: params.authorized } });
+    if (afterId) filters.push({ id: { _gt: afterId } });
+    const data3 = await this.client.query(
+      {
+        query: TAKER_STAKE_AUTHORIZATIONS_QUERY,
+        variables: { limit: limit + 1, where: { _and: filters } }
+      },
+      init
+    );
+    let previousId = afterId;
+    const normalized = data3.TakerStakeAuthorization.map((row, index) => {
+      const id = assertNonEmptyId(row.id, `TakerStakeAuthorization[${index}].id`);
+      if (previousId !== void 0 && id <= previousId) {
+        throw new Error("TakerStakeAuthorization cursor did not advance");
+      }
+      previousId = id;
+      return {
+        item: normalizeTakerStakeAuthorizationRow(row, index, {
+          chainId: params.chainId,
+          vaultAddress,
+          side: scope.side,
+          scopedAddress: scope.address,
+          authorized: params.authorized
+        }),
+        id
+      };
+    });
+    const visible = normalized.slice(0, limit);
+    const items = visible.map(({ item }) => item);
+    return {
+      items,
+      nextCursor: normalized.length > limit ? encodeCursor("zkp2p-stake-auth-v1", { id: visible[visible.length - 1].id }) : null,
+      asOf: latestUpdatedAsOf(items)
     };
   }
   async fetchStakeActivity(params, init) {
@@ -7001,17 +7654,17 @@ var IndexerStakingService = class {
   }
 };
 
-// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.6_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.4.3/node_modules/@zkp2p/contracts-v2/_esm/index.js
-var version = "0.4.1-rc.6";
+// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.9_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.5.4/node_modules/@zkp2p/contracts-v2/_esm/index.js
+var version = "0.4.1-rc.9";
 
-// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.6_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.4.3/node_modules/@zkp2p/contracts-v2/_esm/disputeStack/base.js
+// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.9_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.5.4/node_modules/@zkp2p/contracts-v2/_esm/disputeStack/base.js
 var data = {
-  "schemaVersion": 1,
+  "schemaVersion": 2,
   "network": "base",
   "chainId": 8453,
   "activeDisputeStack": {
-    "version": 1,
-    "selectionHash": "a4f17ae7c1620ecfe7d036f0b9cc7b39c50e1382dc8dc14d2e5f7f21061cd5ad"
+    "version": 2,
+    "selectionHash": "ba40c2954b408d0c658881a8d28e5bfcc9bade5cc3d953fd17eae1eca69d841c"
   },
   "runtimeIdentities": {
     "Orchestrator": {
@@ -7027,32 +7680,32 @@ var data = {
       "runtimeCodeHash": "0x4e58f26129559301c017ff264b61dd2255ed2107593d308472ef32d07b8745e9"
     },
     "StakeVault": {
-      "address": "0x4d16F4a9946CfC76b1c1A4B63aa9D94cdA2dbCEB",
+      "address": "0x47c26258222e2f96424bD2B21bf173f0DA5034C7",
       "runtimeCodeHash": "0xfd8d2a910b9ac2c55675ae06d0504f9aac43b02b7022755cf229b571156c681d"
     },
     "DisputeProtectionPolicy": {
-      "address": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
-      "runtimeCodeHash": "0x9c4be279da216021183638eaef79ebf98db248472685e9ecd0de3f24a513a641"
+      "address": "0xbF4B769dB70DBEc89b6b2c44988304a7aD2de4Fc",
+      "runtimeCodeHash": "0xf5a7756f16556da69c91c55bdcffd9fd95cc8cbdb772699827ec4c66db136dfe"
     },
     "IntentLifecycleHookV1": {
-      "address": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
-      "runtimeCodeHash": "0x35789014e608a248f3244b61210fa259fee3566c33f50fd0e3fa1f5ae22e370b"
+      "address": "0x5Dd6C675a7406fE8C9f0D93394a36fd6e8c50031",
+      "runtimeCodeHash": "0x2b479a570ddea7a990f2cae8fa95eb3b8599fc8b367332b8dab92f7d0cebf7e0"
     },
     "RecognizedPredecessorHook": {
-      "address": "0x251d78fb6bBb4071995Bce74bAfC9E4168638622",
-      "runtimeCodeHash": "0x03d02863ed5eaa096d4089cb1e126681c0621d99409124f4af5be7ed83e341fe"
+      "address": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
+      "runtimeCodeHash": "0x35789014e608a248f3244b61210fa259fee3566c33f50fd0e3fa1f5ae22e370b"
     },
     "RecognizedPredecessorPolicy": {
-      "address": "0xc086b6120B5e61EF48221E6A78c69737c9948dF9",
-      "runtimeCodeHash": "0xf08bce9ad622b9d45ce310493627cbef3bf6c4ac915661d5bc572bb59b61e084"
+      "address": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+      "runtimeCodeHash": "0x9c4be279da216021183638eaef79ebf98db248472685e9ecd0de3f24a513a641"
     },
     "OrchestratorRegistry": {
       "address": "0xBe9fED15ED7A4B915C03EFcEcb9662739C3382A9",
       "runtimeCodeHash": "0xf0d132d621ac03181a6fade6a93bd0968d33830c8bf393793236787e7978aee1"
     },
     "WhitelistPolicy": {
-      "address": "0xBC53641b4B2504f0061D6a9426C61B8eBE9B4Ff0",
-      "runtimeCodeHash": "0xa3cf0fdf3835887de432cbac9c192edf6c93a8589748aa93f8294333d57024b2"
+      "address": "0x389Cd9bA91FfFcd83d267B241E975541892759Ce",
+      "runtimeCodeHash": "0xa83d138a5b89d2fd2861702febc6333e542dcdc8994ee76c345dcbd22fe685a4"
     },
     "DisputeVerifier": {
       "address": "0x30d4947f005653637005eed991005119D9eB2f34",
@@ -7076,26 +7729,26 @@ var data = {
     "StakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
   },
   "expectedRelations": {
-    "activeLifecycleHook": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
-    "recognizedPredecessorPolicy": "0xc086b6120B5e61EF48221E6A78c69737c9948dF9",
+    "activeLifecycleHook": "0x5Dd6C675a7406fE8C9f0D93394a36fd6e8c50031",
+    "recognizedPredecessorPolicy": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
     "registeredOrchestrator": "0x014025fDE093f8701d86e9f38e2C3a9b779cb5c7",
-    "authorizedLifecycleHook": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
-    "disputeNullifierAuthorizedWriter": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+    "authorizedLifecycleHook": "0x5Dd6C675a7406fE8C9f0D93394a36fd6e8c50031",
+    "disputeNullifierAuthorizedWriter": "0xbF4B769dB70DBEc89b6b2c44988304a7aD2de4Fc",
     "orchestratorEscrowRegistry": "0xeD0e847B101abc96E796260AC358e12BAa2f5B21",
     "orchestratorPaymentVerifierRegistry": "0x2b82D24437ff66Fb173eabDfD67ee2ACeb8bEb1e",
     "orchestratorRelayerRegistry": "0xEbA979889a9c97382A92472fF3703786fF180083",
     "hookOrchestratorRegistry": "0xBe9fED15ED7A4B915C03EFcEcb9662739C3382A9",
-    "hookWhitelistPolicy": "0xBC53641b4B2504f0061D6a9426C61B8eBE9B4Ff0",
-    "hookDisputeProtectionPolicy": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+    "hookWhitelistPolicy": "0x389Cd9bA91FfFcd83d267B241E975541892759Ce",
+    "hookDisputeProtectionPolicy": "0xbF4B769dB70DBEc89b6b2c44988304a7aD2de4Fc",
     "whitelistGroupRegistry": "0x39F80118f9eB619135f116171b6Cb91D372C5AF2",
     "whitelistEscrowRegistry": "0xeD0e847B101abc96E796260AC358e12BAa2f5B21",
     "whitelistOrchestratorRegistry": "0xBe9fED15ED7A4B915C03EFcEcb9662739C3382A9",
-    "policyStakeVault": "0x4d16F4a9946CfC76b1c1A4B63aa9D94cdA2dbCEB",
+    "policyStakeVault": "0x47c26258222e2f96424bD2B21bf173f0DA5034C7",
     "policyDisputeVerifier": "0x30d4947f005653637005eed991005119D9eB2f34",
     "policyDisputeNullifierRegistry": "0xA845615b5203F7a21321DdF5e3a1ca024D93a443",
     "disputeVerifierNullifierRegistry": "0x5455e761b866dfa6A2f5Dc6d6525825bf9C09aeB",
     "disputeVerifierAttestationVerifier": "0x9Fe920b24e50e6a6362BA71a1BeB502A99c402d5",
-    "vaultController": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+    "vaultController": "0xbF4B769dB70DBEc89b6b2c44988304a7aD2de4Fc",
     "vaultStakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
   },
   "expectedGovernance": {
@@ -7131,15 +7784,15 @@ var data = {
       "0x888888359E981B5225CA48fbCdCeff702FC3b888",
       "0x014025fDE093f8701d86e9f38e2C3a9b779cb5c7"
     ],
-    "lifecycleHookAuthorizationFromBlock": "50201693",
+    "lifecycleHookAuthorizationFromBlock": "50537204",
     "authorizedLifecycleHooks": [
-      "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970"
+      "0x5Dd6C675a7406fE8C9f0D93394a36fd6e8c50031"
     ],
     "passiveDisputeNullifierWriters": [
-      "0xc086b6120B5e61EF48221E6A78c69737c9948dF9"
+      "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA"
     ],
     "activeDisputeNullifierWriters": [
-      "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA"
+      "0xbF4B769dB70DBEc89b6b2c44988304a7aD2de4Fc"
     ]
   },
   "riskWindowSecondsByPaymentMethod": {
@@ -7174,14 +7827,14 @@ var data = {
 };
 var base_default = data;
 
-// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.6_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.4.3/node_modules/@zkp2p/contracts-v2/_esm/disputeStack/baseStaging.js
+// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.4.1-rc.9_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.5.4/node_modules/@zkp2p/contracts-v2/_esm/disputeStack/baseStaging.js
 var data2 = {
-  "schemaVersion": 1,
+  "schemaVersion": 2,
   "network": "base_staging",
   "chainId": 8453,
   "activeDisputeStack": {
-    "version": 1,
-    "selectionHash": "586c90f9de3d10b6d48f4286c709aa7f870fc2fdcfb0af1da947c1da76132dd0"
+    "version": 2,
+    "selectionHash": "6c49c1ce51eec594a22385c4efcab08aa9926b6b63a725e14a0027ec5d2f4fc9"
   },
   "runtimeIdentities": {
     "Orchestrator": {
@@ -7197,16 +7850,16 @@ var data2 = {
       "runtimeCodeHash": "0x4e58f26129559301c017ff264b61dd2255ed2107593d308472ef32d07b8745e9"
     },
     "StakeVault": {
-      "address": "0x01075fdCB8D38fD5A1070db41B3c00DC2459e71e",
+      "address": "0x92d7B59E99e1CD2066540Cd2413b8714948b731f",
       "runtimeCodeHash": "0xfd8d2a910b9ac2c55675ae06d0504f9aac43b02b7022755cf229b571156c681d"
     },
     "DisputeProtectionPolicy": {
-      "address": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
-      "runtimeCodeHash": "0xa4c6a33333e10da596805b6127e96f78e40fe5a0f0ab0cfa8f4683fbeac91a37"
+      "address": "0x484fA07F085eb66bb7C2b649Ea9d5894b2B6681c",
+      "runtimeCodeHash": "0x70c43bfae8253a6a166f9697ddc27b2d77b4d9841e01fefc2db84037d9a98622"
     },
     "IntentLifecycleHookV1": {
-      "address": "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36",
-      "runtimeCodeHash": "0x376364aa8b693ee8e02eacc48527114ce3cc529714be5a3f316c7323561721ab"
+      "address": "0x5A7f6cb7397134da1fDEFA7E2D434b4Cf18E56D9",
+      "runtimeCodeHash": "0xb9ce42108c706f9241aeb41ffdc0da6b7584e8482183055452098b2f16c7abfd"
     },
     "RecognizedPredecessorHook": {
       "address": "0x19D9F0Fcb08C60D8bd0CD061C34eae27eF8b6e65",
@@ -7221,8 +7874,8 @@ var data2 = {
       "runtimeCodeHash": "0xf0d132d621ac03181a6fade6a93bd0968d33830c8bf393793236787e7978aee1"
     },
     "WhitelistPolicy": {
-      "address": "0x7d9277cb8bb78a51eeaafB7CFF306E7DA4C972fD",
-      "runtimeCodeHash": "0x917965fdc75580147ad0787c86f8b2a0f0185ef6e101567b82dc1245d6eb63bc"
+      "address": "0xF79aAD1BAaB617fF3Eb299225c80893F22F743Fe",
+      "runtimeCodeHash": "0x1ece96bb7be9cdd2433a2aad66c9b2d710e3e210a65876e0f8c1e43662ee5653"
     },
     "DisputeVerifier": {
       "address": "0x973578148c5Fd49b9f68B50B26066555325AC708",
@@ -7246,26 +7899,26 @@ var data2 = {
     "StakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
   },
   "expectedRelations": {
-    "activeLifecycleHook": "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36",
+    "activeLifecycleHook": "0x5A7f6cb7397134da1fDEFA7E2D434b4Cf18E56D9",
     "recognizedPredecessorPolicy": "0x21517b7743E727ae47A66FafF93550B689c15020",
     "registeredOrchestrator": "0x2b5E8Ab562e45fA89D73802605E145ED3E3EeF4f",
-    "authorizedLifecycleHook": "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36",
-    "disputeNullifierAuthorizedWriter": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+    "authorizedLifecycleHook": "0x5A7f6cb7397134da1fDEFA7E2D434b4Cf18E56D9",
+    "disputeNullifierAuthorizedWriter": "0x484fA07F085eb66bb7C2b649Ea9d5894b2B6681c",
     "orchestratorEscrowRegistry": "0xc545f336eC77E69bf115729acCbf2e557A00ac91",
     "orchestratorPaymentVerifierRegistry": "0x2261416DA54C85f975C73FA56EF4D2D6b0aEF7Cc",
     "orchestratorRelayerRegistry": "0xB214650b424E6b5fdcB1259566eB7A512D8Bd25E",
     "hookOrchestratorRegistry": "0xfA6384EB6176cfEC049540526A3d2126C3666d8A",
-    "hookWhitelistPolicy": "0x7d9277cb8bb78a51eeaafB7CFF306E7DA4C972fD",
-    "hookDisputeProtectionPolicy": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+    "hookWhitelistPolicy": "0xF79aAD1BAaB617fF3Eb299225c80893F22F743Fe",
+    "hookDisputeProtectionPolicy": "0x484fA07F085eb66bb7C2b649Ea9d5894b2B6681c",
     "whitelistGroupRegistry": "0x54Ff7788Cb42B46FE2F016a65Fd0f654Bb9BcF3D",
     "whitelistEscrowRegistry": "0xc545f336eC77E69bf115729acCbf2e557A00ac91",
     "whitelistOrchestratorRegistry": "0xfA6384EB6176cfEC049540526A3d2126C3666d8A",
-    "policyStakeVault": "0x01075fdCB8D38fD5A1070db41B3c00DC2459e71e",
+    "policyStakeVault": "0x92d7B59E99e1CD2066540Cd2413b8714948b731f",
     "policyDisputeVerifier": "0x973578148c5Fd49b9f68B50B26066555325AC708",
     "policyDisputeNullifierRegistry": "0xE0B05a9655AF0f31E32904267baa50FbC7f217ea",
     "disputeVerifierNullifierRegistry": "0x2eb43d6C7c7Ec4220Aa6B8735BC053824a71778C",
     "disputeVerifierAttestationVerifier": "0x9855a39aC5975069632e91160d8712CBfF19e864",
-    "vaultController": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+    "vaultController": "0x484fA07F085eb66bb7C2b649Ea9d5894b2B6681c",
     "vaultStakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
   },
   "expectedGovernance": {
@@ -7301,15 +7954,15 @@ var data2 = {
       "0xc17a59227B136c45fAa153086a15EF87ED14bE00",
       "0x2b5E8Ab562e45fA89D73802605E145ED3E3EeF4f"
     ],
-    "lifecycleHookAuthorizationFromBlock": "50201496",
+    "lifecycleHookAuthorizationFromBlock": "50536390",
     "authorizedLifecycleHooks": [
-      "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36"
+      "0x5A7f6cb7397134da1fDEFA7E2D434b4Cf18E56D9"
     ],
     "passiveDisputeNullifierWriters": [
       "0x21517b7743E727ae47A66FafF93550B689c15020"
     ],
     "activeDisputeNullifierWriters": [
-      "0x51436B8051cCf52739A2090C29DA208B70eC2663"
+      "0x484fA07F085eb66bb7C2b649Ea9d5894b2B6681c"
     ]
   },
   "riskWindowSecondsByPaymentMethod": {
@@ -7334,7 +7987,7 @@ var data2 = {
   "prerequisites": {
     "orchestratorPaused": false,
     "admissionsPaused": false,
-    "allowMultipleIntents": true,
+    "allowMultipleIntents": false,
     "orchestratorRegistered": true,
     "lifecycleHookAuthorized": true,
     "disputeNullifierWriterAuthorized": true,
@@ -7348,7 +8001,7 @@ var baseStaging_default = data2;
 
 // src/buildMetadata.ts
 var DEVELOPMENT_BUILD_METADATA = {
-  schemaVersion: 1,
+  schemaVersion: 2,
   source: {
     repository: "zkp2p/zkp2p-clients",
     commitSha: "development",
@@ -7359,13 +8012,14 @@ var DEVELOPMENT_BUILD_METADATA = {
   contractsPackageVersion: "development",
   indexerSchemaPackageVersion: "development",
   activeDisputeStack: {
-    base: { version: 1, selectionHash: "development" },
-    baseStaging: { version: 1, selectionHash: "development" }
+    base: { version: 2, selectionHash: "development" },
+    baseStaging: { version: 2, selectionHash: "development" }
   }
 };
 var SDK_BUILD_METADATA = typeof define_ZKP2P_SDK_BUILD_METADATA_default === "undefined" ? DEVELOPMENT_BUILD_METADATA : define_ZKP2P_SDK_BUILD_METADATA_default;
 
 // src/client/DisputeProtectionReadiness.ts
+var DisputeProtectionPolicy = DISPUTE_PROTECTION_POLICY_ABI ?? DisputeProtectionPolicy_default;
 var SUCCESSOR_RUNTIME_IDENTITIES = [
   "IntentLifecycleHookV1",
   "StakeVault",
@@ -7380,7 +8034,7 @@ var GOVERNANCE_ABIS = {
   OrchestratorRegistry: OrchestratorRegistry_default,
   OrchestratorV3: OrchestratorV3_default,
   StakeVault: StakeVault_default,
-  DisputeProtectionPolicy: DisputeProtectionPolicy_default,
+  DisputeProtectionPolicy,
   WhitelistPolicy: WhitelistPolicy_default,
   DisputeVerifier: DisputeVerifier_default,
   DisputeNullifierRegistry: DisputeNullifierRegistry_default,
@@ -7389,7 +8043,7 @@ var GOVERNANCE_ABIS = {
 var ORCHESTRATOR_AUTHORIZATION_EVENTS = OrchestratorRegistry_default.filter(
   (item) => item.type === "event" && (item.name === "OrchestratorAdded" || item.name === "OrchestratorRemoved")
 );
-var LIFECYCLE_HOOK_AUTHORIZATION_EVENTS = DisputeProtectionPolicy_default.filter(
+var LIFECYCLE_HOOK_AUTHORIZATION_EVENTS = DisputeProtectionPolicy.filter(
   (item) => item.type === "event" && item.name === "LifecycleHookAuthorizationUpdated"
 );
 var FALLBACK_LOG_BLOCK_SPAN = 10000n;
@@ -7425,6 +8079,17 @@ function expectAddressSet(label, actual, expected) {
     throw new ReadinessMismatch(`${label} mismatch`);
   }
 }
+function expectAddressSubsetWithRequired(label, actual, expected, required) {
+  const actualAddresses = normalizeAddressSet(label, actual);
+  const expectedAddresses = new Set(normalizeAddressSet(label, expected));
+  const unknown = actualAddresses.filter((address) => !expectedAddresses.has(address));
+  if (unknown.length > 0) {
+    throw new ReadinessMismatch(`${label} mismatch`);
+  }
+  if (!actualAddresses.includes(required.toLowerCase())) {
+    throw new ReadinessMismatch(`${label} is missing the active successor orchestrator`);
+  }
+}
 function fallbackBlockRanges(fromBlock, toBlock) {
   const ranges = [];
   for (let start = fromBlock; start <= toBlock; start += FALLBACK_LOG_BLOCK_SPAN) {
@@ -7474,6 +8139,55 @@ function replayAddressAuthorizations(label, events, addressField, enabledField)
 function manifestForEnvironment(environment) {
   return environment === "staging" ? baseStaging_default : base_default;
 }
+async function readDisputeAttestationConfig({
+  publicClient,
+  chainId,
+  environment = "production"
+}) {
+  const manifest = manifestForEnvironment(environment);
+  if (manifest.chainId !== chainId) {
+    throw new Error(
+      `Dispute attestation is unavailable for chainId=${chainId}, env=${environment}`
+    );
+  }
+  const asOfBlock = await publicClient.getBlockNumber();
+  const attestationVerifier = manifest.runtimeIdentities.MultiAttestationVerifier.address;
+  const [rawRequiredSignatures, rawTrustedSigners] = await publicClient.multicall({
+    allowFailure: false,
+    blockNumber: asOfBlock,
+    contracts: [
+      {
+        address: attestationVerifier,
+        abi: MultiAttestationVerifier_default,
+        functionName: "requiredSignatures"
+      },
+      {
+        address: attestationVerifier,
+        abi: MultiAttestationVerifier_default,
+        functionName: "witnesses"
+      }
+    ]
+  });
+  const requiredSignatures = typeof rawRequiredSignatures === "bigint" ? Number(rawRequiredSignatures) : Number.NaN;
+  if (!Number.isSafeInteger(requiredSignatures) || requiredSignatures < 1) {
+    throw new Error("Dispute attestation verifier has an invalid signature threshold");
+  }
+  const trustedSigners = normalizeAddressSet(
+    "MultiAttestationVerifier.witnesses",
+    rawTrustedSigners
+  );
+  if (trustedSigners.length < requiredSignatures) {
+    throw new Error("Dispute attestation verifier has fewer witnesses than required signatures");
+  }
+  return {
+    asOfBlock,
+    chainId: manifest.chainId,
+    policyAddress: manifest.runtimeIdentities.DisputeProtectionPolicy.address,
+    verifierAddress: manifest.runtimeIdentities.DisputeVerifier.address,
+    trustedSigners,
+    requiredSignatures
+  };
+}
 function validatePackagedIdentity(config) {
   const { buildMetadata, chainId, contractsPackageVersion, manifest } = config;
   if (!buildMetadata.source.distributable) return "SDK build metadata is not distributable";
@@ -7483,7 +8197,7 @@ function validatePackagedIdentity(config) {
   if (buildMetadata.contractsPackageVersion !== contractsPackageVersion) {
     return "contracts package version does not match SDK build metadata";
   }
-  if (manifest.schemaVersion !== 1 || manifest.chainId !== chainId || manifest.network !== "base" && manifest.network !== "base_staging") {
+  if (manifest.schemaVersion !== 2 || manifest.chainId !== chainId || manifest.network !== "base" && manifest.network !== "base_staging") {
     return "dispute readiness manifest chain identity mismatch";
   }
   const selected = manifest.network === "base" ? buildMetadata.activeDisputeStack.base : buildMetadata.activeDisputeStack.baseStaging;
@@ -7713,10 +8427,11 @@ var DisputeProtectionReadinessReader = class {
       "hook",
       "isAuthorized"
     );
-    expectAddressSet(
+    expectAddressSubsetWithRequired(
       "OrchestratorRegistry authorized orchestrators",
       orchestrators,
-      authorizations.authorizedOrchestrators
+      authorizations.authorizedOrchestrators,
+      this.config.manifest.runtimeIdentities.OrchestratorV3.address
     );
     expectAddressSet(
       "DisputeProtectionPolicy authorized lifecycle hooks",
@@ -7738,6 +8453,10 @@ var DisputeProtectionReadinessReader = class {
     const riskWindows = Object.entries(manifest.riskWindowSecondsByPaymentMethod).sort(
       ([left], [right]) => left.localeCompare(right)
     );
+    const sentinelPaymentMethod = riskWindows[0]?.[0];
+    if (!sentinelPaymentMethod) {
+      throw new ReadinessMismatch("DisputeProtectionPolicy sentinel payment method is missing");
+    }
     const contracts = [
       {
         address: identities.IntentLifecycleHookV1.address,
@@ -7775,34 +8494,38 @@ var DisputeProtectionReadinessReader = class {
         abi: WhitelistPolicy_default,
         functionName: "orchestratorRegistry"
       },
-      { address: policy, abi: DisputeProtectionPolicy_default, functionName: "stakeVault" },
-      { address: policy, abi: DisputeProtectionPolicy_default, functionName: "disputeVerifier" },
+      { address: policy, abi: DisputeProtectionPolicy, functionName: "stakeVault" },
+      { address: policy, abi: DisputeProtectionPolicy, functionName: "disputeVerifier" },
       {
         address: policy,
-        abi: DisputeProtectionPolicy_default,
+        abi: DisputeProtectionPolicy,
         functionName: "disputeNullifierRegistry"
       },
       {
         address: policy,
-        abi: DisputeProtectionPolicy_default,
+        abi: DisputeProtectionPolicy,
         functionName: "isLifecycleHookAuthorized",
         args: [relations.authorizedLifecycleHook]
       },
-      { address: policy, abi: DisputeProtectionPolicy_default, functionName: "admissionsPaused" },
+      { address: policy, abi: DisputeProtectionPolicy, functionName: "admissionsPaused" },
       {
         address: policy,
-        abi: DisputeProtectionPolicy_default,
+        abi: DisputeProtectionPolicy,
         functionName: "PENDING_COVERAGE_MATURITY"
       },
       {
         address: policy,
-        abi: DisputeProtectionPolicy_default,
+        abi: DisputeProtectionPolicy,
         functionName: "isDisputeProtectionEnabled",
-        args: [manifest.sentinel.escrow, BigInt(manifest.sentinel.depositId)]
+        args: [
+          manifest.sentinel.escrow,
+          BigInt(manifest.sentinel.depositId),
+          sentinelPaymentMethod
+        ]
       },
       ...riskWindows.map(([paymentMethod]) => ({
         address: policy,
-        abi: DisputeProtectionPolicy_default,
+        abi: DisputeProtectionPolicy,
         functionName: "getRiskWindow",
         args: [paymentMethod]
       })),
@@ -8349,6 +9072,26 @@ function assertCatalogPaymentMethods(paymentMethods, chainId, runtimeEnv, field)
     }
   });
 }
+function assertCatalogCurrencies(paymentMethods, currencies, chainId, runtimeEnv, field) {
+  const catalogByHash = new Map(
+    Object.values(getPaymentMethodsCatalog(chainId, runtimeEnv)).map((entry) => [
+      entry.paymentMethodHash.toLowerCase(),
+      new Set(entry.currencies?.map((currency) => currency.toLowerCase()) ?? [])
+    ])
+  );
+  paymentMethods.forEach((paymentMethod, paymentMethodIndex) => {
+    const allowedCurrencies = catalogByHash.get(paymentMethod.toLowerCase());
+    if (!allowedCurrencies?.size) return;
+    currencies[paymentMethodIndex]?.forEach((currency, currencyIndex) => {
+      if (!allowedCurrencies.has(currency.code.toLowerCase())) {
+        throw new ValidationError(
+          `Unsupported currency hash ${currency.code} for payment method ${paymentMethod}`,
+          `${field}[${paymentMethodIndex}][${currencyIndex}].code`
+        );
+      }
+    });
+  });
+}
 var Zkp2pClient = class {
   /**
    * Creates a new Zkp2pClient instance.
@@ -8382,7 +9125,12 @@ var Zkp2pClient = class {
       () => []
     );
     /** Enable or disable dispute protection for one deposit. */
-    this.setDisputeProtectionEnabled = this.buildDisputeProtectionPolicyMethod("setDisputeProtectionEnabled", (params) => [params.escrow, params.depositId, params.enabled]);
+    this.setDisputeProtectionEnabled = this.buildDisputeProtectionPolicyMethod("setDisputeProtectionEnabled", (params) => [
+      params.escrow,
+      params.depositId,
+      params.paymentMethod,
+      params.enabled
+    ]);
     /**
      * Release one protected intent whose risk window matured, unlocking its
      * stake cover. Permissionless once mature. Pass `disputeProtectionPolicyAddress` to
@@ -9457,6 +10205,7 @@ var Zkp2pClient = class {
     });
     this._accessPolicyOps = new AccessPolicyOperations({
       getPublicClient: () => this.publicClient,
+      getRuntimeEnv: () => this.runtimeEnv,
       getPolicyAddress: () => this.whitelistPolicyAddress,
       getPolicyAbi: () => this.whitelistPolicyAbi,
       getRegistryAddress: () => this.addressGroupRegistryAddress,
@@ -10300,6 +11049,15 @@ var Zkp2pClient = class {
       getStakeLocks: (params, options) => {
         return stakingService.fetchStakeLocks(params, { signal: options?.signal });
       },
+      /**
+       * Pages one side of the vault's authorization graph: the takers a stake
+       * owner has authorized, or the stake owners that have authorized a taker.
+       */
+      getTakerStakeAuthorizations: (params, options) => {
+        return stakingService.fetchTakerStakeAuthorizations(params, {
+          signal: options?.signal
+        });
+      },
       /** Pages append-only activity relevant to either side of a merchant's stake delegation. */
       getStakeActivity: (params, options) => {
         return stakingService.fetchStakeActivity(params, { signal: options?.signal });
@@ -10478,8 +11236,8 @@ var Zkp2pClient = class {
     return this._stakeOps.getRiskWindow(paymentMethodHash);
   }
   /** Read whether an escrow deposit has opted into dispute protection. */
-  isDisputeProtectionEnabled(escrow, depositId) {
-    return this._stakeOps.isDisputeProtectionEnabled(escrow, depositId);
+  isDisputeProtectionEnabled(escrow, depositId, paymentMethod) {
+    return this._stakeOps.isDisputeProtectionEnabled(escrow, depositId, paymentMethod);
   }
   /**
    * Registers payee details with the curator API and returns hashed on-chain IDs.
@@ -10637,6 +11395,13 @@ var Zkp2pClient = class {
         this.runtimeEnv,
         "paymentMethodsOverride"
       );
+      assertCatalogCurrencies(
+        params.paymentMethodsOverride,
+        params.currenciesOverride,
+        this.chainId,
+        this.runtimeEnv,
+        "currenciesOverride"
+      );
       paymentMethods = params.paymentMethodsOverride;
       paymentMethodData = params.paymentMethodDataOverride;
       currencies = params.currenciesOverride;
@@ -10682,7 +11447,7 @@ var Zkp2pClient = class {
           }
         }
       });
-      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-Y5CH6IXG.mjs');
+      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-KBPBKLN2.mjs');
       currencies = mapConversionRatesToOnchainMinRate2(
         params.conversionRates,
         paymentMethods.length
@@ -11381,162 +12146,6 @@ function selectRiskMode(amount, freeStake, disputeProtected) {
   throw new RangeError("insufficient free stake for dispute-protected admission");
 }
 
-// src/client/accessPolicyPlan.ts
-var MAX_GROUPS_PER_DEPOSIT = 10;
-var MAX_ADDRESSES_PER_CALL = 50;
-var MAX_WHITELISTED_ADDRESSES = 500;
-var chunk = (values, size) => {
-  if (values.length <= size) return values.length > 0 ? [values] : [];
-  const batches = [];
-  for (let index = 0; index < values.length; index += size) {
-    batches.push(values.slice(index, index + size));
-  }
-  return batches;
-};
-var normalizeList = (values) => {
-  const seen = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const value of values) {
-    if (typeof value !== "string") continue;
-    const trimmed = value.trim().toLowerCase();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    normalized.push(trimmed);
-  }
-  return normalized;
-};
-var normalizeAccessPolicyState = (state) => ({
-  enabled: Boolean(state.enabled),
-  groupIds: normalizeList(state.groupIds),
-  addresses: normalizeList(state.addresses)
-});
-var difference = (left, right) => {
-  const exclude = new Set(right);
-  return left.filter((value) => !exclude.has(value));
-};
-var diffAccessPolicy = (persistedInput, draftInput) => {
-  const persisted = normalizeAccessPolicyState(persistedInput);
-  const draft = normalizeAccessPolicyState(draftInput);
-  return {
-    addedGroupIds: difference(draft.groupIds, persisted.groupIds),
-    removedGroupIds: difference(persisted.groupIds, draft.groupIds),
-    addedAddresses: difference(draft.addresses, persisted.addresses),
-    removedAddresses: difference(persisted.addresses, draft.addresses),
-    enabledChanged: persisted.enabled !== draft.enabled
-  };
-};
-var planAccessPolicyUpdate = (persistedInput, draftInput) => {
-  const persisted = normalizeAccessPolicyState(persistedInput);
-  const draft = normalizeAccessPolicyState(draftInput);
-  const diff = diffAccessPolicy(persisted, draft);
-  const hasChanges = diff.enabledChanged || diff.addedGroupIds.length > 0 || diff.removedGroupIds.length > 0 || diff.addedAddresses.length > 0 || diff.removedAddresses.length > 0;
-  const violations = [];
-  if (draft.enabled && draft.groupIds.length === 0 && draft.addresses.length === 0) {
-    violations.push("empty-restricted-policy");
-  }
-  if (draft.groupIds.length > MAX_GROUPS_PER_DEPOSIT) {
-    violations.push("group-cap-exceeded");
-  }
-  if (draft.addresses.length > MAX_WHITELISTED_ADDRESSES) {
-    violations.push("address-cap-exceeded");
-  }
-  if (!hasChanges || violations.length > 0) {
-    return {
-      diff,
-      steps: [],
-      hasChanges,
-      ordering: hasChanges ? "additions-first" : "no-changes",
-      violations,
-      resultingGroupCount: draft.groupIds.length
-    };
-  }
-  const peakIfAddingFirst = (/* @__PURE__ */ new Set([...persisted.groupIds, ...diff.addedGroupIds])).size;
-  const mustRemoveGroupsFirst = peakIfAddingFirst > MAX_GROUPS_PER_DEPOSIT;
-  const ordering = !draft.enabled ? "disable-first" : mustRemoveGroupsFirst ? "removals-first" : "additions-first";
-  const steps = [];
-  const additionSteps = () => {
-    const collected = [];
-    if (diff.addedGroupIds.length > 0) {
-      collected.push({
-        kind: "addAllowedGroups",
-        groupIds: diff.addedGroupIds
-      });
-    }
-    for (const batch of chunk(diff.addedAddresses, MAX_ADDRESSES_PER_CALL)) {
-      collected.push({ kind: "addWhitelistedAddresses", takers: batch });
-    }
-    return collected;
-  };
-  const removalSteps = () => {
-    const collected = [];
-    if (diff.removedGroupIds.length > 0) {
-      collected.push({
-        kind: "removeAllowedGroups",
-        groupIds: diff.removedGroupIds
-      });
-    }
-    for (const batch of chunk(diff.removedAddresses, MAX_ADDRESSES_PER_CALL)) {
-      collected.push({ kind: "removeWhitelistedAddresses", takers: batch });
-    }
-    return collected;
-  };
-  if (ordering === "disable-first") {
-    if (diff.enabledChanged) {
-      steps.push({ kind: "setEnabled", enabled: false });
-    }
-    steps.push(...removalSteps(), ...additionSteps());
-    return {
-      diff,
-      steps,
-      hasChanges,
-      ordering,
-      violations,
-      resultingGroupCount: draft.groupIds.length
-    };
-  }
-  if (ordering === "removals-first") {
-    if (persisted.enabled) {
-      steps.push({ kind: "setEnabled", enabled: false });
-    }
-    steps.push(...removalSteps(), ...additionSteps());
-    steps.push({ kind: "setEnabled", enabled: true });
-    return {
-      diff,
-      steps,
-      hasChanges,
-      ordering,
-      violations,
-      resultingGroupCount: draft.groupIds.length
-    };
-  }
-  if (diff.enabledChanged) {
-    const [firstBatch = [], ...overflowBatches] = chunk(
-      diff.addedAddresses,
-      MAX_ADDRESSES_PER_CALL
-    );
-    steps.push({
-      kind: "configureDeposit",
-      enabled: true,
-      groupIds: diff.addedGroupIds,
-      takers: firstBatch
-    });
-    for (const batch of overflowBatches) {
-      steps.push({ kind: "addWhitelistedAddresses", takers: batch });
-    }
-  } else {
-    steps.push(...additionSteps());
-  }
-  steps.push(...removalSteps());
-  return {
-    diff,
-    steps,
-    hasChanges,
-    ordering,
-    violations,
-    resultingGroupCount: draft.groupIds.length
-  };
-};
-
-export { AccessPolicyOperations, AccessPolicyUnsupportedError, BASE_BUILDER_CODE, CHAINLINK_ORACLE_ADAPTER, CHAINLINK_ORACLE_FEEDS, ContractRouter, DEFAULT_ORACLE_MAX_STALENESS_SECONDS, IndexerClient, IndexerDepositService, IndexerRateManagerService, IndexerStakingService, MAX_ADDRESSES_PER_CALL, MAX_GROUPS_PER_DEPOSIT, MAX_WHITELISTED_ADDRESSES, Zkp2pClient as OfframpClient, PEER_EXTENSION_CHROME_URL, PLATFORM_METADATA, PYTH_CONTRACT_BASE, PYTH_ORACLE_ADAPTER, PYTH_ORACLE_FEEDS, REFERRAL_SIGNATURE_DOMAIN, REFERRAL_SIGNATURE_TYPES, RISK_BPS_DENOMINATOR, SDK_BUILD_METADATA, SPREAD_ORACLE_FEEDS, SUPPORTED_CHAIN_IDS, TOKEN_METADATA, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiCreateReferralCode, apiCreateSellerCredentialBundle, apiGetDepositBundle, apiGetOrderbook, apiGetOrderbookTable, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetQuote, apiGetQuotesBestByPlatform, apiGetReferralDashboard, apiGetReferralEarnings, apiLookupReferralCode, apiPostDepositDetails, apiRedeemReferralCode, apiRequestIdentityAttestation, apiSignIntentV3, apiSignIntentV3Raw, apiUpdateReferralCode, apiUploadGoogleOAuthSellerCredential, apiUploadSellerCredentialBundle, apiValidatePayeeDetails, apiVerifyBuyerTeePayment, appendAttributionToCalldata, assertValidReferrerFeeConfig, buildStakingEntityIds, calculateRequiredCoverage, calculateStakeBackedCapacity, compareEventCursorIdsByRecency, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createEncryptedBuyerTeeSessionMaterial, createPeerExtensionSdk, defaultIndexerEndpoint, diffAccessPolicy, encodePythAdapterConfig, encodeSpreadOracleAdapterConfig, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, getSpreadOracleConfig, isPeerExtensionAvailable, isValidReferralCode, isValidReferrerFeeBps, isValidReferrerFeeRecipient, logger, normalizeAccessPolicyState, normalizeReferralCode, openPeerExtensionInstallPage, parseReferrerFeeConfig, peerExtensionSdk, planAccessPolicyUpdate, referrerFeeConfigToPreciseUnits, selectRiskMode, sendTransactionWithAttribution, setLogLevel, validateOracleFeedsOnChain };
+export { AccessPolicyOperations, AccessPolicyUnsupportedError, BASE_BUILDER_CODE, CHAINLINK_ORACLE_ADAPTER, CHAINLINK_ORACLE_FEEDS, ContractRouter, DEFAULT_ORACLE_MAX_STALENESS_SECONDS, IndexerClient, IndexerDepositService, IndexerRateManagerService, IndexerStakingService, Zkp2pClient as OfframpClient, PEER_EXTENSION_CHROME_URL, PLATFORM_METADATA, PYTH_CONTRACT_BASE, PYTH_ORACLE_ADAPTER, PYTH_ORACLE_FEEDS, REFERRAL_SIGNATURE_DOMAIN, REFERRAL_SIGNATURE_TYPES, RISK_BPS_DENOMINATOR, SDK_BUILD_METADATA, SPREAD_ORACLE_FEEDS, SUPPORTED_CHAIN_IDS, TOKEN_METADATA, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiCreateReferralCode, apiCreateSellerCredentialBundle, apiGetDepositBundle, apiGetOrderbook, apiGetOrderbookTable, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetQuote, apiGetQuotesBestByPlatform, apiGetReferralDashboard, apiGetReferralEarnings, apiLookupReferralCode, apiPostDepositDetails, apiRedeemReferralCode, apiRequestIdentityAttestation, apiSignIntentV3, apiSignIntentV3Raw, apiUpdateReferralCode, apiUploadGoogleOAuthSellerCredential, apiUploadSellerCredentialBundle, apiValidatePayeeDetails, apiVerifyBuyerTeePayment, appendAttributionToCalldata, assertValidReferrerFeeConfig, buildStakingEntityIds, calculateRequiredCoverage, calculateStakeBackedCapacity, compareEventCursorIdsByRecency, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createEncryptedBuyerTeeSessionMaterial, createPeerExtensionSdk, defaultIndexerEndpoint, encodePythAdapterConfig, encodeSpreadOracleAdapterConfig, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, getSpreadOracleConfig, isPeerExtensionAvailable, isValidReferralCode, isValidReferrerFeeBps, isValidReferrerFeeRecipient, logger, normalizeReferralCode, openPeerExtensionInstallPage, parseReferrerFeeConfig, peerExtensionSdk, readDisputeAttestationConfig, referrerFeeConfigToPreciseUnits, selectRiskMode, sendTransactionWithAttribution, setLogLevel, validateOracleFeedsOnChain };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map