@zkp2p/sdk 0.9.0 → 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 { METHOD_NAME_TO_HASH, matchesQuotePaymentMethod, matchesPaymentMethodNameAndHash, getContracts, getRateManagerContracts, getPaymentMethodsCatalog, resolvePaymentMethodHashFromCatalog, getGatingServiceAddress, parseBigIntLike, SUPPORTED_PAYMENT_METHOD_HASHES, resolveFiatCurrencyBytes32, resolvePaymentMethodNameFromHash } from './chunk-FSIRPX4W.mjs';
-export { PAYMENT_PLATFORMS, asciiToBytes32, enrichPvDepositView, enrichPvIntentView, ensureBytes32, getContracts, getGatingServiceAddress, getPaymentMethodsCatalog, getRateManagerContracts, parseDepositView, parseIntentView, resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-FSIRPX4W.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';
@@ -1968,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-ER62YZ5L.mjs');
+      const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
       if (inputCount >= 3) {
         return tryContexts(
           protocolViewerContexts,
@@ -2047,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-ER62YZ5L.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     if (inputCount >= 2) {
       const requests = ids.map((id, index) => ({
         index,
@@ -2152,7 +2152,7 @@ var ProtocolViewerReader = class {
     if (!protocolViewerAddress || !protocolViewerAbi || inputCount === null) {
       return this.config.host.getPvAccountDepositsFromIndexer(owner);
     }
-    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-ER62YZ5L.mjs');
+    const { parseDepositView: parseDepositView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     const { address, abi } = this.config.host.requireProtocolViewer();
     if (inputCount >= 2) {
       const readAndFilter = async (raw2) => {
@@ -2223,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-ER62YZ5L.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     const intentsByHash = /* @__PURE__ */ new Map();
     let attemptedRead = false;
     let hadSuccessfulRead = false;
@@ -2331,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-ER62YZ5L.mjs');
+    const { parseIntentView: parseIntentView2 } = await import('./protocolViewerParsers-VDFKSVGT.mjs');
     let lastError;
     for (const pvEntry of protocolViewerEntries) {
       const inputCount = this.pvEntryFunctionInputCount(pvEntry, "getIntent");
@@ -4525,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/tier?${query.toString()}`;
+  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/capacity?${query.toString()}`;
   return apiFetch({
     url: `${withApiBase(baseApiUrl)}${endpoint}`,
     method: "GET",
@@ -5252,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;
@@ -6311,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                                                 ║
     // ╚═══════════════════════════════════════════════════════════════════════════╝
@@ -7209,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);
@@ -7289,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,
@@ -7746,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) => {
@@ -8203,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.
    *
@@ -8638,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;
@@ -8993,6 +9271,7 @@ var Zkp2pClient = class {
       unifiedPaymentVerifier: this.unifiedPaymentVerifier,
       rateManagerV1: this.rateManagerV1Address,
       orchestratorRegistry: this.orchestratorRegistryAddress,
+      stakeVault: this.stakeVaultAddress,
       usdc: this._usdcAddress
     };
   }
@@ -9067,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, 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, 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