@zkp2p/sdk 0.12.1 → 0.12.2-rc.1

package/dist/index.mjs

@@ -1,13 +1,13 @@
-import { IntentGuardianOperations } from './chunk-FCOH36IX.mjs';
-export { ZERO_RATE_MANAGER_ID, classifyDelegationState, classifyIntentGuardianError, getDelegationRoute, isZeroRateManagerId, normalizeRateManagerId, normalizeRegistry } from './chunk-FCOH36IX.mjs';
-import { NetworkError, ValidationError, APIError } from './chunk-GHQK65J2.mjs';
-export { APIError, ContractError, ErrorCode, NetworkError, ValidationError, ZKP2PError } from './chunk-GHQK65J2.mjs';
-import { METHOD_NAME_TO_HASH, matchesQuotePaymentMethod, matchesPaymentMethodNameAndHash, getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, SUPPORTED_PAYMENT_METHOD_HASHES, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash } from './chunk-DZQOCRT4.mjs';
-export { CHARGEBACK_POLICY_ABI, ORCHESTRATOR_V3_ABI, PAYMENT_PLATFORMS, STAKE_VAULT_ABI, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getChargebackPolicyContract, getContracts, getGatingServiceAddress, getIntentGuardianContract, getOrchestratorV3Contract, getPaymentMethodsCatalog, getRateManagerContracts, getStakeVaultContract, hasIntentGuardian, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-DZQOCRT4.mjs';
-import { Currency, currencyKeccak256 } from './chunk-ZFBH4HD7.mjs';
-export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-ZFBH4HD7.mjs';
-import './chunk-J5LGTIGS.mjs';
-import { concatHex, encodeFunctionData, encodeAbiParameters, createPublicClient, http, isAddress, zeroAddress, formatUnits } from 'viem';
+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-QVEW2DTE.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-QVEW2DTE.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-NCX4BO7G.mjs';
+import { concatHex, encodeFunctionData, encodeAbiParameters, createPublicClient, http, isAddress, zeroAddress, keccak256, 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';
@@ -357,7 +357,7 @@ async function withRetry(fn, maxRetries = 3, delayMs = 1e3, timeoutMs) {
   for (let i = 0; i < maxRetries; i++) {
     try {
       if (timeoutMs) {
-        const { withTimeout } = await import('./timeout-YLP3WHZF.mjs');
+        const { withTimeout } = await import('./timeout-7UJ6HZ4K.mjs');
         return await withTimeout(fn(), timeoutMs, `Operation timed out after ${timeoutMs}ms`);
       }
       return await fn();
@@ -852,7 +852,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.0_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.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
 var chainlink_default = {
   feeds: [
     {
@@ -1300,7 +1300,7 @@ var IntentOperations = class {
       }
     ];
     const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: orchestratorContext.abi,
         functionName: "signalIntent",
@@ -1310,7 +1310,7 @@ var IntentOperations = class {
     );
     return {
       to: orchestratorContext.address,
-      data,
+      data: data3,
       value: 0n,
       chainId: this.config.getChainId(),
       abi: orchestratorContext.abi,
@@ -1325,7 +1325,7 @@ var IntentOperations = class {
     });
     const args = [params.intentHash];
     const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: orchestratorContext.abi,
         functionName: "cancelIntent",
@@ -1335,7 +1335,7 @@ var IntentOperations = class {
     );
     return {
       to: orchestratorContext.address,
-      data,
+      data: data3,
       value: 0n,
       chainId: this.config.getChainId(),
       abi: orchestratorContext.abi,
@@ -1350,7 +1350,7 @@ var IntentOperations = class {
     });
     const args = [params.intentHash];
     const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: orchestratorContext.abi,
         functionName: "releaseFundsToPayer",
@@ -1360,7 +1360,7 @@ var IntentOperations = class {
     );
     return {
       to: orchestratorContext.address,
-      data,
+      data: data3,
       value: 0n,
       chainId: this.config.getChainId(),
       abi: orchestratorContext.abi,
@@ -1524,7 +1524,7 @@ var IntentOperations = class {
       }
     ];
     const { referrer } = params.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: orchestratorContext.abi,
         functionName: "fulfillIntent",
@@ -1534,7 +1534,7 @@ var IntentOperations = class {
     );
     return {
       to: orchestratorContext.address,
-      data,
+      data: data3,
       value: 0n,
       chainId: this.config.getChainId(),
       abi: orchestratorContext.abi,
@@ -1898,7 +1898,7 @@ var ProtocolViewerReader = class {
       if (inputCount === null) {
         throw new Error("Configured ProtocolViewer ABI does not expose getDeposit");
       }
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-WK2QPJH7.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-KB2FTOE6.mjs');
       if (inputCount >= 3) {
         return tryContexts(
           protocolViewerContexts,
@@ -1984,7 +1984,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-WK2QPJH7.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-KB2FTOE6.mjs');
     if (inputCount >= 2) {
       const requests = ids.map((id, index) => ({
         index,
@@ -2089,7 +2089,7 @@ var ProtocolViewerReader = class {
     if (!protocolViewerAddress || !protocolViewerAbi || inputCount === null) {
       return this.config.host.getPvAccountDepositsFromIndexer(owner);
     }
-    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-WK2QPJH7.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-KB2FTOE6.mjs');
     const { address, abi } = this.config.host.requireProtocolViewer();
     if (inputCount >= 2) {
       const readAndFilter = async (raw2) => {
@@ -2160,7 +2160,7 @@ var ProtocolViewerReader = class {
     if (protocolViewerEntries.length === 0) {
       throw new Error("ProtocolViewer not available for this network");
     }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-WK2QPJH7.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-KB2FTOE6.mjs');
     const intentsByHash = /* @__PURE__ */ new Map();
     let attemptedRead = false;
     let hadSuccessfulRead = false;
@@ -2268,7 +2268,7 @@ var ProtocolViewerReader = class {
     if (protocolViewerEntries.length === 0) {
       throw new Error("ProtocolViewer not available for this network");
     }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-WK2QPJH7.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-KB2FTOE6.mjs');
     let lastError;
     for (const pvEntry of protocolViewerEntries) {
       const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
@@ -3603,7 +3603,7 @@ var STAKING_STATE_QUERY = (
       updatedAtBlockNumber
       updatedAt
     }
-    ChargebackRiskWindow(
+    DisputeProtectionRiskWindow(
       where: { chainId: { _eq: $chainId }, policyAddress: { _eq: $policy } }
       order_by: { paymentMethod: asc }
     ) {
@@ -3618,6 +3618,107 @@ var STAKING_STATE_QUERY = (
       updatedAtBlockNumber
       updatedAt
     }
+    chain_metadata(where: { chain_id: { _eq: $chainId } }, limit: 1) {
+      chain_id
+      latest_processed_block
+    }
+  }
+`
+);
+var STAKE_LOCKS_QUERY = (
+  /* GraphQL */
+  `
+  query StakeLocks($where: StakeLock_bool_exp!, $limit: Int!) {
+    StakeLock(where: $where, order_by: [{ id: asc }], limit: $limit) {
+      id
+      chainId
+      vaultAddress
+      lockId
+      stakeOwner
+      initialAmount
+      currentAmount
+      maturesAt
+      status
+      unlockedAmount
+      claimedAmount
+      createdAt
+      updatedAtBlockNumber
+      updatedAt
+    }
+  }
+`
+);
+var STAKE_ACTIVITY_QUERY = (
+  /* GraphQL */
+  `
+  query StakeActivityPage($where: StakeActivity_bool_exp!, $limit: Int!) {
+    StakeActivity(
+      where: $where
+      order_by: [{ blockNumber: asc }, { logIndex: asc }, { id: asc }]
+      limit: $limit
+    ) {
+      id
+      chainId
+      vaultAddress
+      stakeOwner
+      taker
+      beneficiary
+      kind
+      lockId
+      counterparty
+      amount
+      previousAmount
+      stakeBalanceAfter
+      lockedStakeAfter
+      freeStakeAfter
+      claimableAfter
+      maturesAt
+      blockNumber
+      logIndex
+      timestamp
+    }
+  }
+`
+);
+var DISPUTE_PROTECTION_INTENTS_QUERY = (
+  /* GraphQL */
+  `
+  query FinalizedDisputeProtectionIntents($where: DisputeProtectionIntent_bool_exp!, $limit: Int!) {
+    DisputeProtectionIntent(
+      where: $where
+      order_by: [{ disputedAtBlockNumber: asc }, { disputedAtLogIndex: asc }, { id: asc }]
+      limit: $limit
+    ) {
+      id
+      chainId
+      policyAddress
+      intentHash
+      status
+      stakeOwner
+      depositor
+      taker
+      paymentMethod
+      amount
+      riskWindow
+      releaseEligibleAt
+      releaseAmount
+      isManualRelease
+      compensatedAmount
+      disputeId
+      openedAt
+      openedTxHash
+      cancelledAt
+      cancelledTxHash
+      settledAt
+      settledTxHash
+      releasedAt
+      releasedTxHash
+      disputedAt
+      disputedTxHash
+      disputedAtBlockNumber
+      disputedAtLogIndex
+      updatedAt
+    }
   }
 `
 );
@@ -4527,19 +4628,19 @@ async function apiGetPayeeDetails(req, baseApiUrl, timeoutMs) {
   });
 }
 async function apiValidatePayeeDetails(req, baseApiUrl, timeoutMs) {
-  const data = await apiFetch({
+  const data3 = await apiFetch({
     url: `${withApiBase(baseApiUrl)}/v2/makers/validate`,
     method: "POST",
     body: req,
     timeoutMs
   });
-  if (typeof data?.responseObject === "boolean") {
+  if (typeof data3?.responseObject === "boolean") {
     return {
-      ...data,
-      responseObject: { isValid: data.responseObject }
+      ...data3,
+      responseObject: { isValid: data3.responseObject }
     };
   }
-  return data;
+  return data3;
 }
 async function apiGetOwnerDeposits(req, apiKey, baseApiUrl, authToken, timeoutMs) {
   const escrowAddress = requireEscrowAddress(
@@ -5529,10 +5630,10 @@ var StakeOperations = class {
     return { address, abi, stakeToken };
   }
   getPolicyContract() {
-    const address = this.config.getChargebackPolicyAddress();
-    const abi = this.config.getChargebackPolicyAbi();
+    const address = this.config.getDisputeProtectionPolicyAddress();
+    const abi = this.config.getDisputeProtectionPolicyAbi();
     if (!address || !abi) {
-      throw new Error("ChargebackPolicy not available for this chain/environment");
+      throw new Error("DisputeProtectionPolicy not available for this chain/environment");
     }
     return { address, abi };
   }
@@ -5575,7 +5676,7 @@ var StakeOperations = class {
   getTakerAuthorization(stakeOwner, taker) {
     return this.read("authorizedTakers", [stakeOwner, taker]);
   }
-  /** Whether the policy is refusing new chargebackable admissions. */
+  /** Whether the policy is refusing new dispute-protected admissions. */
   getAdmissionsPaused() {
     return this.readPolicy("admissionsPaused");
   }
@@ -5586,9 +5687,9 @@ var StakeOperations = class {
   getRiskWindow(paymentMethodHash) {
     return this.readPolicy("getRiskWindow", [paymentMethodHash]);
   }
-  /** Whether a specific escrow deposit has opted into chargeback coverage. */
-  isChargebackEnabled(escrow, depositId) {
-    return this.readPolicy("isChargebackEnabled", [escrow, depositId]);
+  /** Whether a specific escrow deposit has opted into dispute protection. */
+  isDisputeProtectionEnabled(escrow, depositId) {
+    return this.readPolicy("isDisputeProtectionEnabled", [escrow, depositId]);
   }
   async getStakeVaultState(params) {
     const taker = params.taker ?? params.staker;
@@ -6338,6 +6439,8 @@ var IndexerRateManagerService = class {
     }
   }
 };
+var DEFAULT_PAGE_LIMIT = 50;
+var MAX_PAGE_LIMIT = 100;
 var ZERO_STAKE = {
   totalUsdc: "0",
   lockedUsdc: "0",
@@ -6358,6 +6461,262 @@ function normalizeDecimal(value, field) {
   }
   return value;
 }
+function normalizeOptionalDecimal(value, field) {
+  return value === null || value === void 0 ? null : normalizeDecimal(value, field);
+}
+function validateChainId(chainId) {
+  if (!Number.isInteger(chainId) || chainId <= 0) {
+    throw new ValidationError("chainId must be a positive integer", "chainId");
+  }
+}
+function validateLimit(limit) {
+  const resolved = limit ?? DEFAULT_PAGE_LIMIT;
+  if (!Number.isInteger(resolved) || resolved < 1 || resolved > MAX_PAGE_LIMIT) {
+    throw new ValidationError("limit must be an integer from 1 to 100", "limit");
+  }
+  return resolved;
+}
+function encodeCursor(prefix, value) {
+  const encoded = btoa(JSON.stringify(value)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `${prefix}.${encoded}`;
+}
+function decodeCursor(cursor, prefix, validate) {
+  try {
+    const encoded = cursor.slice(prefix.length + 1).replace(/-/g, "+").replace(/_/g, "/");
+    const padded = encoded.padEnd(Math.ceil(encoded.length / 4) * 4, "=");
+    if (!cursor.startsWith(`${prefix}.`) || encoded.length === 0) {
+      throw new Error("wrong cursor kind");
+    }
+    return validate(JSON.parse(atob(padded)));
+  } catch {
+    throw new ValidationError(`cursor must be a valid ${prefix} cursor`, "cursor");
+  }
+}
+function decodeLockCursor(cursor) {
+  return decodeCursor(cursor, "zkp2p-lock-v1", (value) => {
+    if (typeof value !== "object" || value === null || typeof Reflect.get(value, "id") !== "string") {
+      throw new Error("invalid lock cursor");
+    }
+    const id = Reflect.get(value, "id");
+    if (id.length === 0) throw new Error("invalid lock cursor");
+    return id;
+  });
+}
+function decodeEventCursor(cursor, prefix) {
+  return decodeCursor(cursor, prefix, (value) => {
+    if (typeof value !== "object" || value === null) throw new Error("invalid event cursor");
+    const blockNumber = Reflect.get(value, "blockNumber");
+    const logIndex = Reflect.get(value, "logIndex");
+    const id = Reflect.get(value, "id");
+    if (typeof blockNumber !== "string" || typeof logIndex !== "string" || typeof id !== "string") {
+      throw new Error("invalid event cursor");
+    }
+    if (id.length === 0) throw new Error("invalid event cursor");
+    return {
+      blockNumber: normalizeDecimal(blockNumber, "cursor.blockNumber"),
+      logIndex: normalizeDecimal(logIndex, "cursor.logIndex"),
+      id
+    };
+  });
+}
+function compareEventCursor(left, right) {
+  const leftBlock = BigInt(left.blockNumber);
+  const rightBlock = BigInt(right.blockNumber);
+  if (leftBlock !== rightBlock) return leftBlock < rightBlock ? -1 : 1;
+  const leftLog = BigInt(left.logIndex);
+  const rightLog = BigInt(right.logIndex);
+  if (leftLog !== rightLog) return leftLog < rightLog ? -1 : 1;
+  return left.id === right.id ? 0 : left.id < right.id ? -1 : 1;
+}
+function eventKeysetPredicate(cursor, blockField, logField) {
+  return {
+    _or: [
+      { [blockField]: { _gt: cursor.blockNumber } },
+      {
+        _and: [
+          { [blockField]: { _eq: cursor.blockNumber } },
+          { [logField]: { _gt: cursor.logIndex } }
+        ]
+      },
+      {
+        _and: [
+          { [blockField]: { _eq: cursor.blockNumber } },
+          { [logField]: { _eq: cursor.logIndex } },
+          { id: { _gt: cursor.id } }
+        ]
+      }
+    ]
+  };
+}
+var STAKE_LOCK_STATUSES = /* @__PURE__ */ new Set(["ACTIVE", "UNLOCKED", "RESOLVED"]);
+var STAKE_ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+  "DEPOSITED",
+  "WITHDRAWN",
+  "TAKER_AUTHORIZATION_UPDATED",
+  "STAKE_OWNER_SELECTED",
+  "LOCK_FUNDED",
+  "STAKE_LOCKED",
+  "STAKE_LOCK_INCREASED",
+  "STAKE_LOCK_RESIZED",
+  "STAKE_UNLOCKED",
+  "STAKE_LOCK_RESOLVED",
+  "CLAIM_CREATED",
+  "CLAIM_WITHDRAWN"
+]);
+function normalizeLockStatus(value, field) {
+  if (!STAKE_LOCK_STATUSES.has(value)) {
+    throw new Error(`${field} is not a supported stake lock status`);
+  }
+  return value;
+}
+function normalizeActivityKind(value, field) {
+  if (!STAKE_ACTIVITY_KINDS.has(value)) {
+    throw new Error(`${field} is not a supported stake activity kind`);
+  }
+  return value;
+}
+function latestLockAsOf(items) {
+  if (items.length === 0) return null;
+  const latest = items.reduce(
+    (current, item) => BigInt(item.updatedAtBlockNumber) > BigInt(current.updatedAtBlockNumber) ? item : current
+  );
+  return { blockNumber: latest.updatedAtBlockNumber, timestamp: latest.updatedAt };
+}
+function assertNonEmptyId(id, field) {
+  if (id.length === 0) throw new Error(`${field} must not be empty`);
+  return id;
+}
+function normalizeStakeLockRow(row, index, scope) {
+  const field = `StakeLock[${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 stakeOwner = normalizeAddress4(row.stakeOwner, `${field}.stakeOwner`);
+  if (stakeOwner !== scope.stakeOwner) {
+    throw new Error(`${field}.stakeOwner does not match the query`);
+  }
+  const status = normalizeLockStatus(row.status, `${field}.status`);
+  if (scope.status && status !== scope.status) {
+    throw new Error(`${field}.status does not match the query`);
+  }
+  return {
+    lockId: assertNonEmptyId(row.lockId, `${field}.lockId`),
+    stakeOwner,
+    initialAmount: normalizeDecimal(row.initialAmount, `${field}.initialAmount`),
+    currentAmount: normalizeDecimal(row.currentAmount, `${field}.currentAmount`),
+    maturesAt: normalizeDecimal(row.maturesAt, `${field}.maturesAt`),
+    status,
+    unlockedAmount: normalizeDecimal(row.unlockedAmount, `${field}.unlockedAmount`),
+    claimedAmount: normalizeDecimal(row.claimedAmount, `${field}.claimedAmount`),
+    createdAt: normalizeDecimal(row.createdAt, `${field}.createdAt`),
+    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`);
+  if (normalizeAddress4(row.vaultAddress, `${field}.vaultAddress`) !== scope.vaultAddress) {
+    throw new Error(`${field}.vaultAddress does not match the query`);
+  }
+  const stakeOwner = normalizeNullableAddress(row.stakeOwner, `${field}.stakeOwner`);
+  const taker = normalizeNullableAddress(row.taker, `${field}.taker`);
+  if (stakeOwner !== scope.merchant && taker !== scope.merchant) {
+    throw new Error(`${field} is not relevant to the requested merchant`);
+  }
+  const kind = normalizeActivityKind(row.kind, `${field}.kind`);
+  if (scope.kind && kind !== scope.kind) {
+    throw new Error(`${field}.kind does not match the query`);
+  }
+  const blockNumber = normalizeDecimal(row.blockNumber, `${field}.blockNumber`);
+  const logIndex = normalizeDecimal(row.logIndex, `${field}.logIndex`);
+  const id = assertNonEmptyId(row.id, `${field}.id`);
+  return {
+    item: {
+      stakeOwner,
+      taker,
+      beneficiary: normalizeNullableAddress(row.beneficiary, `${field}.beneficiary`),
+      kind,
+      lockId: row.lockId ?? null,
+      counterparty: normalizeNullableAddress(row.counterparty, `${field}.counterparty`),
+      amount: normalizeDecimal(row.amount, `${field}.amount`),
+      previousAmount: normalizeOptionalDecimal(row.previousAmount, `${field}.previousAmount`),
+      stakeBalanceAfter: normalizeOptionalDecimal(
+        row.stakeBalanceAfter,
+        `${field}.stakeBalanceAfter`
+      ),
+      lockedStakeAfter: normalizeOptionalDecimal(row.lockedStakeAfter, `${field}.lockedStakeAfter`),
+      freeStakeAfter: normalizeOptionalDecimal(row.freeStakeAfter, `${field}.freeStakeAfter`),
+      claimableAfter: normalizeOptionalDecimal(row.claimableAfter, `${field}.claimableAfter`),
+      maturesAt: normalizeOptionalDecimal(row.maturesAt, `${field}.maturesAt`),
+      blockNumber,
+      logIndex,
+      timestamp: normalizeDecimal(row.timestamp, `${field}.timestamp`)
+    },
+    cursor: { blockNumber, logIndex, id }
+  };
+}
+function normalizeDisputeRow(row, index, scope) {
+  const field = `DisputeProtectionIntent[${index}]`;
+  if (row.chainId !== scope.chainId) throw new Error(`${field}.chainId does not match the query`);
+  const policyAddress = normalizeAddress4(row.policyAddress, `${field}.policyAddress`);
+  if (policyAddress !== scope.policyAddress) {
+    throw new Error(`${field}.policyAddress does not match the query`);
+  }
+  if (row.status !== "DISPUTED") throw new Error(`${field}.status must be DISPUTED`);
+  if (row.disputedAtBlockNumber === null || row.disputedAtBlockNumber === void 0 || row.disputedAtLogIndex === null || row.disputedAtLogIndex === void 0 || row.disputedAt === null || row.disputedAt === void 0 || row.disputedTxHash === null || row.disputedTxHash === void 0) {
+    throw new Error(`${field} DISPUTED row must include its finalized event cursor`);
+  }
+  const blockNumber = normalizeDecimal(row.disputedAtBlockNumber, `${field}.disputedAtBlockNumber`);
+  if (BigInt(blockNumber) > BigInt(scope.throughBlockNumber)) {
+    throw new Error(`${field}.disputedAtBlockNumber exceeds throughBlockNumber`);
+  }
+  const logIndex = normalizeDecimal(row.disputedAtLogIndex, `${field}.disputedAtLogIndex`);
+  const disputedAt = normalizeDecimal(row.disputedAt, `${field}.disputedAt`);
+  const id = assertNonEmptyId(row.id, `${field}.id`);
+  return {
+    item: {
+      policyAddress,
+      intentHash: row.intentHash,
+      status: "DISPUTED",
+      stakeOwner: normalizeAddress4(row.stakeOwner, `${field}.stakeOwner`),
+      depositor: normalizeAddress4(row.depositor, `${field}.depositor`),
+      taker: normalizeAddress4(row.taker, `${field}.taker`),
+      paymentMethod: row.paymentMethod,
+      amount: normalizeDecimal(row.amount, `${field}.amount`),
+      riskWindow: normalizeDecimal(row.riskWindow, `${field}.riskWindow`),
+      releaseEligibleAt: normalizeOptionalDecimal(
+        row.releaseEligibleAt,
+        `${field}.releaseEligibleAt`
+      ),
+      releaseAmount: normalizeOptionalDecimal(row.releaseAmount, `${field}.releaseAmount`),
+      isManualRelease: row.isManualRelease ?? null,
+      compensatedAmount: normalizeOptionalDecimal(
+        row.compensatedAmount,
+        `${field}.compensatedAmount`
+      ),
+      disputeId: row.disputeId ?? null,
+      openedAt: normalizeDecimal(row.openedAt, `${field}.openedAt`),
+      openedTxHash: row.openedTxHash,
+      cancelledAt: normalizeOptionalDecimal(row.cancelledAt, `${field}.cancelledAt`),
+      cancelledTxHash: row.cancelledTxHash ?? null,
+      settledAt: normalizeOptionalDecimal(row.settledAt, `${field}.settledAt`),
+      settledTxHash: row.settledTxHash ?? null,
+      releasedAt: normalizeOptionalDecimal(row.releasedAt, `${field}.releasedAt`),
+      releasedTxHash: row.releasedTxHash ?? null,
+      disputedAt,
+      disputedTxHash: row.disputedTxHash,
+      disputedAtBlockNumber: blockNumber,
+      disputedAtLogIndex: logIndex,
+      updatedAt: normalizeDecimal(row.updatedAt, `${field}.updatedAt`)
+    },
+    cursor: { blockNumber, logIndex, id }
+  };
+}
 function freshnessOf(row, field) {
   if (!row) return null;
   return {
@@ -6368,19 +6727,25 @@ function freshnessOf(row, field) {
     updatedAt: normalizeDecimal(row.updatedAt, `${field}.updatedAt`)
   };
 }
-function minimumBlockNumber(rows) {
-  const blockNumbers = rows.filter((row) => row !== null).map((row) => BigInt(row.updatedAtBlockNumber));
-  if (blockNumbers.length === 0) return null;
-  return blockNumbers.reduce((minimum, block) => block < minimum ? block : minimum).toString();
+function indexerHeadBlockNumber(rows, chainId) {
+  const row = rows[0];
+  if (row === void 0) return null;
+  if (row.chain_id !== chainId) {
+    throw new Error("chain_metadata.chain_id does not match the query");
+  }
+  if (!Number.isSafeInteger(row.latest_processed_block) || row.latest_processed_block < 0) {
+    throw new Error("chain_metadata.latest_processed_block must be a non-negative safe integer");
+  }
+  return row.latest_processed_block.toString();
 }
 function buildStakingEntityIds(params) {
   if (!Number.isInteger(params.chainId) || params.chainId <= 0) {
     throw new ValidationError("chainId must be a positive integer", "chainId");
   }
   const vaultAddress = normalizeAddress4(params.vaultAddress, "vaultAddress");
-  const chargebackPolicyAddress = normalizeAddress4(
-    params.chargebackPolicyAddress,
-    "chargebackPolicyAddress"
+  const disputeProtectionPolicyAddress = normalizeAddress4(
+    params.disputeProtectionPolicyAddress,
+    "disputeProtectionPolicyAddress"
   );
   const taker = normalizeAddress4(params.taker, "taker");
   const stakeOwner = normalizeAddress4(params.stakeOwner, "stakeOwner");
@@ -6389,19 +6754,157 @@ function buildStakingEntityIds(params) {
     stakeAccountId: `${params.chainId}_${vaultAddress}_${stakeOwner}`,
     claimAccountId: `${params.chainId}_${vaultAddress}_${taker}`,
     vaultConfigId: `${params.chainId}_${vaultAddress}`,
-    policy: chargebackPolicyAddress
+    policy: disputeProtectionPolicyAddress
   };
 }
 var IndexerStakingService = class {
   constructor(client) {
     this.client = client;
   }
+  async fetchStakeLocks(params, init) {
+    validateChainId(params.chainId);
+    const limit = validateLimit(params.limit);
+    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 filters = [
+      { chainId: { _eq: params.chainId } },
+      { vaultAddress: { _eq: vaultAddress } },
+      { stakeOwner: { _eq: stakeOwner } }
+    ];
+    if (status) filters.push({ status: { _eq: status } });
+    if (afterId) filters.push({ id: { _gt: afterId } });
+    const data3 = await this.client.query(
+      {
+        query: STAKE_LOCKS_QUERY,
+        variables: { limit: limit + 1, where: { _and: filters } }
+      },
+      init
+    );
+    let previousId = afterId;
+    const normalized = data3.StakeLock.map((row, index) => {
+      const id = assertNonEmptyId(row.id, `StakeLock[${index}].id`);
+      if (previousId !== void 0 && id <= previousId) {
+        throw new Error("StakeLock cursor did not advance");
+      }
+      previousId = id;
+      return {
+        item: normalizeStakeLockRow(row, index, {
+          chainId: params.chainId,
+          vaultAddress,
+          stakeOwner,
+          status
+        }),
+        id
+      };
+    });
+    const visible = normalized.slice(0, limit);
+    const items = visible.map(({ item }) => item);
+    return {
+      items,
+      nextCursor: normalized.length > limit ? encodeCursor("zkp2p-lock-v1", { id: visible[visible.length - 1].id }) : null,
+      asOf: latestLockAsOf(items)
+    };
+  }
+  async fetchStakeActivity(params, init) {
+    validateChainId(params.chainId);
+    const limit = validateLimit(params.limit);
+    const vaultAddress = normalizeAddress4(params.vaultAddress, "vaultAddress");
+    const merchant = normalizeAddress4(params.merchant, "merchant");
+    const kind = params.kind ? normalizeActivityKind(params.kind, "kind") : void 0;
+    const after = params.cursor ? decodeEventCursor(params.cursor, "zkp2p-activity-v1") : void 0;
+    const filters = [
+      { chainId: { _eq: params.chainId } },
+      { vaultAddress: { _eq: vaultAddress } },
+      {
+        _or: [{ stakeOwner: { _eq: merchant } }, { taker: { _eq: merchant } }]
+      }
+    ];
+    if (kind) filters.push({ kind: { _eq: kind } });
+    if (after) filters.push(eventKeysetPredicate(after, "blockNumber", "logIndex"));
+    const data3 = await this.client.query(
+      {
+        query: STAKE_ACTIVITY_QUERY,
+        variables: { limit: limit + 1, where: { _and: filters } }
+      },
+      init
+    );
+    let previous = after;
+    const normalized = data3.StakeActivity.map((row, index) => {
+      const result = normalizeStakeActivityRow(row, index, {
+        chainId: params.chainId,
+        vaultAddress,
+        merchant,
+        kind
+      });
+      if (previous && compareEventCursor(result.cursor, previous) <= 0) {
+        throw new Error("StakeActivity cursor did not advance");
+      }
+      previous = result.cursor;
+      return result;
+    });
+    const visible = normalized.slice(0, limit);
+    const last = visible[visible.length - 1];
+    return {
+      items: visible.map(({ item }) => item),
+      nextCursor: normalized.length > limit && last ? encodeCursor("zkp2p-activity-v1", last.cursor) : null,
+      asOf: last ? { blockNumber: last.item.blockNumber, timestamp: last.item.timestamp } : null
+    };
+  }
+  async fetchDisputeProtectionIntents(params, init) {
+    validateChainId(params.chainId);
+    const limit = validateLimit(params.limit);
+    const policyAddress = normalizeAddress4(params.policyAddress, "policyAddress");
+    const throughBlockNumber = normalizeDecimal(params.throughBlockNumber, "throughBlockNumber");
+    const after = params.cursor ? decodeEventCursor(params.cursor, "zkp2p-dispute-v1") : void 0;
+    if (after && BigInt(after.blockNumber) > BigInt(throughBlockNumber)) {
+      throw new ValidationError("cursor exceeds throughBlockNumber", "cursor");
+    }
+    const filters = [
+      { chainId: { _eq: params.chainId } },
+      { policyAddress: { _eq: policyAddress } },
+      { status: { _eq: "DISPUTED" } },
+      { disputedAtBlockNumber: { _lte: throughBlockNumber } }
+    ];
+    if (after) {
+      filters.push(eventKeysetPredicate(after, "disputedAtBlockNumber", "disputedAtLogIndex"));
+    }
+    const data3 = await this.client.query(
+      {
+        query: DISPUTE_PROTECTION_INTENTS_QUERY,
+        variables: { limit: limit + 1, where: { _and: filters } }
+      },
+      init
+    );
+    let previous = after;
+    const normalized = data3.DisputeProtectionIntent.map((row, index) => {
+      const result = normalizeDisputeRow(row, index, {
+        chainId: params.chainId,
+        policyAddress,
+        throughBlockNumber
+      });
+      if (previous && compareEventCursor(result.cursor, previous) <= 0) {
+        throw new Error("DisputeProtectionIntent cursor did not advance");
+      }
+      previous = result.cursor;
+      return result;
+    });
+    const visible = normalized.slice(0, limit);
+    const last = visible[visible.length - 1];
+    return {
+      items: visible.map(({ item }) => item),
+      nextCursor: normalized.length > limit && last ? encodeCursor("zkp2p-dispute-v1", last.cursor) : null,
+      endCursor: last ? encodeCursor("zkp2p-dispute-v1", last.cursor) : null,
+      asOf: last ? { blockNumber: last.item.disputedAtBlockNumber, timestamp: last.item.disputedAt } : null
+    };
+  }
   async fetchStakingState(params, init) {
     const ids = buildStakingEntityIds(params);
     const vaultAddress = normalizeAddress4(params.vaultAddress, "vaultAddress");
     const taker = normalizeAddress4(params.taker, "taker");
     const requestedStakeOwner = normalizeAddress4(params.stakeOwner, "stakeOwner");
-    const data = await this.client.query(
+    const data3 = await this.client.query(
       {
         query: STAKING_STATE_QUERY,
         variables: {
@@ -6413,20 +6916,20 @@ var IndexerStakingService = class {
       },
       init
     );
-    const takerState = data.TakerStakeState_by_pk;
+    const takerState = data3.TakerStakeState_by_pk;
     const indexedStakeOwner = takerState ? normalizeAddress4(takerState.stakeOwner, "TakerStakeState.stakeOwner") : taker;
     const selectedStakeOwner = normalizeNullableAddress(
       takerState?.selectedStakeOwner,
       "TakerStakeState.selectedStakeOwner"
     );
-    const stakeAccount = data.StakeAccountState_by_pk;
+    const stakeAccount = data3.StakeAccountState_by_pk;
     const stakeAccountOwner = stakeAccount ? normalizeAddress4(stakeAccount.stakeOwner, "StakeAccountState.stakeOwner") : requestedStakeOwner;
     const stakeAccountMatchesEffectiveOwner = requestedStakeOwner === indexedStakeOwner && stakeAccountOwner === indexedStakeOwner;
-    const claimAccount = data.ClaimAccountState_by_pk;
+    const claimAccount = data3.ClaimAccountState_by_pk;
     if (claimAccount && normalizeAddress4(claimAccount.beneficiary, "ClaimAccountState.beneficiary") !== taker) {
       throw new Error("ClaimAccountState beneficiary does not match the requested taker");
     }
-    const authorizations = data.TakerStakeAuthorization.map((authorization, index) => ({
+    const authorizations = data3.TakerStakeAuthorization.map((authorization, index) => ({
       stakeOwner: normalizeAddress4(
         authorization.stakeOwner,
         `TakerStakeAuthorization[${index}].stakeOwner`
@@ -6437,18 +6940,18 @@ var IndexerStakingService = class {
         `TakerStakeAuthorization[${index}]`
       )
     }));
-    const riskWindows = data.ChargebackRiskWindow.map((row, index) => ({
+    const riskWindows = data3.DisputeProtectionRiskWindow.map((row, index) => ({
       paymentMethod: row.paymentMethod,
       riskWindowSeconds: normalizeDecimal(
         row.riskWindow,
-        `ChargebackRiskWindow[${index}].riskWindow`
+        `DisputeProtectionRiskWindow[${index}].riskWindow`
       ),
-      updatedAt: normalizeDecimal(row.updatedAt, `ChargebackRiskWindow[${index}].updatedAt`)
+      updatedAt: normalizeDecimal(row.updatedAt, `DisputeProtectionRiskWindow[${index}].updatedAt`)
     }));
     const takerFreshness = freshnessOf(takerState, "TakerStakeState");
     const stakeFreshness = freshnessOf(stakeAccount, "StakeAccountState");
     const claimFreshness = freshnessOf(claimAccount, "ClaimAccountState");
-    const vaultFreshness = freshnessOf(data.StakeVaultConfig_by_pk, "StakeVaultConfig");
+    const vaultFreshness = freshnessOf(data3.StakeVaultConfig_by_pk, "StakeVaultConfig");
     const authorizationFreshness = authorizations.map((authorization) => authorization.freshness);
     return {
       chainId: params.chainId,
@@ -6468,17 +6971,17 @@ var IndexerStakingService = class {
       claimableUsdc: claimAccount ? normalizeDecimal(claimAccount.claimableAmount, "ClaimAccountState.claimableAmount") : "0",
       authorizations,
       riskWindows,
-      vault: data.StakeVaultConfig_by_pk ? {
+      vault: data3.StakeVaultConfig_by_pk ? {
         controller: normalizeNullableAddress(
-          data.StakeVaultConfig_by_pk.controller,
+          data3.StakeVaultConfig_by_pk.controller,
           "StakeVaultConfig.controller"
         ),
         pendingController: normalizeNullableAddress(
-          data.StakeVaultConfig_by_pk.pendingController,
+          data3.StakeVaultConfig_by_pk.pendingController,
           "StakeVaultConfig.pendingController"
         ),
-        pendingControllerValidAt: data.StakeVaultConfig_by_pk.pendingControllerValidAt ? normalizeDecimal(
-          data.StakeVaultConfig_by_pk.pendingControllerValidAt,
+        pendingControllerValidAt: data3.StakeVaultConfig_by_pk.pendingControllerValidAt ? normalizeDecimal(
+          data3.StakeVaultConfig_by_pk.pendingControllerValidAt,
           "StakeVaultConfig.pendingControllerValidAt"
         ) : null
       } : null,
@@ -6489,18 +6992,1023 @@ var IndexerStakingService = class {
         claimAccountState: claimFreshness,
         stakeVaultConfig: vaultFreshness,
         authorizations: authorizationFreshness,
-        indexedBlockNumber: minimumBlockNumber([
-          takerFreshness,
-          stakeFreshness,
-          claimFreshness,
-          vaultFreshness,
-          ...authorizationFreshness
-        ])
+        indexerHeadBlockNumber: indexerHeadBlockNumber(data3.chain_metadata, params.chainId)
       }
     };
   }
 };
 
+// ../../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.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
+var data = {
+  "schemaVersion": 1,
+  "network": "base",
+  "chainId": 8453,
+  "activeDisputeStack": {
+    "version": 1,
+    "selectionHash": "a4f17ae7c1620ecfe7d036f0b9cc7b39c50e1382dc8dc14d2e5f7f21061cd5ad"
+  },
+  "runtimeIdentities": {
+    "Orchestrator": {
+      "address": "0x88888883Ed048FF0a415271B28b2F52d431810D0",
+      "runtimeCodeHash": "0xf511343f2903dd1877c490796cc9423fac66b162b59004d55e522046c1ceb050"
+    },
+    "OrchestratorV2": {
+      "address": "0x888888359E981B5225CA48fbCdCeff702FC3b888",
+      "runtimeCodeHash": "0xcf70a08cc24fcc00799f9f365d0998abe37c718c93ee370a78d1ca06c60d01e0"
+    },
+    "OrchestratorV3": {
+      "address": "0x014025fDE093f8701d86e9f38e2C3a9b779cb5c7",
+      "runtimeCodeHash": "0x4e58f26129559301c017ff264b61dd2255ed2107593d308472ef32d07b8745e9"
+    },
+    "StakeVault": {
+      "address": "0x4d16F4a9946CfC76b1c1A4B63aa9D94cdA2dbCEB",
+      "runtimeCodeHash": "0xfd8d2a910b9ac2c55675ae06d0504f9aac43b02b7022755cf229b571156c681d"
+    },
+    "DisputeProtectionPolicy": {
+      "address": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+      "runtimeCodeHash": "0x9c4be279da216021183638eaef79ebf98db248472685e9ecd0de3f24a513a641"
+    },
+    "IntentLifecycleHookV1": {
+      "address": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
+      "runtimeCodeHash": "0x35789014e608a248f3244b61210fa259fee3566c33f50fd0e3fa1f5ae22e370b"
+    },
+    "RecognizedPredecessorHook": {
+      "address": "0x251d78fb6bBb4071995Bce74bAfC9E4168638622",
+      "runtimeCodeHash": "0x03d02863ed5eaa096d4089cb1e126681c0621d99409124f4af5be7ed83e341fe"
+    },
+    "RecognizedPredecessorPolicy": {
+      "address": "0xc086b6120B5e61EF48221E6A78c69737c9948dF9",
+      "runtimeCodeHash": "0xf08bce9ad622b9d45ce310493627cbef3bf6c4ac915661d5bc572bb59b61e084"
+    },
+    "OrchestratorRegistry": {
+      "address": "0xBe9fED15ED7A4B915C03EFcEcb9662739C3382A9",
+      "runtimeCodeHash": "0xf0d132d621ac03181a6fade6a93bd0968d33830c8bf393793236787e7978aee1"
+    },
+    "WhitelistPolicy": {
+      "address": "0xBC53641b4B2504f0061D6a9426C61B8eBE9B4Ff0",
+      "runtimeCodeHash": "0xa3cf0fdf3835887de432cbac9c192edf6c93a8589748aa93f8294333d57024b2"
+    },
+    "DisputeVerifier": {
+      "address": "0x30d4947f005653637005eed991005119D9eB2f34",
+      "runtimeCodeHash": "0x65246e11392befc33d92246cf3ac2467d1f338a8b73c6514b76fab0a70a01ead"
+    },
+    "DisputeNullifierRegistry": {
+      "address": "0xA845615b5203F7a21321DdF5e3a1ca024D93a443",
+      "runtimeCodeHash": "0x1a711749b7700142265363c9c184c195ac81a1415e2142aa84edcbf1cd88142a"
+    },
+    "MultiAttestationVerifier": {
+      "address": "0x9Fe920b24e50e6a6362BA71a1BeB502A99c402d5",
+      "runtimeCodeHash": "0x828a5dae520d3eaed904dfed56994dc6e892eb6416b58ad952c079e220ef841a"
+    }
+  },
+  "addressExpectations": {
+    "AddressGroupRegistry": "0x39F80118f9eB619135f116171b6Cb91D372C5AF2",
+    "EscrowRegistry": "0xeD0e847B101abc96E796260AC358e12BAa2f5B21",
+    "PaymentVerifierRegistry": "0x2b82D24437ff66Fb173eabDfD67ee2ACeb8bEb1e",
+    "RelayerRegistry": "0xEbA979889a9c97382A92472fF3703786fF180083",
+    "NullifierRegistryV2": "0x5455e761b866dfa6A2f5Dc6d6525825bf9C09aeB",
+    "StakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "expectedRelations": {
+    "activeLifecycleHook": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
+    "recognizedPredecessorPolicy": "0xc086b6120B5e61EF48221E6A78c69737c9948dF9",
+    "registeredOrchestrator": "0x014025fDE093f8701d86e9f38e2C3a9b779cb5c7",
+    "authorizedLifecycleHook": "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970",
+    "disputeNullifierAuthorizedWriter": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+    "orchestratorEscrowRegistry": "0xeD0e847B101abc96E796260AC358e12BAa2f5B21",
+    "orchestratorPaymentVerifierRegistry": "0x2b82D24437ff66Fb173eabDfD67ee2ACeb8bEb1e",
+    "orchestratorRelayerRegistry": "0xEbA979889a9c97382A92472fF3703786fF180083",
+    "hookOrchestratorRegistry": "0xBe9fED15ED7A4B915C03EFcEcb9662739C3382A9",
+    "hookWhitelistPolicy": "0xBC53641b4B2504f0061D6a9426C61B8eBE9B4Ff0",
+    "hookDisputeProtectionPolicy": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+    "whitelistGroupRegistry": "0x39F80118f9eB619135f116171b6Cb91D372C5AF2",
+    "whitelistEscrowRegistry": "0xeD0e847B101abc96E796260AC358e12BAa2f5B21",
+    "whitelistOrchestratorRegistry": "0xBe9fED15ED7A4B915C03EFcEcb9662739C3382A9",
+    "policyStakeVault": "0x4d16F4a9946CfC76b1c1A4B63aa9D94cdA2dbCEB",
+    "policyDisputeVerifier": "0x30d4947f005653637005eed991005119D9eB2f34",
+    "policyDisputeNullifierRegistry": "0xA845615b5203F7a21321DdF5e3a1ca024D93a443",
+    "disputeVerifierNullifierRegistry": "0x5455e761b866dfa6A2f5Dc6d6525825bf9C09aeB",
+    "disputeVerifierAttestationVerifier": "0x9Fe920b24e50e6a6362BA71a1BeB502A99c402d5",
+    "vaultController": "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA",
+    "vaultStakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "expectedGovernance": {
+    "owner": "0x0bC26FF515411396DD588Abd6Ef6846E04470227",
+    "governedRuntimeIdentities": [
+      "OrchestratorRegistry",
+      "OrchestratorV3",
+      "StakeVault",
+      "DisputeProtectionPolicy",
+      "WhitelistPolicy",
+      "DisputeVerifier",
+      "DisputeNullifierRegistry",
+      "MultiAttestationVerifier"
+    ],
+    "pendingOwner": "0x0000000000000000000000000000000000000000",
+    "twoStepGovernedRuntimeIdentities": [
+      "StakeVault",
+      "DisputeProtectionPolicy",
+      "DisputeVerifier"
+    ]
+  },
+  "attestationTrust": {
+    "requiredSignatures": "1",
+    "witnesses": [
+      "0xDB4Ed7FAF170F0f6493E3adaaCaaFaF47092c754",
+      "0xE078D93bFdd87A8c5C5cCA5905DCbA0Dd7A1F0BD"
+    ]
+  },
+  "exactAuthorizationSets": {
+    "orchestratorAuthorizationFromBlock": "42878566",
+    "authorizedOrchestrators": [
+      "0x88888883Ed048FF0a415271B28b2F52d431810D0",
+      "0x888888359E981B5225CA48fbCdCeff702FC3b888",
+      "0x014025fDE093f8701d86e9f38e2C3a9b779cb5c7"
+    ],
+    "lifecycleHookAuthorizationFromBlock": "50201693",
+    "authorizedLifecycleHooks": [
+      "0x71467dCac3B50eeED5A485aC6a70f27B1EAC1970"
+    ],
+    "passiveDisputeNullifierWriters": [
+      "0xc086b6120B5e61EF48221E6A78c69737c9948dF9"
+    ],
+    "activeDisputeNullifierWriters": [
+      "0xcEc48F7242eDBf02875BB4629115Bd927e1287aA"
+    ]
+  },
+  "riskWindowSecondsByPaymentMethod": {
+    "0x10940ee67cfb3c6c064569ec92c0ee934cd7afa18dd2ca2d6a2254fcb009c17d": "1209600",
+    "0x3ccc3d4d5e769b1f82dc4988485551dc0cd3c7a3926d7d8a4dde91507199490f": "1209600",
+    "0x554a007c2217df766b977723b276671aee5ebb4adaea0edb6433c88b3e61dac5": "0",
+    "0x5908bb0c9b87763ac6171d4104847667e7f02b4c47b574fe890c1f439ed128bb": "0",
+    "0x617f88ab82b5c1b014c539f7e75121427f0bb50a4c58b187a238531e7d58605d": "0",
+    "0x62c7ed738ad3e7618111348af32691b5767777fbaf46a2d8943237625552645c": "0",
+    "0x90262a3db0edd0be2369c6b28f9e8511ec0bac7136cefbada0880602f87e7268": "1209600",
+    "0xa5418819c024239299ea32e09defae8ec412c03e58f5c75f1b2fe84c857f5483": "0",
+    "0xcac9daea62d7b89d75ac73af4ee14dcf25721012ae82b568c2ea5c808eaa04ff": "0",
+    "0xf752c7d19698ecb0bb8988abf9b9a53a4c3657f3bc8850a6fb59fdf3e3ce8cd3": "0"
+  },
+  "sentinel": {
+    "escrow": "0x0000000000000000000000000000000000000001",
+    "depositId": "0",
+    "expected": false
+  },
+  "prerequisites": {
+    "orchestratorPaused": false,
+    "admissionsPaused": false,
+    "allowMultipleIntents": true,
+    "orchestratorRegistered": true,
+    "lifecycleHookAuthorized": true,
+    "disputeNullifierWriterAuthorized": true,
+    "vaultControllerActivated": true,
+    "vaultPendingController": "0x0000000000000000000000000000000000000000",
+    "vaultPendingControllerValidAt": "0",
+    "pendingCoverageMaturity": "18446744073709551615"
+  }
+};
+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
+var data2 = {
+  "schemaVersion": 1,
+  "network": "base_staging",
+  "chainId": 8453,
+  "activeDisputeStack": {
+    "version": 1,
+    "selectionHash": "586c90f9de3d10b6d48f4286c709aa7f870fc2fdcfb0af1da947c1da76132dd0"
+  },
+  "runtimeIdentities": {
+    "Orchestrator": {
+      "address": "0xF9b9CD27Deea496B960b3cb5221b514705fCaF5e",
+      "runtimeCodeHash": "0xf511343f2903dd1877c490796cc9423fac66b162b59004d55e522046c1ceb050"
+    },
+    "OrchestratorV2": {
+      "address": "0xc17a59227B136c45fAa153086a15EF87ED14bE00",
+      "runtimeCodeHash": "0xcf70a08cc24fcc00799f9f365d0998abe37c718c93ee370a78d1ca06c60d01e0"
+    },
+    "OrchestratorV3": {
+      "address": "0x2b5E8Ab562e45fA89D73802605E145ED3E3EeF4f",
+      "runtimeCodeHash": "0x4e58f26129559301c017ff264b61dd2255ed2107593d308472ef32d07b8745e9"
+    },
+    "StakeVault": {
+      "address": "0x01075fdCB8D38fD5A1070db41B3c00DC2459e71e",
+      "runtimeCodeHash": "0xfd8d2a910b9ac2c55675ae06d0504f9aac43b02b7022755cf229b571156c681d"
+    },
+    "DisputeProtectionPolicy": {
+      "address": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+      "runtimeCodeHash": "0xa4c6a33333e10da596805b6127e96f78e40fe5a0f0ab0cfa8f4683fbeac91a37"
+    },
+    "IntentLifecycleHookV1": {
+      "address": "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36",
+      "runtimeCodeHash": "0x376364aa8b693ee8e02eacc48527114ce3cc529714be5a3f316c7323561721ab"
+    },
+    "RecognizedPredecessorHook": {
+      "address": "0x19D9F0Fcb08C60D8bd0CD061C34eae27eF8b6e65",
+      "runtimeCodeHash": "0xba70239e37624f5808e2f79e100e83a17daeb1558f310543187f5d8a121ec367"
+    },
+    "RecognizedPredecessorPolicy": {
+      "address": "0x21517b7743E727ae47A66FafF93550B689c15020",
+      "runtimeCodeHash": "0x4e6617a94819ad15693289b173a9a66a78cfe1dd706f6b4fdc5a5f6ad6a32971"
+    },
+    "OrchestratorRegistry": {
+      "address": "0xfA6384EB6176cfEC049540526A3d2126C3666d8A",
+      "runtimeCodeHash": "0xf0d132d621ac03181a6fade6a93bd0968d33830c8bf393793236787e7978aee1"
+    },
+    "WhitelistPolicy": {
+      "address": "0x7d9277cb8bb78a51eeaafB7CFF306E7DA4C972fD",
+      "runtimeCodeHash": "0x917965fdc75580147ad0787c86f8b2a0f0185ef6e101567b82dc1245d6eb63bc"
+    },
+    "DisputeVerifier": {
+      "address": "0x973578148c5Fd49b9f68B50B26066555325AC708",
+      "runtimeCodeHash": "0xb3b34734cfd162cd129d0c84285461c751321545213ec20164745b8e72f9dd6c"
+    },
+    "DisputeNullifierRegistry": {
+      "address": "0xE0B05a9655AF0f31E32904267baa50FbC7f217ea",
+      "runtimeCodeHash": "0x1a711749b7700142265363c9c184c195ac81a1415e2142aa84edcbf1cd88142a"
+    },
+    "MultiAttestationVerifier": {
+      "address": "0x9855a39aC5975069632e91160d8712CBfF19e864",
+      "runtimeCodeHash": "0x828a5dae520d3eaed904dfed56994dc6e892eb6416b58ad952c079e220ef841a"
+    }
+  },
+  "addressExpectations": {
+    "AddressGroupRegistry": "0x54Ff7788Cb42B46FE2F016a65Fd0f654Bb9BcF3D",
+    "EscrowRegistry": "0xc545f336eC77E69bf115729acCbf2e557A00ac91",
+    "PaymentVerifierRegistry": "0x2261416DA54C85f975C73FA56EF4D2D6b0aEF7Cc",
+    "RelayerRegistry": "0xB214650b424E6b5fdcB1259566eB7A512D8Bd25E",
+    "NullifierRegistryV2": "0x2eb43d6C7c7Ec4220Aa6B8735BC053824a71778C",
+    "StakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "expectedRelations": {
+    "activeLifecycleHook": "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36",
+    "recognizedPredecessorPolicy": "0x21517b7743E727ae47A66FafF93550B689c15020",
+    "registeredOrchestrator": "0x2b5E8Ab562e45fA89D73802605E145ED3E3EeF4f",
+    "authorizedLifecycleHook": "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36",
+    "disputeNullifierAuthorizedWriter": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+    "orchestratorEscrowRegistry": "0xc545f336eC77E69bf115729acCbf2e557A00ac91",
+    "orchestratorPaymentVerifierRegistry": "0x2261416DA54C85f975C73FA56EF4D2D6b0aEF7Cc",
+    "orchestratorRelayerRegistry": "0xB214650b424E6b5fdcB1259566eB7A512D8Bd25E",
+    "hookOrchestratorRegistry": "0xfA6384EB6176cfEC049540526A3d2126C3666d8A",
+    "hookWhitelistPolicy": "0x7d9277cb8bb78a51eeaafB7CFF306E7DA4C972fD",
+    "hookDisputeProtectionPolicy": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+    "whitelistGroupRegistry": "0x54Ff7788Cb42B46FE2F016a65Fd0f654Bb9BcF3D",
+    "whitelistEscrowRegistry": "0xc545f336eC77E69bf115729acCbf2e557A00ac91",
+    "whitelistOrchestratorRegistry": "0xfA6384EB6176cfEC049540526A3d2126C3666d8A",
+    "policyStakeVault": "0x01075fdCB8D38fD5A1070db41B3c00DC2459e71e",
+    "policyDisputeVerifier": "0x973578148c5Fd49b9f68B50B26066555325AC708",
+    "policyDisputeNullifierRegistry": "0xE0B05a9655AF0f31E32904267baa50FbC7f217ea",
+    "disputeVerifierNullifierRegistry": "0x2eb43d6C7c7Ec4220Aa6B8735BC053824a71778C",
+    "disputeVerifierAttestationVerifier": "0x9855a39aC5975069632e91160d8712CBfF19e864",
+    "vaultController": "0x51436B8051cCf52739A2090C29DA208B70eC2663",
+    "vaultStakeToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "expectedGovernance": {
+    "owner": "0x84e113087C97Cd80eA9D78983D4B8Ff61ECa1929",
+    "governedRuntimeIdentities": [
+      "OrchestratorRegistry",
+      "OrchestratorV3",
+      "StakeVault",
+      "DisputeProtectionPolicy",
+      "WhitelistPolicy",
+      "DisputeVerifier",
+      "DisputeNullifierRegistry",
+      "MultiAttestationVerifier"
+    ],
+    "pendingOwner": "0x0000000000000000000000000000000000000000",
+    "twoStepGovernedRuntimeIdentities": [
+      "StakeVault",
+      "DisputeProtectionPolicy",
+      "DisputeVerifier"
+    ]
+  },
+  "attestationTrust": {
+    "requiredSignatures": "1",
+    "witnesses": [
+      "0x66649F896521b0fb487fE2077b4FBDA283d7f19a",
+      "0x4ab950AE1e3326578Bf7e643a2031E858aBa2927"
+    ]
+  },
+  "exactAuthorizationSets": {
+    "orchestratorAuthorizationFromBlock": "42614859",
+    "authorizedOrchestrators": [
+      "0xF9b9CD27Deea496B960b3cb5221b514705fCaF5e",
+      "0xc17a59227B136c45fAa153086a15EF87ED14bE00",
+      "0x2b5E8Ab562e45fA89D73802605E145ED3E3EeF4f"
+    ],
+    "lifecycleHookAuthorizationFromBlock": "50201496",
+    "authorizedLifecycleHooks": [
+      "0x3AB0879499b28e03bfcA4F5bC2CBe2070Fba4E36"
+    ],
+    "passiveDisputeNullifierWriters": [
+      "0x21517b7743E727ae47A66FafF93550B689c15020"
+    ],
+    "activeDisputeNullifierWriters": [
+      "0x51436B8051cCf52739A2090C29DA208B70eC2663"
+    ]
+  },
+  "riskWindowSecondsByPaymentMethod": {
+    "0x10940ee67cfb3c6c064569ec92c0ee934cd7afa18dd2ca2d6a2254fcb009c17d": "1209600",
+    "0x1d966dbd6aeb8674d7c05174bd0ded7b56a798672bfb862ef20bbe8c2bbfce18": "0",
+    "0x3ccc3d4d5e769b1f82dc4988485551dc0cd3c7a3926d7d8a4dde91507199490f": "1209600",
+    "0x554a007c2217df766b977723b276671aee5ebb4adaea0edb6433c88b3e61dac5": "0",
+    "0x5908bb0c9b87763ac6171d4104847667e7f02b4c47b574fe890c1f439ed128bb": "0",
+    "0x617f88ab82b5c1b014c539f7e75121427f0bb50a4c58b187a238531e7d58605d": "0",
+    "0x62c7ed738ad3e7618111348af32691b5767777fbaf46a2d8943237625552645c": "0",
+    "0x90262a3db0edd0be2369c6b28f9e8511ec0bac7136cefbada0880602f87e7268": "1209600",
+    "0xa5418819c024239299ea32e09defae8ec412c03e58f5c75f1b2fe84c857f5483": "0",
+    "0xcac9daea62d7b89d75ac73af4ee14dcf25721012ae82b568c2ea5c808eaa04ff": "0",
+    "0xf752c7d19698ecb0bb8988abf9b9a53a4c3657f3bc8850a6fb59fdf3e3ce8cd3": "0",
+    "0xf81480907d808d639ad3230869e4b05a3b01b2d34e323af40f2efab807effd32": "0"
+  },
+  "sentinel": {
+    "escrow": "0x0000000000000000000000000000000000000001",
+    "depositId": "0",
+    "expected": false
+  },
+  "prerequisites": {
+    "orchestratorPaused": false,
+    "admissionsPaused": false,
+    "allowMultipleIntents": true,
+    "orchestratorRegistered": true,
+    "lifecycleHookAuthorized": true,
+    "disputeNullifierWriterAuthorized": true,
+    "vaultControllerActivated": true,
+    "vaultPendingController": "0x0000000000000000000000000000000000000000",
+    "vaultPendingControllerValidAt": "0",
+    "pendingCoverageMaturity": "18446744073709551615"
+  }
+};
+var baseStaging_default = data2;
+
+// src/buildMetadata.ts
+var DEVELOPMENT_BUILD_METADATA = {
+  schemaVersion: 1,
+  source: {
+    repository: "zkp2p/zkp2p-clients",
+    commitSha: "development",
+    kind: "development",
+    distributable: false
+  },
+  sdkPackageVersion: "development",
+  contractsPackageVersion: "development",
+  indexerSchemaPackageVersion: "development",
+  activeDisputeStack: {
+    base: { version: 1, selectionHash: "development" },
+    baseStaging: { version: 1, 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 SUCCESSOR_RUNTIME_IDENTITIES = [
+  "IntentLifecycleHookV1",
+  "StakeVault",
+  "DisputeProtectionPolicy",
+  "OrchestratorRegistry",
+  "WhitelistPolicy",
+  "DisputeVerifier",
+  "DisputeNullifierRegistry",
+  "MultiAttestationVerifier"
+];
+var GOVERNANCE_ABIS = {
+  OrchestratorRegistry: OrchestratorRegistry_default,
+  OrchestratorV3: OrchestratorV3_default,
+  StakeVault: StakeVault_default,
+  DisputeProtectionPolicy: DisputeProtectionPolicy_default,
+  WhitelistPolicy: WhitelistPolicy_default,
+  DisputeVerifier: DisputeVerifier_default,
+  DisputeNullifierRegistry: DisputeNullifierRegistry_default,
+  MultiAttestationVerifier: MultiAttestationVerifier_default
+};
+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(
+  (item) => item.type === "event" && item.name === "LifecycleHookAuthorizationUpdated"
+);
+var FALLBACK_LOG_BLOCK_SPAN = 10000n;
+var LOG_QUERY_CONCURRENCY = 8;
+var ReadinessMismatch = class extends Error {
+};
+function sameAddress(actual, expected) {
+  return typeof actual === "string" && actual.toLowerCase() === expected.toLowerCase();
+}
+function expectAddress(label, actual, expected) {
+  if (!sameAddress(actual, expected)) throw new ReadinessMismatch(`${label} mismatch`);
+}
+function expectBoolean(label, actual, expected) {
+  if (actual !== expected) throw new ReadinessMismatch(`${label} expected ${String(expected)}`);
+}
+function expectBigInt(label, actual, expected) {
+  if (actual !== expected) throw new ReadinessMismatch(`${label} mismatch`);
+}
+function normalizeAddressSet(label, addresses) {
+  if (!Array.isArray(addresses) || addresses.some((address) => typeof address !== "string")) {
+    throw new ReadinessMismatch(`${label} is not an address array`);
+  }
+  const normalized = addresses.map((address) => address.toLowerCase()).sort();
+  if (new Set(normalized).size !== normalized.length) {
+    throw new ReadinessMismatch(`${label} contains duplicate addresses`);
+  }
+  return normalized;
+}
+function expectAddressSet(label, actual, expected) {
+  const actualAddresses = normalizeAddressSet(label, actual);
+  const expectedAddresses = normalizeAddressSet(label, expected);
+  if (actualAddresses.length !== expectedAddresses.length || actualAddresses.some((address, index) => address !== expectedAddresses[index])) {
+    throw new ReadinessMismatch(`${label} mismatch`);
+  }
+}
+function fallbackBlockRanges(fromBlock, toBlock) {
+  const ranges = [];
+  for (let start = fromBlock; start <= toBlock; start += FALLBACK_LOG_BLOCK_SPAN) {
+    const end = start + FALLBACK_LOG_BLOCK_SPAN - 1n;
+    ranges.push([start, end < toBlock ? end : toBlock]);
+  }
+  return ranges;
+}
+function isLogRangeLimitError(cause) {
+  let error = cause;
+  while (error instanceof Error) {
+    if (/(?:block range.{0,40}(?:too (?:large|wide)|exceed|limit)|limited to.{0,40}(?:blocks?|range)|response size exceeded|query returned more than|too many (?:logs|results)|maximum block range)/i.test(
+      error.message
+    )) {
+      return true;
+    }
+    error = error.cause;
+  }
+  return false;
+}
+function compareAuthorizationEvents(left, right) {
+  if ((left.blockNumber ?? 0n) !== (right.blockNumber ?? 0n)) {
+    return (left.blockNumber ?? 0n) < (right.blockNumber ?? 0n) ? -1 : 1;
+  }
+  if ((left.transactionIndex ?? 0) !== (right.transactionIndex ?? 0)) {
+    return (left.transactionIndex ?? 0) - (right.transactionIndex ?? 0);
+  }
+  return (left.logIndex ?? 0) - (right.logIndex ?? 0);
+}
+function replayAddressAuthorizations(label, events, addressField, enabledField) {
+  const authorized = /* @__PURE__ */ new Set();
+  for (const event of [...events].sort(compareAuthorizationEvents)) {
+    const address = event.args?.[addressField];
+    if (typeof address !== "string") {
+      throw new ReadinessMismatch(`${label} event address is malformed`);
+    }
+    const normalized = address.toLowerCase();
+    const enabled = enabledField ? event.args?.[enabledField] : event.args?.enabled;
+    if (typeof enabled !== "boolean") {
+      throw new ReadinessMismatch(`${label} event authorization is malformed`);
+    }
+    if (enabled) authorized.add(normalized);
+    else authorized.delete(normalized);
+  }
+  return [...authorized];
+}
+function manifestForEnvironment(environment) {
+  return environment === "staging" ? baseStaging_default : base_default;
+}
+function validatePackagedIdentity(config) {
+  const { buildMetadata, chainId, contractsPackageVersion, manifest } = config;
+  if (!buildMetadata.source.distributable) return "SDK build metadata is not distributable";
+  if (buildMetadata.source.kind !== "github" || buildMetadata.source.repository !== "zkp2p/zkp2p-clients" || !/^[0-9a-f]{40}$/.test(buildMetadata.source.commitSha)) {
+    return "SDK build source identity is invalid";
+  }
+  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") {
+    return "dispute readiness manifest chain identity mismatch";
+  }
+  const selected = manifest.network === "base" ? buildMetadata.activeDisputeStack.base : buildMetadata.activeDisputeStack.baseStaging;
+  if (selected.version !== manifest.activeDisputeStack.version || selected.selectionHash !== manifest.activeDisputeStack.selectionHash) {
+    return "active dispute manifest selection does not match SDK build metadata";
+  }
+  return null;
+}
+function knownResult(state, readyForDisputeProtection, blockNumber, config, lifecycleHook, paused, allowMultipleIntents, policyAdmissionsPaused) {
+  return {
+    state,
+    readyForDisputeProtection,
+    asOfBlock: blockNumber,
+    manifestNetwork: config.manifest.network,
+    manifestSelectionHash: config.manifest.activeDisputeStack.selectionHash,
+    contractsPackageVersion: config.contractsPackageVersion,
+    activeLifecycleHook: lifecycleHook,
+    orchestratorPaused: paused,
+    allowMultipleIntents,
+    policyAdmissionsPaused
+  };
+}
+var DisputeProtectionReadinessReader = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async verifyRuntimeIdentities(names, blockNumber) {
+    await Promise.all(
+      names.map(async (name) => {
+        const identity = this.config.manifest.runtimeIdentities[name];
+        const bytecode = await this.config.publicClient.getBytecode({
+          address: identity.address,
+          blockNumber
+        });
+        if (!bytecode || bytecode === "0x") {
+          throw new ReadinessMismatch(`${name} runtime bytecode unavailable`);
+        }
+        if (keccak256(bytecode).toLowerCase() !== identity.runtimeCodeHash.toLowerCase()) {
+          throw new ReadinessMismatch(`${name} runtime code hash mismatch`);
+        }
+      })
+    );
+  }
+  async readOrchestrator(blockNumber) {
+    const { manifest, publicClient } = this.config;
+    const orchestrator = manifest.runtimeIdentities.OrchestratorV3.address;
+    const result = await publicClient.multicall({
+      allowFailure: false,
+      blockNumber,
+      contracts: [
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "lifecycleHook" },
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "paused" },
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "allowMultipleIntents" },
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "chainId" },
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "escrowRegistry" },
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "paymentVerifierRegistry" },
+        { address: orchestrator, abi: OrchestratorV3_default, functionName: "relayerRegistry" }
+      ]
+    });
+    const lifecycleHook = result[0];
+    if (typeof lifecycleHook !== "string") {
+      throw new ReadinessMismatch("OrchestratorV3.lifecycleHook is not an address");
+    }
+    expectBigInt("OrchestratorV3.chainId", result[3], BigInt(manifest.chainId));
+    expectAddress(
+      "OrchestratorV3.escrowRegistry",
+      result[4],
+      manifest.expectedRelations.orchestratorEscrowRegistry
+    );
+    expectAddress(
+      "OrchestratorV3.paymentVerifierRegistry",
+      result[5],
+      manifest.expectedRelations.orchestratorPaymentVerifierRegistry
+    );
+    expectAddress(
+      "OrchestratorV3.relayerRegistry",
+      result[6],
+      manifest.expectedRelations.orchestratorRelayerRegistry
+    );
+    if (typeof result[1] !== "boolean" || typeof result[2] !== "boolean") {
+      throw new ReadinessMismatch("OrchestratorV3 readiness flags are malformed");
+    }
+    return {
+      lifecycleHook: lifecycleHook.toLowerCase(),
+      paused: result[1],
+      allowMultipleIntents: result[2]
+    };
+  }
+  async verifyGovernance(blockNumber) {
+    const { manifest, publicClient } = this.config;
+    const governance = manifest.expectedGovernance;
+    const ownerContracts = governance.governedRuntimeIdentities.map((name) => ({
+      address: manifest.runtimeIdentities[name].address,
+      abi: GOVERNANCE_ABIS[name],
+      functionName: "owner"
+    }));
+    const pendingOwnerContracts = governance.twoStepGovernedRuntimeIdentities.map((name) => ({
+      address: manifest.runtimeIdentities[name].address,
+      abi: GOVERNANCE_ABIS[name],
+      functionName: "pendingOwner"
+    }));
+    const results = await publicClient.multicall({
+      allowFailure: false,
+      blockNumber,
+      contracts: [...ownerContracts, ...pendingOwnerContracts]
+    });
+    governance.governedRuntimeIdentities.forEach((name, index) => {
+      expectAddress(`${name}.owner`, results[index], governance.owner);
+    });
+    governance.twoStepGovernedRuntimeIdentities.forEach((name, index) => {
+      expectAddress(
+        `${name}.pendingOwner`,
+        results[ownerContracts.length + index],
+        governance.pendingOwner
+      );
+    });
+  }
+  async verifyAttestationTrust(blockNumber) {
+    const { manifest, publicClient } = this.config;
+    const verifier = manifest.runtimeIdentities.MultiAttestationVerifier.address;
+    const results = await publicClient.multicall({
+      allowFailure: false,
+      blockNumber,
+      contracts: [
+        {
+          address: verifier,
+          abi: MultiAttestationVerifier_default,
+          functionName: "requiredSignatures"
+        },
+        { address: verifier, abi: MultiAttestationVerifier_default, functionName: "witnesses" }
+      ]
+    });
+    expectBigInt(
+      "MultiAttestationVerifier.requiredSignatures",
+      results[0],
+      BigInt(manifest.attestationTrust.requiredSignatures)
+    );
+    expectAddressSet(
+      "MultiAttestationVerifier.witnesses",
+      results[1],
+      manifest.attestationTrust.witnesses
+    );
+  }
+  async readAuthorizationEvents(params) {
+    if (params.fromBlock > params.toBlock) {
+      throw new ReadinessMismatch("authorization event range is invalid");
+    }
+    let logs;
+    try {
+      logs = await this.readAuthorizationEventRange(params, params.fromBlock, params.toBlock);
+    } catch (cause) {
+      if (!isLogRangeLimitError(cause)) throw cause;
+      const ranges = fallbackBlockRanges(params.fromBlock, params.toBlock);
+      const batches = [];
+      for (let index = 0; index < ranges.length; index += LOG_QUERY_CONCURRENCY) {
+        const batch = await Promise.all(
+          ranges.slice(index, index + LOG_QUERY_CONCURRENCY).map(
+            ([fromBlock, toBlock]) => this.readAuthorizationEventRange(params, fromBlock, toBlock)
+          )
+        );
+        batches.push(...batch);
+      }
+      logs = batches.flat();
+    }
+    return logs;
+  }
+  async readAuthorizationEventRange(params, fromBlock, toBlock) {
+    const logs = await this.config.publicClient.getLogs({
+      address: params.address,
+      events: params.events,
+      fromBlock,
+      toBlock,
+      strict: true
+    });
+    return logs.map((event) => ({
+      eventName: event.eventName,
+      blockNumber: event.blockNumber,
+      transactionIndex: event.transactionIndex,
+      logIndex: event.logIndex,
+      args: event.args
+    }));
+  }
+  async verifyExactAuthorizationSets(blockNumber, successorActive) {
+    const { manifest, publicClient } = this.config;
+    const identities = manifest.runtimeIdentities;
+    const authorizations = manifest.exactAuthorizationSets;
+    const [orchestratorEvents, lifecycleHookEvents, writers] = await Promise.all([
+      this.readAuthorizationEvents({
+        address: identities.OrchestratorRegistry.address,
+        events: ORCHESTRATOR_AUTHORIZATION_EVENTS,
+        fromBlock: BigInt(authorizations.orchestratorAuthorizationFromBlock),
+        toBlock: blockNumber
+      }),
+      this.readAuthorizationEvents({
+        address: identities.DisputeProtectionPolicy.address,
+        events: LIFECYCLE_HOOK_AUTHORIZATION_EVENTS,
+        fromBlock: BigInt(authorizations.lifecycleHookAuthorizationFromBlock),
+        toBlock: blockNumber
+      }),
+      publicClient.readContract({
+        address: identities.DisputeNullifierRegistry.address,
+        abi: DisputeNullifierRegistry_default,
+        functionName: "getWriters",
+        blockNumber
+      })
+    ]);
+    const orchestratorAuthorizationEvents = orchestratorEvents.map((event) => {
+      if (event.eventName !== "OrchestratorAdded" && event.eventName !== "OrchestratorRemoved") {
+        throw new ReadinessMismatch("OrchestratorRegistry authorization event is malformed");
+      }
+      return {
+        ...event,
+        args: {
+          orchestrator: event.args?.orchestrator,
+          enabled: event.eventName === "OrchestratorAdded"
+        }
+      };
+    });
+    const orchestrators = replayAddressAuthorizations(
+      "OrchestratorRegistry authorization",
+      orchestratorAuthorizationEvents,
+      "orchestrator"
+    );
+    const lifecycleHooks = replayAddressAuthorizations(
+      "DisputeProtectionPolicy lifecycle authorization",
+      lifecycleHookEvents,
+      "hook",
+      "isAuthorized"
+    );
+    expectAddressSet(
+      "OrchestratorRegistry authorized orchestrators",
+      orchestrators,
+      authorizations.authorizedOrchestrators
+    );
+    expectAddressSet(
+      "DisputeProtectionPolicy authorized lifecycle hooks",
+      lifecycleHooks,
+      authorizations.authorizedLifecycleHooks
+    );
+    expectAddressSet(
+      "DisputeNullifierRegistry writers",
+      writers,
+      successorActive ? authorizations.activeDisputeNullifierWriters : authorizations.passiveDisputeNullifierWriters
+    );
+  }
+  async verifySuccessorState(blockNumber, successorActive) {
+    const { manifest, publicClient } = this.config;
+    const identities = manifest.runtimeIdentities;
+    const relations = manifest.expectedRelations;
+    const prerequisite = manifest.prerequisites;
+    const policy = identities.DisputeProtectionPolicy.address;
+    const riskWindows = Object.entries(manifest.riskWindowSecondsByPaymentMethod).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
+    const contracts = [
+      {
+        address: identities.IntentLifecycleHookV1.address,
+        abi: IntentLifecycleHookV1_default,
+        functionName: "orchestratorRegistry"
+      },
+      {
+        address: identities.IntentLifecycleHookV1.address,
+        abi: IntentLifecycleHookV1_default,
+        functionName: "whitelistPolicy"
+      },
+      {
+        address: identities.IntentLifecycleHookV1.address,
+        abi: IntentLifecycleHookV1_default,
+        functionName: "disputeProtectionPolicy"
+      },
+      {
+        address: identities.OrchestratorRegistry.address,
+        abi: OrchestratorRegistry_default,
+        functionName: "isOrchestrator",
+        args: [relations.registeredOrchestrator]
+      },
+      {
+        address: identities.WhitelistPolicy.address,
+        abi: WhitelistPolicy_default,
+        functionName: "groupRegistry"
+      },
+      {
+        address: identities.WhitelistPolicy.address,
+        abi: WhitelistPolicy_default,
+        functionName: "escrowRegistry"
+      },
+      {
+        address: identities.WhitelistPolicy.address,
+        abi: WhitelistPolicy_default,
+        functionName: "orchestratorRegistry"
+      },
+      { address: policy, abi: DisputeProtectionPolicy_default, functionName: "stakeVault" },
+      { address: policy, abi: DisputeProtectionPolicy_default, functionName: "disputeVerifier" },
+      {
+        address: policy,
+        abi: DisputeProtectionPolicy_default,
+        functionName: "disputeNullifierRegistry"
+      },
+      {
+        address: policy,
+        abi: DisputeProtectionPolicy_default,
+        functionName: "isLifecycleHookAuthorized",
+        args: [relations.authorizedLifecycleHook]
+      },
+      { address: policy, abi: DisputeProtectionPolicy_default, functionName: "admissionsPaused" },
+      {
+        address: policy,
+        abi: DisputeProtectionPolicy_default,
+        functionName: "PENDING_COVERAGE_MATURITY"
+      },
+      {
+        address: policy,
+        abi: DisputeProtectionPolicy_default,
+        functionName: "isDisputeProtectionEnabled",
+        args: [manifest.sentinel.escrow, BigInt(manifest.sentinel.depositId)]
+      },
+      ...riskWindows.map(([paymentMethod]) => ({
+        address: policy,
+        abi: DisputeProtectionPolicy_default,
+        functionName: "getRiskWindow",
+        args: [paymentMethod]
+      })),
+      {
+        address: identities.DisputeVerifier.address,
+        abi: DisputeVerifier_default,
+        functionName: "nullifierRegistry"
+      },
+      {
+        address: identities.DisputeVerifier.address,
+        abi: DisputeVerifier_default,
+        functionName: "attestationVerifier"
+      },
+      { address: identities.StakeVault.address, abi: StakeVault_default, functionName: "controller" },
+      { address: identities.StakeVault.address, abi: StakeVault_default, functionName: "stakeToken" },
+      {
+        address: identities.StakeVault.address,
+        abi: StakeVault_default,
+        functionName: "pendingController"
+      },
+      {
+        address: identities.StakeVault.address,
+        abi: StakeVault_default,
+        functionName: "pendingControllerValidAt"
+      }
+    ];
+    const result = await publicClient.multicall({
+      allowFailure: false,
+      blockNumber,
+      // The dynamic risk-window suffix prevents viem from inferring one fixed
+      // ABI tuple, while every entry remains assembled from packaged ABIs.
+      contracts
+    });
+    expectAddress(
+      "IntentLifecycleHookV1.orchestratorRegistry",
+      result[0],
+      relations.hookOrchestratorRegistry
+    );
+    expectAddress(
+      "IntentLifecycleHookV1.whitelistPolicy",
+      result[1],
+      relations.hookWhitelistPolicy
+    );
+    expectAddress(
+      "IntentLifecycleHookV1.disputeProtectionPolicy",
+      result[2],
+      relations.hookDisputeProtectionPolicy
+    );
+    expectBoolean(
+      "OrchestratorRegistry.isOrchestrator",
+      result[3],
+      prerequisite.orchestratorRegistered
+    );
+    expectAddress("WhitelistPolicy.groupRegistry", result[4], relations.whitelistGroupRegistry);
+    expectAddress("WhitelistPolicy.escrowRegistry", result[5], relations.whitelistEscrowRegistry);
+    expectAddress(
+      "WhitelistPolicy.orchestratorRegistry",
+      result[6],
+      relations.whitelistOrchestratorRegistry
+    );
+    expectAddress("DisputeProtectionPolicy.stakeVault", result[7], relations.policyStakeVault);
+    expectAddress(
+      "DisputeProtectionPolicy.disputeVerifier",
+      result[8],
+      relations.policyDisputeVerifier
+    );
+    expectAddress(
+      "DisputeProtectionPolicy.disputeNullifierRegistry",
+      result[9],
+      relations.policyDisputeNullifierRegistry
+    );
+    expectBoolean(
+      "DisputeProtectionPolicy.isLifecycleHookAuthorized",
+      result[10],
+      prerequisite.lifecycleHookAuthorized
+    );
+    if (typeof result[11] !== "boolean") {
+      throw new ReadinessMismatch("DisputeProtectionPolicy.admissionsPaused is malformed");
+    }
+    const policyAdmissionsPaused = result[11];
+    expectBigInt(
+      "DisputeProtectionPolicy.PENDING_COVERAGE_MATURITY",
+      result[12],
+      BigInt(prerequisite.pendingCoverageMaturity)
+    );
+    expectBoolean("DisputeProtectionPolicy.sentinel", result[13], manifest.sentinel.expected);
+    let index = 14;
+    for (const [paymentMethod, seconds] of riskWindows) {
+      expectBigInt(
+        `DisputeProtectionPolicy.getRiskWindow(${paymentMethod})`,
+        result[index],
+        BigInt(seconds)
+      );
+      index += 1;
+    }
+    expectAddress(
+      "DisputeVerifier.nullifierRegistry",
+      result[index++],
+      relations.disputeVerifierNullifierRegistry
+    );
+    expectAddress(
+      "DisputeVerifier.attestationVerifier",
+      result[index++],
+      relations.disputeVerifierAttestationVerifier
+    );
+    expectAddress("StakeVault.controller", result[index++], relations.vaultController);
+    expectAddress("StakeVault.stakeToken", result[index++], relations.vaultStakeToken);
+    expectAddress("StakeVault.pendingController", result[index++], zeroAddress);
+    expectBigInt("StakeVault.pendingControllerValidAt", result[index], 0n);
+    await this.verifyGovernance(blockNumber);
+    await this.verifyAttestationTrust(blockNumber);
+    await this.verifyExactAuthorizationSets(blockNumber, successorActive);
+    return policyAdmissionsPaused;
+  }
+  async read(options = {}) {
+    const packageMismatch = validatePackagedIdentity(this.config);
+    if (packageMismatch) {
+      return {
+        state: "mismatch",
+        readyForDisputeProtection: false,
+        asOfBlock: null,
+        reason: packageMismatch
+      };
+    }
+    let blockNumber = null;
+    try {
+      blockNumber = await this.config.publicClient.getBlockNumber();
+      await this.verifyRuntimeIdentities(["OrchestratorV3"], blockNumber);
+      const orchestrator = await this.readOrchestrator(blockNumber);
+      const hook = orchestrator.lifecycleHook;
+      const identities = this.config.manifest.runtimeIdentities;
+      if (sameAddress(hook, zeroAddress)) {
+        return knownResult(
+          "verified_no_hook",
+          false,
+          blockNumber,
+          this.config,
+          hook,
+          orchestrator.paused,
+          orchestrator.allowMultipleIntents,
+          null
+        );
+      }
+      if (sameAddress(hook, identities.RecognizedPredecessorHook.address)) {
+        await this.verifyRuntimeIdentities(
+          ["RecognizedPredecessorHook", "RecognizedPredecessorPolicy"],
+          blockNumber
+        );
+        if (!options.verifyPassiveSuccessor) {
+          return knownResult(
+            "recognized_predecessor",
+            false,
+            blockNumber,
+            this.config,
+            hook,
+            orchestrator.paused,
+            orchestrator.allowMultipleIntents,
+            null
+          );
+        }
+        await this.verifyRuntimeIdentities(SUCCESSOR_RUNTIME_IDENTITIES, blockNumber);
+        const policyAdmissionsPaused2 = await this.verifySuccessorState(blockNumber, false);
+        return knownResult(
+          "passive_successor",
+          false,
+          blockNumber,
+          this.config,
+          hook,
+          orchestrator.paused,
+          orchestrator.allowMultipleIntents,
+          policyAdmissionsPaused2
+        );
+      }
+      if (!sameAddress(hook, identities.IntentLifecycleHookV1.address)) {
+        throw new ReadinessMismatch("OrchestratorV3.lifecycleHook is not a recognized deployment");
+      }
+      await this.verifyRuntimeIdentities(SUCCESSOR_RUNTIME_IDENTITIES, blockNumber);
+      const policyAdmissionsPaused = await this.verifySuccessorState(blockNumber, true);
+      const readyForDisputeProtection = orchestrator.paused === this.config.manifest.prerequisites.orchestratorPaused && orchestrator.allowMultipleIntents === this.config.manifest.prerequisites.allowMultipleIntents && policyAdmissionsPaused === this.config.manifest.prerequisites.admissionsPaused;
+      return knownResult(
+        "active_successor_verified",
+        readyForDisputeProtection,
+        blockNumber,
+        this.config,
+        hook,
+        orchestrator.paused,
+        orchestrator.allowMultipleIntents,
+        policyAdmissionsPaused
+      );
+    } catch (error) {
+      return {
+        state: "mismatch",
+        readyForDisputeProtection: false,
+        asOfBlock: blockNumber,
+        reason: error instanceof ReadinessMismatch ? error.message : `dispute readiness RPC failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+};
+function createDisputeProtectionReadinessReader(params) {
+  return new DisputeProtectionReadinessReader({
+    publicClient: params.publicClient,
+    chainId: params.chainId,
+    manifest: manifestForEnvironment(params.environment),
+    buildMetadata: SDK_BUILD_METADATA,
+    contractsPackageVersion: version
+  });
+}
+
 // src/indexer/intentVerification.ts
 async function fetchFulfillmentAndPayment(client, intentHash) {
   return client.query({
@@ -6870,17 +8378,19 @@ var Zkp2pClient = class {
       "clearStakeOwner",
       () => []
     );
+    /** Enable or disable dispute protection for one deposit. */
+    this.setDisputeProtectionEnabled = this.buildDisputeProtectionPolicyMethod("setDisputeProtectionEnabled", (params) => [params.escrow, params.depositId, params.enabled]);
     /**
-     * Release one chargeback intent whose risk window matured, unlocking its
-     * stake cover. Permissionless once mature. Pass `chargebackPolicyAddress` to
+     * Release one protected intent whose risk window matured, unlocking its
+     * stake cover. Permissionless once mature. Pass `disputeProtectionPolicyAddress` to
      * pin the transaction to a snapshotted deployment.
      */
-    this.releaseMaturedChargebackIntent = this.buildChargebackPolicyMethod("releaseMaturedChargebackIntent", (params) => [params.intentHash]);
+    this.releaseMaturedDisputeProtectionIntent = this.buildDisputeProtectionPolicyMethod("releaseMaturedDisputeProtectionIntent", (params) => [params.intentHash]);
     /**
-     * Release multiple matured chargeback intents in one transaction.
-     * Pass `chargebackPolicyAddress` to pin the transaction to a snapshotted deployment.
+     * Release multiple matured protected intents in one transaction.
+     * Pass `disputeProtectionPolicyAddress` to pin the transaction to a snapshotted deployment.
      */
-    this.releaseMaturedChargebackIntents = this.buildChargebackPolicyMethod("releaseMaturedChargebackIntents", (params) => [params.intentHashes]);
+    this.releaseMaturedDisputeProtectionIntents = this.buildDisputeProtectionPolicyMethod("releaseMaturedDisputeProtectionIntents", (params) => [params.intentHashes]);
     // ╔═══════════════════════════════════════════════════════════════════════════╗
     // ║ CORE: DEPOSIT MANAGEMENT                                                 ║
     // ╚═══════════════════════════════════════════════════════════════════════════╝
@@ -7746,6 +9256,11 @@ var Zkp2pClient = class {
       chain: selectedChain,
       transport: opts.rpcTransport ?? http(rpc, { batch: false })
     });
+    this._disputeProtectionReadinessReader = createDisputeProtectionReadinessReader({
+      publicClient: this.publicClient,
+      chainId: this.chainId,
+      environment: this.runtimeEnv
+    });
     const { addresses, abis } = getContracts(this.chainId, this.runtimeEnv);
     const toAddress = (value) => this.isValidHexAddress(value) ? value : void 0;
     const uniqAddresses = (values) => {
@@ -7813,8 +9328,8 @@ var Zkp2pClient = class {
     this.intentGuardianAbi = abis.intentGuardian;
     this.stakeVaultAddress = toAddress(addresses.stakeVault);
     this.stakeVaultAbi = abis.stakeVault;
-    this.chargebackPolicyAddress = toAddress(addresses.chargebackPolicy);
-    this.chargebackPolicyAbi = abis.chargebackPolicy;
+    this.disputeProtectionPolicyAddress = toAddress(addresses.disputeProtectionPolicy);
+    this.disputeProtectionPolicyAbi = abis.disputeProtectionPolicy;
     if (!this.rateManagerRegistryAddress || !this.rateManagerRegistryAbi) {
       try {
         const rateManagerContracts = getRateManagerContracts(this.chainId, this.runtimeEnv);
@@ -7904,8 +9419,8 @@ var Zkp2pClient = class {
       getStakeVaultAddress: () => this.stakeVaultAddress,
       getStakeVaultAbi: () => this.stakeVaultAbi,
       getStakeTokenAddress: () => this._usdcAddress,
-      getChargebackPolicyAddress: () => this.chargebackPolicyAddress,
-      getChargebackPolicyAbi: () => this.chargebackPolicyAbi
+      getDisputeProtectionPolicyAddress: () => this.disputeProtectionPolicyAddress,
+      getDisputeProtectionPolicyAbi: () => this.disputeProtectionPolicyAbi
     });
     this._intentGuardianOps = new IntentGuardianOperations({
       getPublicClient: () => this.publicClient,
@@ -8246,7 +9761,7 @@ var Zkp2pClient = class {
     const escrowAbi = opts.escrowAbi ?? this.escrowAbi;
     if (!escrowAddress || !escrowAbi) throw new Error("Escrow not available");
     const { referrer, value } = opts.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: escrowAbi,
         functionName: opts.functionName,
@@ -8256,7 +9771,7 @@ var Zkp2pClient = class {
     );
     return {
       to: escrowAddress,
-      data,
+      data: data3,
       value: opts.value ?? value ?? 0n,
       chainId: this.chainId,
       abi: escrowAbi,
@@ -8269,7 +9784,7 @@ var Zkp2pClient = class {
     const orchestratorAbi = opts.orchestratorAbi ?? this.orchestratorAbi;
     if (!orchestratorAddress || !orchestratorAbi) throw new Error("Orchestrator not available");
     const { referrer, value } = opts.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: orchestratorAbi,
         functionName: opts.functionName,
@@ -8279,7 +9794,7 @@ var Zkp2pClient = class {
     );
     return {
       to: orchestratorAddress,
-      data,
+      data: data3,
       value: opts.value ?? value ?? 0n,
       chainId: this.chainId,
       abi: orchestratorAbi,
@@ -8300,7 +9815,7 @@ var Zkp2pClient = class {
   }
   prepareContractTransaction(opts) {
     const { referrer, value } = opts.txOverrides ?? {};
-    const data = encodeWithAttribution(
+    const data3 = encodeWithAttribution(
       {
         abi: opts.abi,
         functionName: opts.functionName,
@@ -8310,7 +9825,7 @@ var Zkp2pClient = class {
     );
     return {
       to: opts.address,
-      data,
+      data: data3,
       value: opts.value ?? value ?? 0n,
       chainId: this.chainId,
       abi: opts.abi,
@@ -8370,12 +9885,12 @@ var Zkp2pClient = class {
       buildArgs
     );
   }
-  buildChargebackPolicyMethod(functionName, buildArgs) {
+  buildDisputeProtectionPolicyMethod(functionName, buildArgs) {
     return this.buildContractMethod(
       (params) => ({
-        address: params.chargebackPolicyAddress ?? this.chargebackPolicyAddress,
-        abi: this.chargebackPolicyAbi,
-        label: "ChargebackPolicy"
+        address: params.disputeProtectionPolicyAddress ?? this.disputeProtectionPolicyAddress,
+        abi: this.disputeProtectionPolicyAbi,
+        label: "DisputeProtectionPolicy"
       }),
       functionName,
       buildArgs
@@ -8778,6 +10293,20 @@ var Zkp2pClient = class {
           signal: options?.signal
         });
       },
+      /** Pages stake-owner locks by immutable lock identity. */
+      getStakeLocks: (params, options) => {
+        return stakingService.fetchStakeLocks(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 });
+      },
+      /** Pages the exact active policy's finalized dispute stream. */
+      getDisputeProtectionIntents: (params, options) => {
+        return stakingService.fetchDisputeProtectionIntents(params, {
+          signal: options?.signal
+        });
+      },
       /**
        * Fetches chronological fund activities for a specific deposit.
        */
@@ -8877,12 +10406,12 @@ var Zkp2pClient = class {
     }
     return { address: this.orchestratorV3Address, abi: this.orchestratorV3Abi };
   }
-  /** Return the resolved ChargebackPolicy coordinates for keeper integrations. */
-  getChargebackPolicyContract() {
-    if (!this.chargebackPolicyAddress || !this.chargebackPolicyAbi) {
-      throw new Error("ChargebackPolicy not available for this chain/environment");
+  /** Return the resolved DisputeProtectionPolicy coordinates for keeper integrations. */
+  getDisputeProtectionPolicyContract() {
+    if (!this.disputeProtectionPolicyAddress || !this.disputeProtectionPolicyAbi) {
+      throw new Error("DisputeProtectionPolicy not available for this chain/environment");
     }
-    return { address: this.chargebackPolicyAddress, abi: this.chargebackPolicyAbi };
+    return { address: this.disputeProtectionPolicyAddress, abi: this.disputeProtectionPolicyAbi };
   }
   /**
    * Ensure the connected wallet has approved enough USDC for StakeVault.
@@ -8930,10 +10459,14 @@ var Zkp2pClient = class {
   getStakeVaultState(params) {
     return this._stakeOps.getStakeVaultState(params);
   }
-  /** Read whether the ChargebackPolicy is refusing new chargebackable admissions. */
+  /** Read whether the DisputeProtectionPolicy is refusing new dispute-protected admissions. */
   getAdmissionsPaused() {
     return this._stakeOps.getAdmissionsPaused();
   }
+  /** Prove the exact packaged dispute-protection deployment at one block. */
+  getDisputeProtectionReadiness(options) {
+    return this._disputeProtectionReadinessReader.read(options);
+  }
   /**
    * Read a payment method's minimum collateral lock window in seconds. Zero
    * means the method admits unbonded — no stake is locked at admission.
@@ -8941,9 +10474,9 @@ var Zkp2pClient = class {
   getRiskWindow(paymentMethodHash) {
     return this._stakeOps.getRiskWindow(paymentMethodHash);
   }
-  /** Read whether an escrow deposit has opted into chargeback coverage. */
-  isChargebackEnabled(escrow, depositId) {
-    return this._stakeOps.isChargebackEnabled(escrow, depositId);
+  /** Read whether an escrow deposit has opted into dispute protection. */
+  isDisputeProtectionEnabled(escrow, depositId) {
+    return this._stakeOps.isDisputeProtectionEnabled(escrow, depositId);
   }
   /**
    * Registers payee details with the curator API and returns hashed on-chain IDs.
@@ -9146,7 +10679,7 @@ var Zkp2pClient = class {
           }
         }
       });
-      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-MARF3D2J.mjs');
+      const { mapConversionRatesToOnchainMinRate: mapConversionRatesToOnchainMinRate2 } = await import('./currency-XA62DCJH.mjs');
       currencies = mapConversionRatesToOnchainMinRate2(
         params.conversionRates,
         paymentMethods.length
@@ -9742,7 +11275,7 @@ var Zkp2pClient = class {
       rateManagerV1: this.rateManagerV1Address,
       orchestratorRegistry: this.orchestratorRegistryAddress,
       stakeVault: this.stakeVaultAddress,
-      chargebackPolicy: this.chargebackPolicyAddress,
+      disputeProtectionPolicy: this.disputeProtectionPolicyAddress,
       usdc: this._usdcAddress
     };
   }
@@ -9832,17 +11365,17 @@ function integer(value, label) {
   if (parsed < 0n) throw new RangeError(`${label} must be non-negative`);
   return parsed;
 }
-function calculateRequiredCoverage(amount, chargebackable) {
-  return chargebackable ? integer(amount, "amount") : 0n;
+function calculateRequiredCoverage(amount, disputeProtected) {
+  return disputeProtected ? integer(amount, "amount") : 0n;
 }
 function calculateStakeBackedCapacity(freeStake) {
   return integer(freeStake, "freeStake");
 }
-function selectRiskMode(amount, freeStake, chargebackable) {
-  const required = calculateRequiredCoverage(amount, chargebackable);
-  if (!chargebackable) return "UNBONDED";
+function selectRiskMode(amount, freeStake, disputeProtected) {
+  const required = calculateRequiredCoverage(amount, disputeProtected);
+  if (!disputeProtected) return "UNBONDED";
   if (integer(freeStake, "freeStake") >= required) return "STAKE_BACKED";
-  throw new RangeError("insufficient free stake for chargebackable admission");
+  throw new RangeError("insufficient free stake for dispute-protected admission");
 }
 
 // src/client/accessPolicyPlan.ts
@@ -10001,6 +11534,6 @@ var planAccessPolicyUpdate = (persistedInput, draftInput) => {
   };
 };
 
-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, 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, 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 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map