@zkp2p/sdk 0.8.1 → 0.10.0-rc.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
-export { TAKER_TIER_CAPS, TAKER_TIER_FEE_DISCOUNT_BPS, TAKER_TIER_ORDER, TAKER_TIER_SCHEDULE, ZERO_RATE_MANAGER_ID, classifyDelegationState, getDelegationRoute, getNextTakerTier, getTakerTierFeeDiscountBps, isZeroRateManagerId, normalizeRateManagerId, normalizeRegistry } from './chunk-EIOXBVXP.mjs';
+export { ZERO_RATE_MANAGER_ID, classifyDelegationState, getDelegationRoute, isZeroRateManagerId, normalizeRateManagerId, normalizeRegistry } from './chunk-LPJE2MN7.mjs';
 import { ValidationError, APIError, NetworkError } from './chunk-GHQK65J2.mjs';
 export { APIError, ContractError, ErrorCode, NetworkError, ValidationError, ZKP2PError } from './chunk-GHQK65J2.mjs';
-import { getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash } from './chunk-ZM4ZP5GQ.mjs';
-export { asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, getRateManagerContracts, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-ZM4ZP5GQ.mjs';
+import { METHOD_NAME_TO_HASH, matchesQuotePaymentMethod, matchesPaymentMethodNameAndHash, getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, SUPPORTED_PAYMENT_METHOD_HASHES, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash } from './chunk-7M37EVN5.mjs';
+export { PAYMENT_PLATFORMS, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, getRateManagerContracts, getStakeVaultContract, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-7M37EVN5.mjs';
 import { Currency, currencyKeccak256 } from './chunk-ZFBH4HD7.mjs';
 export { Currency, currencyInfo, getCurrencyCodeFromHash, getCurrencyInfoFromCountryCode, getCurrencyInfoFromHash, isSupportedCurrencyHash, mapConversionRatesToOnchainMinRate } from './chunk-ZFBH4HD7.mjs';
 import './chunk-J5LGTIGS.mjs';
@@ -813,25 +813,10 @@ async function sendTransactionWithAttribution(walletClient, request, referrer, o
   });
 }
 
-// src/types/index.ts
-var PAYMENT_PLATFORMS = [
-  "wise",
-  "venmo",
-  "revolut",
-  "cashapp",
-  "mercadopago",
-  "zelle",
-  "paypal",
-  "monzo",
-  "chime",
-  "luxon",
-  "n26"
-];
-
 // src/utils/constants.ts
 var DEFAULT_BASE_API_URL = "https://api.zkp2p.xyz";
 
-// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.2.4_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.2.1/node_modules/@zkp2p/contracts-v2/oracleFeeds/chainlink.json
+// ../../node_modules/.pnpm/@zkp2p+contracts-v2@0.3.0_ethers@6.16.0_bufferutil@4.1.0_utf-8-validate@5.0.10__typescript@5.9.3_zod@4.2.1/node_modules/@zkp2p/contracts-v2/oracleFeeds/chainlink.json
 var chainlink_default = {
   feeds: [
     {
@@ -1983,7 +1968,7 @@ var ProtocolViewerReader = class {
       if (inputCount === null) {
         throw new Error("Configured ProtocolViewer ABI does not expose getDeposit");
       }
-      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-GG6UQKLO.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
       if (inputCount >= 3) {
         return tryContexts(
           protocolViewerContexts,
@@ -2062,7 +2047,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-GG6UQKLO.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     if (inputCount >= 2) {
       const requests = ids.map((id, index) => ({
         index,
@@ -2167,7 +2152,7 @@ var ProtocolViewerReader = class {
     if (!protocolViewerAddress || !protocolViewerAbi || inputCount === null) {
       return this.config.host.getPvAccountDepositsFromIndexer(owner);
     }
-    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-GG6UQKLO.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     const { address, abi } = this.config.host.requireProtocolViewer();
     if (inputCount >= 2) {
       const readAndFilter = async (raw2) => {
@@ -2238,7 +2223,7 @@ var ProtocolViewerReader = class {
     if (protocolViewerEntries.length === 0) {
       throw new Error("ProtocolViewer not available for this network");
     }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-GG6UQKLO.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     const intentsByHash = /* @__PURE__ */ new Map();
     let attemptedRead = false;
     let hadSuccessfulRead = false;
@@ -2346,7 +2331,7 @@ var ProtocolViewerReader = class {
     if (protocolViewerEntries.length === 0) {
       throw new Error("ProtocolViewer not available for this network");
     }
-    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-GG6UQKLO.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     let lastError;
     for (const pvEntry of protocolViewerEntries) {
       const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
@@ -3558,7 +3543,7 @@ var MAKER_FUND_ACTIVITIES_QUERY = (
   `
   query GetMakerFundActivities($depositor: String!, $limit: Int) {
     DepositFundActivity(
-      where: { depositor: { _eq: $depositor } }
+      where: { depositor: { _ilike: $depositor } }
       order_by: { timestamp: desc }
       limit: $limit
     ) {
@@ -4337,6 +4322,7 @@ function buildLegacyVerifierCurrencies(deposit) {
   const currenciesByMethod = /* @__PURE__ */ new Map();
   for (const currency of deposit.currencies ?? []) {
     const methodHash = currency.paymentMethodHash;
+    if (!SUPPORTED_PAYMENT_METHOD_HASHES.has(methodHash.toLowerCase())) continue;
     const resolvedConversionRate = currency.conversionRate ?? currency.minConversionRate;
     if (resolvedConversionRate === null || resolvedConversionRate === void 0) {
       logger.warn(
@@ -4358,7 +4344,9 @@ function buildLegacyVerifierCurrencies(deposit) {
 }
 function convertIndexerDepositToLegacyApiDeposit(deposit) {
   const currenciesByMethod = buildLegacyVerifierCurrencies(deposit);
-  const verifiers = (deposit.paymentMethods ?? []).filter((paymentMethod) => paymentMethod.active !== false).map((paymentMethod) => ({
+  const verifiers = (deposit.paymentMethods ?? []).filter(
+    (paymentMethod) => paymentMethod.active !== false && SUPPORTED_PAYMENT_METHOD_HASHES.has(paymentMethod.paymentMethodHash.toLowerCase())
+  ).map((paymentMethod) => ({
     depositId: Number(deposit.depositId),
     verifier: "",
     methodHash: paymentMethod.paymentMethodHash,
@@ -4460,13 +4448,28 @@ async function apiGetQuotesBestByPlatform(req, baseApiUrl, timeoutMs, apiKey) {
   Object.keys(requestBody).forEach(
     (key) => requestBody[key] === void 0 && delete requestBody[key]
   );
-  return apiFetch({
+  const response = await apiFetch({
     url,
     method: "POST",
     body: requestBody,
     apiKey,
     timeoutMs
   });
+  return {
+    ...response,
+    responseObject: {
+      ...response.responseObject,
+      platformQuotes: (response.responseObject?.platformQuotes ?? []).filter((platformQuote) => {
+        const platform = platformQuote.platform.trim().toLowerCase();
+        if (!METHOD_NAME_TO_HASH[platform]) return false;
+        if (!platformQuote.bestQuote) return true;
+        return platform === platformQuote.bestQuote.intent.processorName.trim().toLowerCase() && matchesQuotePaymentMethod(
+          platformQuote.bestQuote.intent.processorName,
+          platformQuote.bestQuote.paymentMethod
+        );
+      })
+    }
+  };
 }
 async function apiGetPayeeDetails(req, baseApiUrl, timeoutMs) {
   return apiFetch({
@@ -4522,13 +4525,26 @@ async function apiGetOwnerDeposits(req, apiKey, baseApiUrl, authToken, timeoutMs
     statusCode: 200
   };
 }
-async function apiGetTakerTier(req, baseApiUrl, timeoutMs) {
+async function apiGetTakerStake(req, baseApiUrl, timeoutMs) {
+  const normalizedOwner = req.owner.toLowerCase();
+  const query = new URLSearchParams({
+    owner: normalizedOwner,
+    chainId: String(req.chainId)
+  });
+  const endpoint = `/v2/taker/stake?${query.toString()}`;
+  return apiFetch({
+    url: `${withApiBase(baseApiUrl)}${endpoint}`,
+    method: "GET",
+    timeoutMs
+  });
+}
+async function apiGetTakerCapacity(req, baseApiUrl, timeoutMs) {
   const normalizedOwner = req.owner.toLowerCase();
   const query = new URLSearchParams({
     owner: normalizedOwner,
     chainId: String(req.chainId)
   });
-  const endpoint = `/v2/taker/tier?${query.toString()}`;
+  const endpoint = `/v2/taker/capacity?${query.toString()}`;
   return apiFetch({
     url: `${withApiBase(baseApiUrl)}${endpoint}`,
     method: "GET",
@@ -4687,7 +4703,35 @@ async function apiGetOrderbook(params, optsOrBaseApiUrl, timeoutMs) {
     method: "GET",
     timeoutMs: opts.timeoutMs
   });
-  return response.responseObject;
+  return {
+    ...response.responseObject,
+    entries: response.responseObject.entries.filter(
+      (entry) => matchesPaymentMethodNameAndHash(entry.paymentPlatform, entry.paymentMethodHash)
+    )
+  };
+}
+async function apiGetOrderbookTable(params, optsOrBaseApiUrl, timeoutMs) {
+  const opts = typeof optsOrBaseApiUrl === "string" ? {
+    baseApiUrl: optsOrBaseApiUrl,
+    timeoutMs
+  } : optsOrBaseApiUrl;
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null) return;
+    query.set(key, String(value));
+  });
+  const response = await apiFetch({
+    url: `${withApiBase(opts.baseApiUrl)}/v2/orderbook/table?${query.toString()}`,
+    method: "GET",
+    timeoutMs: opts.timeoutMs
+  });
+  const responseObject = unwrapResponseObject(response);
+  return {
+    ...responseObject,
+    rows: responseObject.rows.filter(
+      (row) => matchesPaymentMethodNameAndHash(row.paymentPlatform, row.paymentMethodHash)
+    )
+  };
 }
 async function apiGetDepositBundle(params, optsOrBaseApiUrl, timeoutMs) {
   const opts = typeof optsOrBaseApiUrl === "string" ? {
@@ -5221,6 +5265,125 @@ var getRateManagerReadFunction = (abi, functionName) => Array.isArray(abi) && ab
   (item) => item.type === "function" && item.name === functionName
 );
 
+// src/client/StakeOperations.ts
+function tupleValue(value, key, index) {
+  if (Array.isArray(value)) return value[index];
+  if (value && typeof value === "object") {
+    return value[key];
+  }
+  return void 0;
+}
+function toBigInt2(value, label) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" || typeof value === "string") {
+    return BigInt(value);
+  }
+  throw new Error(`Invalid StakeVault ${label}`);
+}
+function toBoolean(value, label) {
+  if (typeof value === "boolean") return value;
+  throw new Error(`Invalid StakeVault ${label}`);
+}
+var StakeOperations = class {
+  constructor(config) {
+    this.config = config;
+  }
+  getContract() {
+    const address = this.config.getStakeVaultAddress();
+    const abi = this.config.getStakeVaultAbi();
+    const stakeToken = this.config.getStakeTokenAddress();
+    if (!address || !abi || !stakeToken) {
+      throw new Error("StakeVault not available for this chain/environment");
+    }
+    return { address, abi, stakeToken };
+  }
+  read(functionName, args = []) {
+    const { address, abi } = this.getContract();
+    return this.config.getPublicClient().readContract({
+      address,
+      abi,
+      functionName,
+      args
+    });
+  }
+  getStakeBalance(staker) {
+    return this.read("stakeBalance", [staker]);
+  }
+  getEligibleStake(staker) {
+    return this.read("eligibleStake", [staker]);
+  }
+  getReservedStake(staker) {
+    return this.read("reservedStake", [staker]);
+  }
+  getFreeStake(staker) {
+    return this.read("freeStake", [staker]);
+  }
+  getStakeOwner(taker) {
+    return this.read("stakeOwnerOf", [taker]);
+  }
+  getAllowedStakeOwner(taker) {
+    return this.read("allowedStakeOwner", [taker]);
+  }
+  getStakeDelegationEnabled(taker) {
+    return this.read("stakeDelegationEnabled", [taker]);
+  }
+  async getStakeWithdrawalRequest(staker) {
+    const value = await this.read("getStakeWithdrawalRequest", [staker]);
+    return {
+      amount: toBigInt2(tupleValue(value, "amount", 0), "withdrawal amount"),
+      requestedAt: toBigInt2(tupleValue(value, "requestedAt", 1), "withdrawal requestedAt"),
+      availableAt: toBigInt2(tupleValue(value, "availableAt", 2), "withdrawal availableAt")
+    };
+  }
+  async getStakeExitRequest(staker) {
+    const value = await this.read("getExitRequest", [staker]);
+    return {
+      exiting: toBoolean(tupleValue(value, "exiting", 0), "exit status"),
+      requestedAt: toBigInt2(tupleValue(value, "requestedAt", 1), "exit requestedAt"),
+      availableAt: toBigInt2(tupleValue(value, "availableAt", 2), "exit availableAt")
+    };
+  }
+  async getStakeVaultState(params) {
+    const taker = params.taker ?? params.staker;
+    const { stakeToken } = this.getContract();
+    const [
+      stakeOwner,
+      allowedStakeOwner,
+      delegationEnabled,
+      staked,
+      eligible,
+      reserved,
+      free,
+      withdrawal,
+      exit
+    ] = await Promise.all([
+      this.getStakeOwner(taker),
+      this.getAllowedStakeOwner(taker),
+      this.getStakeDelegationEnabled(taker),
+      this.getStakeBalance(params.staker),
+      this.getEligibleStake(params.staker),
+      this.getReservedStake(params.staker),
+      this.getFreeStake(params.staker),
+      this.getStakeWithdrawalRequest(params.staker),
+      this.getStakeExitRequest(params.staker)
+    ]);
+    return {
+      staker: params.staker,
+      taker,
+      stakeToken,
+      stakeOwner,
+      allowedStakeOwner,
+      delegationEnabled,
+      staked,
+      eligible,
+      reserved,
+      free,
+      withdrawal,
+      exit
+    };
+  }
+};
+
 // src/indexer/rateManagerService.ts
 var DEFAULT_LIMIT2 = 50;
 var RATE_MANAGER_HISTORY_PAGE_SIZE = 250;
@@ -6187,6 +6350,12 @@ function normalizeQuotePayeeData(maker) {
     metadata: isObjectRecord(maker?.metadata) ? maker.metadata : legacy?.metadata ?? null
   };
 }
+function isActiveQuotePaymentMethod(quote) {
+  if (!quote?.intent || typeof quote.intent.processorName !== "string" || typeof quote.paymentMethod !== "string") {
+    return false;
+  }
+  return matchesQuotePaymentMethod(quote.intent.processorName, quote.paymentMethod);
+}
 function normalizePayeeDataInputItem(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     return null;
@@ -6235,6 +6404,7 @@ function resolvePayeeDataInput(params, methodName) {
   return normalized;
 }
 function toPostDepositDetailsRequest(processorName, payeeData, index) {
+  assertKnownProcessorName(processorName, `processorNames[${index}]`);
   if (!payeeData || typeof payeeData.offchainId !== "string" || payeeData.offchainId.length === 0) {
     throw new Error(`payeeData[${index}] must include a non-empty offchainId`);
   }
@@ -6245,6 +6415,26 @@ function toPostDepositDetailsRequest(processorName, payeeData, index) {
     metadata: getPayeeRegistrationMetadata(payeeData)
   };
 }
+function assertKnownProcessorName(processorName, field) {
+  if (!METHOD_NAME_TO_HASH[processorName.toLowerCase()]) {
+    throw new ValidationError(`Unknown processorName: ${processorName}`, field);
+  }
+}
+function assertCatalogPaymentMethods(paymentMethods, chainId, runtimeEnv, field) {
+  const catalogHashes = new Set(
+    Object.values(getPaymentMethodsCatalog(chainId, runtimeEnv)).map(
+      (entry) => entry.paymentMethodHash.toLowerCase()
+    )
+  );
+  paymentMethods.forEach((paymentMethod, index) => {
+    if (!catalogHashes.has(paymentMethod.toLowerCase())) {
+      throw new ValidationError(
+        `Unsupported payment method hash: ${paymentMethod}`,
+        `${field}[${index}]`
+      );
+    }
+  });
+}
 var Zkp2pClient = class {
   /**
    * Creates a new Zkp2pClient instance.
@@ -6253,6 +6443,46 @@ var Zkp2pClient = class {
    * @throws Error if walletClient is missing an account
    */
   constructor(opts) {
+    /** Deposit USDC stake for the connected taker. */
+    this.depositStake = this.buildStakeVaultMethod(
+      "depositStake",
+      (params) => [params.amount]
+    );
+    /** Deposit USDC stake for a different taker that has enabled delegation. */
+    this.depositStakeFor = this.buildStakeVaultMethod(
+      "depositStakeFor",
+      (params) => [params.taker, params.amount]
+    );
+    /** Begin a partial stake-withdrawal delay. */
+    this.requestStakeWithdrawal = this.buildStakeVaultMethod("requestStakeWithdrawal", (params) => [params.amount]);
+    /** Cancel the connected staker's pending partial withdrawal. */
+    this.cancelStakeWithdrawal = this.buildStakeVaultMethod("cancelStakeWithdrawal", () => []);
+    /** Withdraw a matured partial stake-withdrawal request. */
+    this.withdrawRequestedStake = this.buildStakeVaultMethod("withdrawRequestedStake", (params) => [params.recipient]);
+    /** Begin a full exit, blocking new taking activity for the stake owner. */
+    this.requestExit = this.buildStakeVaultMethod(
+      "requestExit",
+      () => []
+    );
+    /** Cancel a pending full exit. */
+    this.cancelExit = this.buildStakeVaultMethod(
+      "cancelExit",
+      () => []
+    );
+    /** Withdraw all stake after a matured, fully settled exit. */
+    this.withdrawStake = this.buildStakeVaultMethod(
+      "withdrawStake",
+      (params) => [params.recipient]
+    );
+    /** Allow or block third-party stake owners for the connected taker. */
+    this.setStakeDelegationEnabled = this.buildStakeVaultMethod("setStakeDelegationEnabled", (params) => [params.enabled]);
+    /** Select the stake owner whose portfolio backs the connected taker. */
+    this.setAllowedStakeOwner = this.buildStakeVaultMethod("setAllowedStakeOwner", (params) => [params.stakeOwner]);
+    /** Remove the connected taker's selected third-party stake owner. */
+    this.clearStakeOwner = this.buildStakeVaultMethod(
+      "clearStakeOwner",
+      () => []
+    );
     // ╔═══════════════════════════════════════════════════════════════════════════╗
     // ║ CORE: DEPOSIT MANAGEMENT                                                 ║
     // ╚═══════════════════════════════════════════════════════════════════════════╝
@@ -6597,6 +6827,12 @@ var Zkp2pClient = class {
      */
     this.addPaymentMethods = Object.assign(
       async (params) => {
+        assertCatalogPaymentMethods(
+          params.paymentMethods,
+          this.chainId,
+          this.runtimeEnv,
+          "paymentMethods"
+        );
         const escrowContext = await this.resolveEscrowContextForDepositWrite({
           escrowAddress: params.escrowAddress,
           depositId: params.depositId,
@@ -6621,6 +6857,12 @@ var Zkp2pClient = class {
       },
       {
         prepare: async (params) => {
+          assertCatalogPaymentMethods(
+            params.paymentMethods,
+            this.chainId,
+            this.runtimeEnv,
+            "paymentMethods"
+          );
           const escrowContext = await this.resolveEscrowContextForDepositWrite({
             escrowAddress: params.escrowAddress,
             depositId: params.depositId,
@@ -7139,6 +7381,8 @@ var Zkp2pClient = class {
     this.rateManagerRegistryAbi = abis.rateManagerRegistry ?? this.rateManagerV1Abi;
     this.rateManagerControllerAddress = toAddress(addresses.rateManagerController);
     this.rateManagerControllerAbi = abis.rateManagerController;
+    this.stakeVaultAddress = toAddress(addresses.stakeVault);
+    this.stakeVaultAbi = abis.stakeVault;
     if (!this.rateManagerRegistryAddress || !this.rateManagerRegistryAbi) {
       try {
         const rateManagerContracts = getRateManagerContracts(this.chainId, this.runtimeEnv);
@@ -7219,6 +7463,12 @@ var Zkp2pClient = class {
         prepareContractTransaction: (tx) => this.prepareContractTransaction(tx)
       }
     });
+    this._stakeOps = new StakeOperations({
+      getPublicClient: () => this.publicClient,
+      getStakeVaultAddress: () => this.stakeVaultAddress,
+      getStakeVaultAbi: () => this.stakeVaultAbi,
+      getStakeTokenAddress: () => this._usdcAddress
+    });
     this._intentOps = new IntentOperations({
       getWalletClient: () => this.walletClient,
       getPublicClient: () => this.publicClient,
@@ -7676,6 +7926,17 @@ var Zkp2pClient = class {
       }
     );
   }
+  buildStakeVaultMethod(functionName, buildArgs) {
+    return this.buildContractMethod(
+      () => ({
+        address: this.stakeVaultAddress,
+        abi: this.stakeVaultAbi,
+        label: "StakeVault"
+      }),
+      functionName,
+      buildArgs
+    );
+  }
   buildEscrowMethod(functionName, buildArgs, buildValue) {
     return Object.assign(
       async (params) => {
@@ -8133,6 +8394,70 @@ var Zkp2pClient = class {
     });
     return { hadAllowance: false, hash };
   }
+  // ╔═══════════════════════════════════════════════════════════════════════════╗
+  // ║ CORE: TAKER STAKING                                                      ║
+  // ╚═══════════════════════════════════════════════════════════════════════════╝
+  /**
+   * Return the resolved StakeVault coordinates for advanced wallet, relayer,
+   * or reactive read integrations.
+   */
+  getStakeVaultContract() {
+    return this._stakeOps.getContract();
+  }
+  /**
+   * Ensure the connected wallet has approved enough USDC for StakeVault.
+   * If an approval is submitted, wait for it to confirm before depositing.
+   */
+  async ensureStakeAllowance(params) {
+    const { address, stakeToken } = this._stakeOps.getContract();
+    return this.ensureAllowance({
+      token: stakeToken,
+      spender: address,
+      amount: params.amount,
+      maxApprove: params.maxApprove,
+      txOverrides: params.txOverrides
+    });
+  }
+  /** Read total stake owned by an address directly from StakeVault. */
+  getStakeBalance(staker) {
+    return this._stakeOps.getStakeBalance(staker);
+  }
+  /** Read stake that currently backs taking capacity. */
+  getEligibleStake(staker) {
+    return this._stakeOps.getEligibleStake(staker);
+  }
+  /** Read stake reserved against active intents. */
+  getReservedStake(staker) {
+    return this._stakeOps.getReservedStake(staker);
+  }
+  /** Read stake currently available for withdrawal or new reservations. */
+  getFreeStake(staker) {
+    return this._stakeOps.getFreeStake(staker);
+  }
+  /** Resolve the effective stake owner backing a taker. */
+  getStakeOwner(taker) {
+    return this._stakeOps.getStakeOwner(taker);
+  }
+  /** Read the stake owner explicitly selected by a taker. */
+  getAllowedStakeOwner(taker) {
+    return this._stakeOps.getAllowedStakeOwner(taker);
+  }
+  /** Read whether a taker allows third-party stake delegation. */
+  getStakeDelegationEnabled(taker) {
+    return this._stakeOps.getStakeDelegationEnabled(taker);
+  }
+  /** Read the connected staker's pending partial withdrawal. */
+  getStakeWithdrawalRequest(staker) {
+    return this._stakeOps.getStakeWithdrawalRequest(staker);
+  }
+  /** Read the connected staker's pending full exit. */
+  getStakeExitRequest(staker) {
+    return this._stakeOps.getStakeExitRequest(staker);
+  }
+  /** Read the complete authoritative StakeVault state needed by a staking UI. */
+  getStakeVaultState(params) {
+    return this._stakeOps.getStakeVaultState(params);
+  }
   /**
    * Registers payee details with the curator API and returns hashed on-chain IDs.
    *
@@ -8252,6 +8577,9 @@ var Zkp2pClient = class {
     if (!Array.isArray(params.processorNames) || params.processorNames.length === 0) {
       throw new Error("processorNames must be a non-empty array");
     }
+    params.processorNames.forEach(
+      (processorName, index) => assertKnownProcessorName(processorName, `processorNames[${index}]`)
+    );
     if (params.processorNames.length !== params.conversionRates.length) {
       throw new Error("processorNames and conversionRates length mismatch");
     }
@@ -8280,6 +8608,12 @@ var Zkp2pClient = class {
           "paymentMethodsOverride, paymentMethodDataOverride, and currenciesOverride length mismatch"
         );
       }
+      assertCatalogPaymentMethods(
+        params.paymentMethodsOverride,
+        this.chainId,
+        this.runtimeEnv,
+        "paymentMethodsOverride"
+      );
       paymentMethods = params.paymentMethodsOverride;
       paymentMethodData = params.paymentMethodDataOverride;
       currencies = params.currenciesOverride;
@@ -8468,6 +8802,9 @@ var Zkp2pClient = class {
    */
   async getQuote(req, opts) {
     const referrerFeeConfig = assertValidReferrerFeeConfig(req.referrerFeeConfig, "getQuote");
+    req.paymentPlatforms.forEach(
+      (processorName, index) => assertKnownProcessorName(processorName, `paymentPlatforms[${index}]`)
+    );
     const baseApiUrl = (opts?.baseApiUrl ?? this.baseApiUrl ?? DEFAULT_BASE_API_URL).replace(
       /\/$/,
       ""
@@ -8481,7 +8818,18 @@ var Zkp2pClient = class {
       }
     }
     const quote = await apiGetQuote(reqWithEscrow, baseApiUrl, timeoutMs, this.apiKey);
-    const quotes = quote?.responseObject?.quotes ?? [];
+    const quotes = (quote?.responseObject?.quotes ?? []).filter(isActiveQuotePaymentMethod);
+    quote.responseObject.quotes = quotes;
+    if (quote.responseObject.nearbySuggestions) {
+      quote.responseObject.nearbySuggestions = {
+        below: quote.responseObject.nearbySuggestions.below.filter(
+          (suggestion) => isActiveQuotePaymentMethod(suggestion.quote)
+        ),
+        above: quote.responseObject.nearbySuggestions.above.filter(
+          (suggestion) => isActiveQuotePaymentMethod(suggestion.quote)
+        )
+      };
+    }
     for (const q of quotes) {
       const payeeData = normalizeQuotePayeeData(q.maker);
       if (payeeData) {
@@ -8527,7 +8875,11 @@ var Zkp2pClient = class {
       ...quote,
       responseObject: {
         ...quote.responseObject,
-        platformQuotes: (quote.responseObject?.platformQuotes ?? []).map((platformQuote) => {
+        platformQuotes: (quote.responseObject?.platformQuotes ?? []).filter((platformQuote) => {
+          const platform = platformQuote.platform.trim().toLowerCase();
+          if (!METHOD_NAME_TO_HASH[platform]) return false;
+          return !platformQuote.bestQuote || platform === platformQuote.bestQuote.intent.processorName.trim().toLowerCase() && isActiveQuotePaymentMethod(platformQuote.bestQuote);
+        }).map((platformQuote) => {
           const bestQuote = platformQuote?.bestQuote;
           const payeeData = normalizeQuotePayeeData(bestQuote?.maker);
           if (!bestQuote || !payeeData) return platformQuote;
@@ -8541,25 +8893,48 @@ var Zkp2pClient = class {
     return appendReferrerFeeDisplayFieldsToBestByPlatform(enrichedQuote, referrerFeeConfig);
   }
   // ───────────────────────────────────────────────────────────────────────────
-  // SUPPORTING: TAKER TIER
-  // (Used by frontends to display taker limits)
+  // SUPPORTING: TAKER STAKE & CAPACITY
+  // (Used by frontends to display the stake portfolio and per-platform taking
+  // capacity; never used to filter quotes)
   // ───────────────────────────────────────────────────────────────────────────
   /**
-   * **Supporting Method** - Fetches taker tier information for an address.
+   * **Supporting Method** - Fetches the stake portfolio backing a taker:
+   * staked/pending-withdrawal/eligible/reserved/free balances, reservation
+   * aggregates, delegation, and exit state.
    *
-   * @param req - Taker tier request parameters
-   * @param req.owner - Taker address
+   * @param req - Stake request parameters
+   * @param req.owner - Taker address (the resolved stake owner may differ)
    * @param req.chainId - Chain ID
    * @param opts - Optional overrides for API URL and timeout
-   * @returns Taker tier response
+   * @returns Taker stake response
    */
-  async getTakerTier(req, opts) {
+  async getTakerStake(req, opts) {
     const baseApiUrl = (opts?.baseApiUrl ?? this.baseApiUrl ?? DEFAULT_BASE_API_URL).replace(
       /\/$/,
       ""
     );
     const timeoutMs = opts?.timeoutMs ?? this.apiTimeoutMs;
-    return apiGetTakerTier(req, baseApiUrl, timeoutMs);
+    return apiGetTakerStake(req, baseApiUrl, timeoutMs);
+  }
+  /**
+   * **Supporting Method** - Fetches per-platform bonded taking capacity, free
+   * takes, curve terms, warnings, and operational gates for a taker's shared
+   * stake portfolio. Platform capacities are alternative views of one shared
+   * balance and must never be summed.
+   *
+   * @param req - Capacity request parameters
+   * @param req.owner - Taker address (the resolved stake owner may differ)
+   * @param req.chainId - Chain ID
+   * @param opts - Optional overrides for API URL and timeout
+   * @returns Taker capacity response
+   */
+  async getTakerCapacity(req, opts) {
+    const baseApiUrl = (opts?.baseApiUrl ?? this.baseApiUrl ?? DEFAULT_BASE_API_URL).replace(
+      /\/$/,
+      ""
+    );
+    const timeoutMs = opts?.timeoutMs ?? this.apiTimeoutMs;
+    return apiGetTakerCapacity(req, baseApiUrl, timeoutMs);
   }
   /**
    * Fetch a referral dashboard. Pass `address` for a public wallet-keyed read;
@@ -8896,6 +9271,7 @@ var Zkp2pClient = class {
       unifiedPaymentVerifier: this.unifiedPaymentVerifier,
       rateManagerV1: this.rateManagerV1Address,
       orchestratorRegistry: this.orchestratorRegistryAddress,
+      stakeVault: this.stakeVaultAddress,
       usdc: this._usdcAddress
     };
   }
@@ -8970,6 +9346,97 @@ var createPeerExtensionSdk = (options = {}) => ({
 });
 var peerExtensionSdk = createPeerExtensionSdk();
 
-export { BASE_BUILDER_CODE, CHAINLINK_ORACLE_ADAPTER, CHAINLINK_ORACLE_FEEDS, ContractRouter, DEFAULT_ORACLE_MAX_STALENESS_SECONDS, IndexerClient, IndexerDepositService, IndexerRateManagerService, Zkp2pClient as OfframpClient, PAYMENT_PLATFORMS, PEER_EXTENSION_CHROME_URL, PLATFORM_METADATA, PYTH_CONTRACT_BASE, PYTH_ORACLE_ADAPTER, PYTH_ORACLE_FEEDS, REFERRAL_SIGNATURE_DOMAIN, REFERRAL_SIGNATURE_TYPES, SPREAD_ORACLE_FEEDS, SUPPORTED_CHAIN_IDS, TOKEN_METADATA, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiCreateReferralCode, apiCreateSellerCredentialBundle, apiGetDepositBundle, apiGetOrderbook, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetQuotesBestByPlatform, apiGetReferralDashboard, apiGetReferralEarnings, apiGetTakerTier, apiLookupReferralCode, apiPostDepositDetails, apiRedeemReferralCode, apiRequestIdentityAttestation, apiUpdateReferralCode, apiUploadGoogleOAuthSellerCredential, apiUploadSellerCredentialBundle, apiValidatePayeeDetails, apiVerifyBuyerTeePayment, appendAttributionToCalldata, assertValidReferrerFeeConfig, compareEventCursorIdsByRecency, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createEncryptedBuyerTeeSessionMaterial, createPeerExtensionSdk, defaultIndexerEndpoint, encodePythAdapterConfig, encodeSpreadOracleAdapterConfig, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, getSpreadOracleConfig, isPeerExtensionAvailable, isValidReferralCode, isValidReferrerFeeBps, isValidReferrerFeeRecipient, logger, normalizeReferralCode, openPeerExtensionInstallPage, parseReferrerFeeConfig, peerExtensionSdk, referrerFeeConfigToPreciseUnits, sendTransactionWithAttribution, setLogLevel, validateOracleFeedsOnChain };
+// src/riskMath.ts
+var RISK_BPS_DENOMINATOR = 10000n;
+var RISK_SECONDS_PER_HOUR = 3600n;
+var RISK_GRIEFING_DENOMINATOR = RISK_BPS_DENOMINATOR * RISK_SECONDS_PER_HOUR;
+function integer(value, label) {
+  if (typeof value === "number" && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new RangeError(`${label} must be a non-negative safe integer`);
+  }
+  const parsed = BigInt(value.toString());
+  if (parsed < 0n) throw new RangeError(`${label} must be non-negative`);
+  return parsed;
+}
+function ceilDiv(numerator, denominator) {
+  if (denominator <= 0n) throw new RangeError("denominator must be positive");
+  if (numerator === 0n) return 0n;
+  return (numerator - 1n) / denominator + 1n;
+}
+function calculateMaxGriefingBond(amount, terms) {
+  const bondedAmount = integer(amount, "amount");
+  const maxIntentPeriod = integer(terms.maxIntentPeriod, "maxIntentPeriod");
+  const griefingCliff = integer(terms.griefingCliff, "griefingCliff");
+  const slope = integer(terms.griefingPenaltyBpsPerHour, "griefingPenaltyBpsPerHour");
+  if (slope === 0n || maxIntentPeriod <= griefingCliff) return 0n;
+  return ceilDiv(
+    bondedAmount * slope * (maxIntentPeriod - griefingCliff),
+    RISK_GRIEFING_DENOMINATOR
+  );
+}
+function calculateChargebackReserve(amount, reserveBps) {
+  const bondedAmount = integer(amount, "amount");
+  const reserveRatio = integer(reserveBps, "reserveBps");
+  if (reserveRatio > RISK_BPS_DENOMINATOR) {
+    throw new RangeError("reserveBps cannot exceed 10,000");
+  }
+  return ceilDiv(bondedAmount * reserveRatio, RISK_BPS_DENOMINATOR);
+}
+function calculateRequiredReservation(amount, terms, reserveBps) {
+  const griefingBond = calculateMaxGriefingBond(amount, terms);
+  const chargebackReserve = calculateChargebackReserve(amount, reserveBps);
+  return griefingBond > chargebackReserve ? griefingBond : chargebackReserve;
+}
+function calculateGriefingPenalty(amount, createdAt, cancelledAt, terms) {
+  const bondedAmount = integer(amount, "amount");
+  const created = integer(createdAt, "createdAt");
+  const cancelled = integer(cancelledAt, "cancelledAt");
+  const maxIntentPeriod = integer(terms.maxIntentPeriod, "maxIntentPeriod");
+  const griefingCliff = integer(terms.griefingCliff, "griefingCliff");
+  const slope = integer(terms.griefingPenaltyBpsPerHour, "griefingPenaltyBpsPerHour");
+  if (cancelled <= created) return { penalty: 0n, effectiveElapsed: 0n };
+  const elapsed = cancelled - created;
+  const effectiveElapsed = elapsed < maxIntentPeriod ? elapsed : maxIntentPeriod;
+  if (slope === 0n || effectiveElapsed <= griefingCliff) {
+    return { penalty: 0n, effectiveElapsed };
+  }
+  const chargeableTime = effectiveElapsed - griefingCliff;
+  return {
+    penalty: ceilDiv(bondedAmount * slope * chargeableTime, RISK_GRIEFING_DENOMINATOR),
+    effectiveElapsed
+  };
+}
+function calculateBondedTakingCapacity(freeStake, terms, reserveBps) {
+  const available = integer(freeStake, "freeStake");
+  const maxIntentPeriod = integer(terms.maxIntentPeriod, "maxIntentPeriod");
+  const griefingCliff = integer(terms.griefingCliff, "griefingCliff");
+  const slope = integer(terms.griefingPenaltyBpsPerHour, "griefingPenaltyBpsPerHour");
+  const reserveRatio = integer(reserveBps, "reserveBps");
+  if (reserveRatio > RISK_BPS_DENOMINATOR) {
+    throw new RangeError("reserveBps cannot exceed 10,000");
+  }
+  const griefingRateNumerator = maxIntentPeriod > griefingCliff ? slope * (maxIntentPeriod - griefingCliff) : 0n;
+  const griefingCapacity = griefingRateNumerator === 0n ? null : available * RISK_GRIEFING_DENOMINATOR / griefingRateNumerator;
+  const chargebackCapacity = reserveRatio === 0n ? null : available * RISK_BPS_DENOMINATOR / reserveRatio;
+  let bondedTakingCapacity;
+  if (griefingCapacity === null) bondedTakingCapacity = chargebackCapacity;
+  else if (chargebackCapacity === null) bondedTakingCapacity = griefingCapacity;
+  else {
+    bondedTakingCapacity = griefingCapacity < chargebackCapacity ? griefingCapacity : chargebackCapacity;
+  }
+  return { griefingCapacity, chargebackCapacity, bondedTakingCapacity };
+}
+function calculateFreeTakeCapacity(freeTakeCount, freeTakesUsed, freeTakeAmount) {
+  const count = integer(freeTakeCount, "freeTakeCount");
+  const used = integer(freeTakesUsed, "freeTakesUsed");
+  const amount = integer(freeTakeAmount, "freeTakeAmount");
+  const remainingFreeTakes = used >= count ? 0n : count - used;
+  return {
+    remainingFreeTakes,
+    freeTakingCapacity: remainingFreeTakes * amount
+  };
+}
+
+export { BASE_BUILDER_CODE, CHAINLINK_ORACLE_ADAPTER, CHAINLINK_ORACLE_FEEDS, ContractRouter, DEFAULT_ORACLE_MAX_STALENESS_SECONDS, IndexerClient, IndexerDepositService, IndexerRateManagerService, 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, RISK_GRIEFING_DENOMINATOR, RISK_SECONDS_PER_HOUR, SPREAD_ORACLE_FEEDS, SUPPORTED_CHAIN_IDS, TOKEN_METADATA, ZKP2P_ANDROID_REFERRER, ZKP2P_IOS_REFERRER, Zkp2pClient, apiCreateReferralCode, apiCreateSellerCredentialBundle, apiGetDepositBundle, apiGetOrderbook, apiGetOrderbookTable, apiGetOwnerDeposits, apiGetPayeeDetails, apiGetQuotesBestByPlatform, apiGetReferralDashboard, apiGetReferralEarnings, apiGetTakerCapacity, apiGetTakerStake, apiLookupReferralCode, apiPostDepositDetails, apiRedeemReferralCode, apiRequestIdentityAttestation, apiUpdateReferralCode, apiUploadGoogleOAuthSellerCredential, apiUploadSellerCredentialBundle, apiValidatePayeeDetails, apiVerifyBuyerTeePayment, appendAttributionToCalldata, assertValidReferrerFeeConfig, calculateBondedTakingCapacity, calculateChargebackReserve, calculateFreeTakeCapacity, calculateGriefingPenalty, calculateMaxGriefingBond, calculateRequiredReservation, compareEventCursorIdsByRecency, convertDepositsForLiquidity, convertIndexerDepositToEscrowView, convertIndexerIntentsToEscrowViews, createCompositeDepositId, createEncryptedBuyerTeeSessionMaterial, createPeerExtensionSdk, defaultIndexerEndpoint, encodePythAdapterConfig, encodeSpreadOracleAdapterConfig, encodeWithAttribution, fetchFulfillmentAndPayment as fetchIndexerFulfillmentAndPayment, getAttributionDataSuffix, getPeerExtensionState, getSpreadOracleConfig, isPeerExtensionAvailable, isValidReferralCode, isValidReferrerFeeBps, isValidReferrerFeeRecipient, logger, normalizeReferralCode, openPeerExtensionInstallPage, parseReferrerFeeConfig, peerExtensionSdk, referrerFeeConfigToPreciseUnits, sendTransactionWithAttribution, setLogLevel, validateOracleFeedsOnChain };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map