@zkp2p/sdk 0.11.2 → 0.12.0

package/dist/index.mjs

@@ -2,12 +2,12 @@ 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-LPKFXAKY.mjs';
-export { PAYMENT_PLATFORMS, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getGatingServiceAddress, getIntentGuardianContract, getPaymentMethodsCatalog, getRateManagerContracts, hasIntentGuardian, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-LPKFXAKY.mjs';
+import { METHOD_NAME_TO_HASH, matchesQuotePaymentMethod, matchesPaymentMethodNameAndHash, getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, SUPPORTED_PAYMENT_METHOD_HASHES, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash } from './chunk-RYBXFY6X.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-RYBXFY6X.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, formatUnits } from 'viem';
+import { concatHex, encodeFunctionData, encodeAbiParameters, createPublicClient, http, isAddress, zeroAddress, formatUnits } from 'viem';
 import { hardhat, base } from 'viem/chains';
 import { createEncryptedBuyerTeeSessionMaterial as createEncryptedBuyerTeeSessionMaterial$1, createEncryptedSellerCredentialUpload } from '@zkp2p/zkp2p-attestation';
 export { createNitroAttestationClient } from '@zkp2p/zkp2p-attestation';
@@ -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-M7C2ICV3.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-LCSRVC7F.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-M7C2ICV3.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-LCSRVC7F.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-M7C2ICV3.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-LCSRVC7F.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-M7C2ICV3.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-LCSRVC7F.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-M7C2ICV3.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-LCSRVC7F.mjs');
     let lastError;
     for (const pvEntry of protocolViewerEntries) {
       const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
@@ -3559,6 +3559,68 @@ var FULFILLMENT_AND_PAYMENT_QUERY = (
   }
 `
 );
+var STAKING_STATE_QUERY = (
+  /* GraphQL */
+  `
+  query StakingState(
+    $takerStateId: String!
+    $stakeAccountId: String!
+    $claimAccountId: String!
+    $vaultConfigId: String!
+    $chainId: Int!
+    $vault: String!
+    $taker: String!
+    $policy: String!
+  ) {
+    TakerStakeState_by_pk(id: $takerStateId) {
+      taker
+      stakeOwner
+      selectedStakeOwner
+      selectionAuthorized
+      updatedAtBlockNumber
+      updatedAt
+    }
+    StakeAccountState_by_pk(id: $stakeAccountId) {
+      stakeOwner
+      totalStake
+      lockedStake
+      freeStake
+      updatedAtBlockNumber
+      updatedAt
+    }
+    ClaimAccountState_by_pk(id: $claimAccountId) {
+      beneficiary
+      claimableAmount
+      updatedAtBlockNumber
+      updatedAt
+    }
+    TakerStakeAuthorization(
+      where: { chainId: { _eq: $chainId }, vaultAddress: { _eq: $vault }, taker: { _eq: $taker } }
+      order_by: { updatedAt: desc }
+    ) {
+      stakeOwner
+      authorized
+      updatedAtBlockNumber
+      updatedAt
+    }
+    ChargebackRiskWindow(
+      where: { chainId: { _eq: $chainId }, policyAddress: { _eq: $policy } }
+      order_by: { paymentMethod: asc }
+    ) {
+      paymentMethod
+      riskWindow
+      updatedAt
+    }
+    StakeVaultConfig_by_pk(id: $vaultConfigId) {
+      controller
+      pendingController
+      pendingControllerValidAt
+      updatedAtBlockNumber
+      updatedAt
+    }
+  }
+`
+);
 
 // src/indexer/converters.ts
 var ZERO = "0x0000000000000000000000000000000000000000";
@@ -5453,6 +5515,110 @@ var AccessPolicyOperations = class {
     );
   }
 };
+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 };
+  }
+  getPolicyContract() {
+    const address = this.config.getChargebackPolicyAddress();
+    const abi = this.config.getChargebackPolicyAbi();
+    if (!address || !abi) {
+      throw new Error("ChargebackPolicy not available for this chain/environment");
+    }
+    return { address, abi };
+  }
+  read(functionName, args = []) {
+    const { address, abi } = this.getContract();
+    return this.config.getPublicClient().readContract({
+      address,
+      abi,
+      functionName,
+      args
+    });
+  }
+  readPolicy(functionName, args = []) {
+    const { address, abi } = this.getPolicyContract();
+    return this.config.getPublicClient().readContract({
+      address,
+      abi,
+      functionName,
+      args
+    });
+  }
+  getStakeBalance(stakeOwner) {
+    return this.read("stakeBalance", [stakeOwner]);
+  }
+  getLockedStake(stakeOwner) {
+    return this.read("lockedStake", [stakeOwner]);
+  }
+  getFreeStake(stakeOwner) {
+    return this.read("freeStake", [stakeOwner]);
+  }
+  getClaimable(beneficiary) {
+    return this.read("claimable", [beneficiary]);
+  }
+  getStakeOwner(taker) {
+    return this.read("stakeOwnerOf", [taker]);
+  }
+  getSelectedStakeOwner(taker) {
+    return this.read("selectedStakeOwner", [taker]);
+  }
+  getTakerAuthorization(stakeOwner, taker) {
+    return this.read("authorizedTakers", [stakeOwner, taker]);
+  }
+  /** Whether the policy is refusing new chargebackable admissions. */
+  getAdmissionsPaused() {
+    return this.readPolicy("admissionsPaused");
+  }
+  /**
+   * Minimum collateral lock window for a payment method, in seconds. Zero
+   * means intents on this method admit unbonded — no stake is locked at all.
+   */
+  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]);
+  }
+  async getStakeVaultState(params) {
+    const taker = params.taker ?? params.staker;
+    const { stakeToken } = this.getContract();
+    const [stakeOwner, rawSelection, staked, locked, free, claimable, admissionsPaused] = await Promise.all([
+      this.getStakeOwner(taker),
+      this.getSelectedStakeOwner(taker),
+      this.getStakeBalance(params.staker),
+      this.getLockedStake(params.staker),
+      this.getFreeStake(params.staker),
+      this.getClaimable(params.staker),
+      this.getAdmissionsPaused()
+    ]);
+    const selectedStakeOwner = rawSelection === zeroAddress ? null : rawSelection;
+    const selectionAuthorized = selectedStakeOwner ? await this.getTakerAuthorization(selectedStakeOwner, taker) : false;
+    return {
+      staker: params.staker,
+      taker,
+      stakeToken,
+      stakeOwner,
+      selectedStakeOwner,
+      selectionAuthorized,
+      staked,
+      locked,
+      free,
+      claimable,
+      admissionsPaused
+    };
+  }
+};
 
 // src/indexer/rateManagerService.ts
 var DEFAULT_LIMIT2 = 50;
@@ -6172,6 +6338,168 @@ var IndexerRateManagerService = class {
     }
   }
 };
+var ZERO_STAKE = {
+  totalUsdc: "0",
+  lockedUsdc: "0",
+  freeUsdc: "0"
+};
+function normalizeAddress4(value, field) {
+  if (!isAddress(value)) {
+    throw new ValidationError(`${field} must be a valid Ethereum address`, field);
+  }
+  return value.toLowerCase();
+}
+function normalizeNullableAddress(value, field) {
+  return value ? normalizeAddress4(value, field) : null;
+}
+function normalizeDecimal(value, field) {
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`${field} must be an unsigned decimal string`);
+  }
+  return value;
+}
+function freshnessOf(row, field) {
+  if (!row) return null;
+  return {
+    updatedAtBlockNumber: normalizeDecimal(
+      row.updatedAtBlockNumber,
+      `${field}.updatedAtBlockNumber`
+    ),
+    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 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 taker = normalizeAddress4(params.taker, "taker");
+  const stakeOwner = normalizeAddress4(params.stakeOwner, "stakeOwner");
+  return {
+    takerStateId: `${params.chainId}_${vaultAddress}_${taker}`,
+    stakeAccountId: `${params.chainId}_${vaultAddress}_${stakeOwner}`,
+    claimAccountId: `${params.chainId}_${vaultAddress}_${taker}`,
+    vaultConfigId: `${params.chainId}_${vaultAddress}`,
+    policy: chargebackPolicyAddress
+  };
+}
+var IndexerStakingService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  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(
+      {
+        query: STAKING_STATE_QUERY,
+        variables: {
+          ...ids,
+          chainId: params.chainId,
+          vault: vaultAddress,
+          taker
+        }
+      },
+      init
+    );
+    const takerState = data.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 stakeAccountOwner = stakeAccount ? normalizeAddress4(stakeAccount.stakeOwner, "StakeAccountState.stakeOwner") : requestedStakeOwner;
+    const stakeAccountMatchesEffectiveOwner = requestedStakeOwner === indexedStakeOwner && stakeAccountOwner === indexedStakeOwner;
+    const claimAccount = data.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) => ({
+      stakeOwner: normalizeAddress4(
+        authorization.stakeOwner,
+        `TakerStakeAuthorization[${index}].stakeOwner`
+      ),
+      authorized: authorization.authorized,
+      freshness: freshnessOf(
+        authorization,
+        `TakerStakeAuthorization[${index}]`
+      )
+    }));
+    const riskWindows = data.ChargebackRiskWindow.map((row, index) => ({
+      paymentMethod: row.paymentMethod,
+      riskWindowSeconds: normalizeDecimal(
+        row.riskWindow,
+        `ChargebackRiskWindow[${index}].riskWindow`
+      ),
+      updatedAt: normalizeDecimal(row.updatedAt, `ChargebackRiskWindow[${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 authorizationFreshness = authorizations.map((authorization) => authorization.freshness);
+    return {
+      chainId: params.chainId,
+      environment: params.environment,
+      taker,
+      stakeOwner: indexedStakeOwner,
+      selectedStakeOwner,
+      selectionAuthorized: takerState?.selectionAuthorized ?? false,
+      stake: stakeAccount && stakeAccountMatchesEffectiveOwner ? {
+        totalUsdc: normalizeDecimal(stakeAccount.totalStake, "StakeAccountState.totalStake"),
+        lockedUsdc: normalizeDecimal(
+          stakeAccount.lockedStake,
+          "StakeAccountState.lockedStake"
+        ),
+        freeUsdc: normalizeDecimal(stakeAccount.freeStake, "StakeAccountState.freeStake")
+      } : { ...ZERO_STAKE },
+      claimableUsdc: claimAccount ? normalizeDecimal(claimAccount.claimableAmount, "ClaimAccountState.claimableAmount") : "0",
+      authorizations,
+      riskWindows,
+      vault: data.StakeVaultConfig_by_pk ? {
+        controller: normalizeNullableAddress(
+          data.StakeVaultConfig_by_pk.controller,
+          "StakeVaultConfig.controller"
+        ),
+        pendingController: normalizeNullableAddress(
+          data.StakeVaultConfig_by_pk.pendingController,
+          "StakeVaultConfig.pendingController"
+        ),
+        pendingControllerValidAt: data.StakeVaultConfig_by_pk.pendingControllerValidAt ? normalizeDecimal(
+          data.StakeVaultConfig_by_pk.pendingControllerValidAt,
+          "StakeVaultConfig.pendingControllerValidAt"
+        ) : null
+      } : null,
+      stakeAccountMatchesEffectiveOwner,
+      freshness: {
+        takerStakeState: takerFreshness,
+        stakeAccountState: stakeFreshness,
+        claimAccountState: claimFreshness,
+        stakeVaultConfig: vaultFreshness,
+        authorizations: authorizationFreshness,
+        indexedBlockNumber: minimumBlockNumber([
+          takerFreshness,
+          stakeFreshness,
+          claimFreshness,
+          vaultFreshness,
+          ...authorizationFreshness
+        ])
+      }
+    };
+  }
+};
 
 // src/indexer/intentVerification.ts
 async function fetchFulfillmentAndPayment(client, intentHash) {
@@ -6518,6 +6846,41 @@ var Zkp2pClient = class {
    * @throws Error if walletClient is missing an account
    */
   constructor(opts) {
+    /** Deposit USDC stake owned by the transaction sender. */
+    this.depositStake = this.buildStakeVaultMethod(
+      "depositStake",
+      (params) => [params.amount]
+    );
+    /** Withdraw the sender's free stake immediately; locked stake cannot move. */
+    this.withdrawStake = this.buildStakeVaultMethod(
+      "withdrawStake",
+      (params) => [params.amount]
+    );
+    /** Withdraw the sender's complete claimable USDC balance. */
+    this.claim = this.buildStakeVaultMethod("claim", () => []);
+    /** Grant or revoke a taker's access to the sender's stake. */
+    this.setTakerAuthorization = this.buildStakeVaultMethod("setTakerAuthorization", (params) => [params.taker, params.authorized]);
+    /** Select the authorizing stake owner that backs the connected taker. */
+    this.selectStakeOwner = this.buildStakeVaultMethod(
+      "selectStakeOwner",
+      (params) => [params.stakeOwner]
+    );
+    /** Clear the connected taker's selection and return to self-stake. */
+    this.clearStakeOwner = this.buildStakeVaultMethod(
+      "clearStakeOwner",
+      () => []
+    );
+    /**
+     * Release one chargeback intent whose risk window matured, unlocking its
+     * stake cover. Permissionless once mature. Pass `chargebackPolicyAddress` to
+     * pin the transaction to a snapshotted deployment.
+     */
+    this.releaseMaturedChargebackIntent = this.buildChargebackPolicyMethod("releaseMaturedChargebackIntent", (params) => [params.intentHash]);
+    /**
+     * Release multiple matured chargeback intents in one transaction.
+     * Pass `chargebackPolicyAddress` to pin the transaction to a snapshotted deployment.
+     */
+    this.releaseMaturedChargebackIntents = this.buildChargebackPolicyMethod("releaseMaturedChargebackIntents", (params) => [params.intentHashes]);
     // ╔═══════════════════════════════════════════════════════════════════════════╗
     // ║ CORE: DEPOSIT MANAGEMENT                                                 ║
     // ╚═══════════════════════════════════════════════════════════════════════════╝
@@ -7450,6 +7813,10 @@ var Zkp2pClient = class {
     this.rateManagerControllerAbi = abis.rateManagerController;
     this.intentGuardianAddress = toAddress(addresses.intentGuardian);
     this.intentGuardianAbi = abis.intentGuardian;
+    this.stakeVaultAddress = toAddress(addresses.stakeVault);
+    this.stakeVaultAbi = abis.stakeVault;
+    this.chargebackPolicyAddress = toAddress(addresses.chargebackPolicy);
+    this.chargebackPolicyAbi = abis.chargebackPolicy;
     if (!this.rateManagerRegistryAddress || !this.rateManagerRegistryAbi) {
       try {
         const rateManagerContracts = getRateManagerContracts(this.chainId, this.runtimeEnv);
@@ -7493,6 +7860,7 @@ var Zkp2pClient = class {
     });
     this._indexerService = new IndexerDepositService(this._indexerClient);
     this._indexerRateManagerService = new IndexerRateManagerService(this._indexerClient);
+    this._indexerStakingService = new IndexerStakingService(this._indexerClient);
     this.baseApiUrl = opts.baseApiUrl;
     this.apiKey = opts.apiKey;
     this.apiHeaders = opts.apiHeaders;
@@ -7533,6 +7901,14 @@ var Zkp2pClient = class {
         prepareContractTransaction: (tx) => this.prepareContractTransaction(tx)
       }
     });
+    this._stakeOps = new StakeOperations({
+      getPublicClient: () => this.publicClient,
+      getStakeVaultAddress: () => this.stakeVaultAddress,
+      getStakeVaultAbi: () => this.stakeVaultAbi,
+      getStakeTokenAddress: () => this._usdcAddress,
+      getChargebackPolicyAddress: () => this.chargebackPolicyAddress,
+      getChargebackPolicyAbi: () => this.chargebackPolicyAbi
+    });
     this._intentGuardianOps = new IntentGuardianOperations({
       getPublicClient: () => this.publicClient,
       getGuardianAddress: () => this.intentGuardianAddress,
@@ -7947,7 +8323,7 @@ var Zkp2pClient = class {
   buildContractMethod(resolveContract, functionName, buildArgs, buildValue) {
     return Object.assign(
       async (params) => {
-        const contract = resolveContract();
+        const contract = resolveContract(params);
         if (!contract.address || !contract.abi) {
           throw new Error(`${contract.label} not available`);
         }
@@ -7963,7 +8339,7 @@ var Zkp2pClient = class {
       },
       {
         prepare: async (params) => {
-          const contract = resolveContract();
+          const contract = resolveContract(params);
           if (!contract.address || !contract.abi) {
             throw new Error(`${contract.label} not available`);
           }
@@ -7985,6 +8361,28 @@ var Zkp2pClient = class {
       }
     );
   }
+  buildStakeVaultMethod(functionName, buildArgs) {
+    return this.buildContractMethod(
+      () => ({
+        address: this.stakeVaultAddress,
+        abi: this.stakeVaultAbi,
+        label: "StakeVault"
+      }),
+      functionName,
+      buildArgs
+    );
+  }
+  buildChargebackPolicyMethod(functionName, buildArgs) {
+    return this.buildContractMethod(
+      (params) => ({
+        address: params.chargebackPolicyAddress ?? this.chargebackPolicyAddress,
+        abi: this.chargebackPolicyAbi,
+        label: "ChargebackPolicy"
+      }),
+      functionName,
+      buildArgs
+    );
+  }
   buildIntentGuardianMethod(functionName, buildArgs) {
     return this.buildContractMethod(
       () => ({
@@ -8235,6 +8633,7 @@ var Zkp2pClient = class {
   get indexer() {
     const service = this._indexerService;
     const rateManagerService = this._indexerRateManagerService;
+    const stakingService = this._indexerStakingService;
     const client = this._indexerClient;
     return {
       /** Raw GraphQL client for custom queries */
@@ -8371,6 +8770,16 @@ var Zkp2pClient = class {
       getOracleConfigUpdates: (rateManagerId, options) => {
         return rateManagerService.fetchOracleConfigUpdates(rateManagerId, options);
       },
+      /**
+       * Composes the hard-cut 0.14.0-rc.0 staking current-state rows. Pass the
+       * caller's fresh stakeOwnerOf(taker) result so the account rows can be
+       * fetched together and checked against indexed ownership.
+       */
+      getStakingState: (params, options) => {
+        return stakingService.fetchStakingState(params, {
+          signal: options?.signal
+        });
+      },
       /**
        * Fetches chronological fund activities for a specific deposit.
        */
@@ -8453,6 +8862,91 @@ 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();
+  }
+  /** Return the resolved OrchestratorV3 coordinates for advanced integrations. */
+  getOrchestratorV3Contract() {
+    if (!this.orchestratorV3Address || !this.orchestratorV3Abi) {
+      throw new Error("OrchestratorV3 not available for this chain/environment");
+    }
+    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 { address: this.chargebackPolicyAddress, abi: this.chargebackPolicyAbi };
+  }
+  /**
+   * 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(stakeOwner) {
+    return this._stakeOps.getStakeBalance(stakeOwner);
+  }
+  /** Read stake committed to active StakeVault locks. */
+  getLockedStake(stakeOwner) {
+    return this._stakeOps.getLockedStake(stakeOwner);
+  }
+  /** Read stake available for immediate withdrawal or a new lock. */
+  getFreeStake(stakeOwner) {
+    return this._stakeOps.getFreeStake(stakeOwner);
+  }
+  /** Read the non-stake USDC withdrawable by a beneficiary with `claim()`. */
+  getClaimable(beneficiary) {
+    return this._stakeOps.getClaimable(beneficiary);
+  }
+  /** Resolve the effective stake owner backing a taker. */
+  getStakeOwner(taker) {
+    return this._stakeOps.getStakeOwner(taker);
+  }
+  /** Read a taker's raw selection, which is stale once authorization is revoked. */
+  getSelectedStakeOwner(taker) {
+    return this._stakeOps.getSelectedStakeOwner(taker);
+  }
+  /** Read whether a stake owner currently authorizes a taker. */
+  getTakerAuthorization(stakeOwner, taker) {
+    return this._stakeOps.getTakerAuthorization(stakeOwner, taker);
+  }
+  /** Read the complete authoritative StakeVault state needed by a staking UI. */
+  getStakeVaultState(params) {
+    return this._stakeOps.getStakeVaultState(params);
+  }
+  /** Read whether the ChargebackPolicy is refusing new chargebackable admissions. */
+  getAdmissionsPaused() {
+    return this._stakeOps.getAdmissionsPaused();
+  }
+  /**
+   * Read a payment method's minimum collateral lock window in seconds. Zero
+   * means the method admits unbonded — no stake is locked at admission.
+   */
+  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);
+  }
   /**
    * Registers payee details with the curator API and returns hashed on-chain IDs.
    *
@@ -9249,6 +9743,8 @@ var Zkp2pClient = class {
       unifiedPaymentVerifier: this.unifiedPaymentVerifier,
       rateManagerV1: this.rateManagerV1Address,
       orchestratorRegistry: this.orchestratorRegistryAddress,
+      stakeVault: this.stakeVaultAddress,
+      chargebackPolicy: this.chargebackPolicyAddress,
       usdc: this._usdcAddress
     };
   }
@@ -9311,18 +9807,46 @@ var getPeerExtensionState = async (options) => {
     return "needs_connection";
   }
 };
+var sanitizePeerAuthenticateParams = (params) => {
+  const sanitizedParams = { ...params };
+  delete sanitizedParams.providerConfig;
+  return sanitizedParams;
+};
 var createPeerExtensionSdk = (options = {}) => ({
   isAvailable: () => isPeerExtensionAvailable(options),
   requestConnection: () => requirePeer(options).requestConnection(),
   checkConnectionStatus: () => requirePeer(options).checkConnectionStatus(),
   getVersion: () => requirePeer(options).getVersion(),
-  authenticate: (params) => requirePeer(options).authenticate(params),
+  authenticate: (params) => requirePeer(options).authenticate(sanitizePeerAuthenticateParams(params)),
   onMetadataMessage: (callback) => requirePeer(options).onMetadataMessage(callback),
   openInstallPage: () => openPeerExtensionInstallPage(options),
   getState: () => getPeerExtensionState(options)
 });
 var peerExtensionSdk = createPeerExtensionSdk();
 
+// src/riskMath.ts
+var RISK_BPS_DENOMINATOR = 10000n;
+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 calculateRequiredCoverage(amount, chargebackable) {
+  return chargebackable ? 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";
+  if (integer(freeStake, "freeStake") >= required) return "STAKE_BACKED";
+  throw new RangeError("insufficient free stake for chargebackable admission");
+}
+
 // src/client/accessPolicyPlan.ts
 var MAX_GROUPS_PER_DEPOSIT = 10;
 var MAX_ADDRESSES_PER_CALL = 50;
@@ -9479,6 +10003,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, 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, 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, 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, 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, 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