@p2pdotme/sdk 1.2.17 → 1.2.19

package/dist/react.cjs

@@ -34,6 +34,7 @@ __export(react_exports, {
   useFingerprint: () => useFingerprint,
   useFraudEngine: () => useFraudEngine,
   useOrders: () => useOrders,
+  usePlacementLimits: () => usePlacementLimits,
   usePrices: () => usePrices,
   useProfile: () => useProfile,
   useSdk: () => useSdk,
@@ -110,6 +111,7 @@ var CURRENCY = {
   ARS: "ARS",
   MEX: "MEX",
   VEN: "VEN",
+  BOB: "BOB",
   EUR: "EUR",
   NGN: "NGN",
   USD: "USD",
@@ -1723,6 +1725,9 @@ var ZodGetOrderParamsSchema = import_zod3.z.object({
 var ZodGetFeeConfigParamsSchema = import_zod3.z.object({
   currency: ZodCurrencySchema
 });
+var ZodGetPlacementLimitsParamsSchema = import_zod3.z.object({
+  userAddress: ZodAddressSchema
+});
 var ZodGetOrdersParamsSchema = import_zod3.z.object({
   userAddress: ZodAddressSchema,
   skip: import_zod3.z.number().int().min(0).default(0),
@@ -1783,6 +1788,19 @@ var ZodSubgraphOrderSchema = import_zod3.z.object({
 var ZodSubgraphOrdersResponseSchema = import_zod3.z.object({
   orders_collection: import_zod3.z.array(ZodSubgraphOrderSchema)
 });
+var ZodSubgraphPlacementLimitsResponseSchema = import_zod3.z.object({
+  userDailyPlacements: import_zod3.z.object({
+    dayIndex: import_zod3.z.string(),
+    buyPlacements: import_zod3.z.string(),
+    sellPlacements: import_zod3.z.string()
+  }).nullish(),
+  orderPlacementLimitConfig: import_zod3.z.object({
+    dailyBuyOrderPlacementLimit: import_zod3.z.string(),
+    buyLimitConfigured: import_zod3.z.boolean(),
+    dailySellOrderPlacementLimit: import_zod3.z.string(),
+    sellLimitConfigured: import_zod3.z.boolean()
+  }).nullish()
+});
 
 // src/orders/actions/approve-usdc.ts
 function createApproveUsdcAction(input) {
@@ -5156,6 +5174,10 @@ var contractErrors = {
   // Order limits
   DailyBuyOrderLimitExceeded: "DAILY_BUY_ORDER_LIMIT_EXCEEDED",
   MonthlyBuyOrderLimitExceeded: "MONTHLY_BUY_ORDER_LIMIT_EXCEEDED",
+  // Gross placement caps: counted when the order is placed and never given
+  // back when it is cancelled, unlike the volume limits above.
+  DailyBuyOrderPlacementLimitExceeded: "DAILY_BUY_ORDER_PLACEMENT_LIMIT_EXCEEDED",
+  DailySellOrderPlacementLimitExceeded: "DAILY_SELL_ORDER_PLACEMENT_LIMIT_EXCEEDED",
   SellOrderAmountLimitExceeded: "SELL_ORDER_AMOUNT_LIMIT_EXCEEDED",
   BuyOrderAmountExceedsLimit: "BUY_ORDER_AMOUNT_EXCEEDS_LIMIT",
   SellOrderAmountExceedsLimit: "SELL_ORDER_AMOUNT_EXCEEDS_LIMIT",
@@ -5367,6 +5389,8 @@ var hexContractErrors = {
   // Order limits
   "0xe595a7bf": contractErrors.DailyBuyOrderLimitExceeded,
   "0x675dbc86": contractErrors.MonthlyBuyOrderLimitExceeded,
+  "0x917c7aef": contractErrors.DailyBuyOrderPlacementLimitExceeded,
+  "0x4688ce73": contractErrors.DailySellOrderPlacementLimitExceeded,
   "0x64301cb8": contractErrors.SellOrderAmountLimitExceeded,
   "0x91da284f": contractErrors.BuyOrderAmountExceedsLimit,
   "0xb407b9ec": contractErrors.SellOrderAmountExceedsLimit,
@@ -6568,6 +6592,7 @@ function normalizeSubgraphOrder(raw) {
 
 // src/orders/subgraph/index.ts
 var import_neverthrow17 = require("neverthrow");
+var import_viem19 = require("viem");
 
 // src/orders/subgraph/queries.ts
 var ORDERS_BY_USER_QUERY = (
@@ -6604,8 +6629,35 @@ var ORDERS_BY_USER_QUERY = (
   }
 `
 );
+var PLACEMENT_LIMITS_QUERY = (
+  /* GraphQL */
+  `
+  query PlacementLimits($placementsId: ID!, $configId: ID!) {
+    userDailyPlacements(id: $placementsId) {
+      dayIndex
+      buyPlacements
+      sellPlacements
+    }
+    orderPlacementLimitConfig(id: $configId) {
+      dailyBuyOrderPlacementLimit
+      buyLimitConfigured
+      dailySellOrderPlacementLimit
+      sellLimitConfigured
+    }
+  }
+`
+);
 
 // src/orders/subgraph/index.ts
+var SECONDS_PER_DAY = 86400;
+var PLACEMENT_LIMIT_CONFIG_ID = (0, import_viem19.stringToHex)("placement-limits");
+function bucket(used, limit, configured, zeroMeansUnlimited) {
+  if (!configured) return { used, limit: null, remaining: null, state: "unknown" };
+  if (limit === 0 && zeroMeansUnlimited) {
+    return { used, limit: null, remaining: null, state: "unlimited" };
+  }
+  return { used, limit, remaining: Math.max(0, limit - used), state: "enforced" };
+}
 function getOrdersForUser(subgraphUrl, userAddress, skip, limit, logger = noopLogger) {
   const user = userAddress.toLowerCase();
   logger.debug("fetching orders from subgraph", { subgraphUrl, user, skip, limit });
@@ -6632,6 +6684,54 @@ function getOrdersForUser(subgraphUrl, userAddress, skip, limit, logger = noopLo
     )
   );
 }
+function getPlacementLimitsForUser(subgraphUrl, userAddress, nowSeconds, logger = noopLogger) {
+  const user = userAddress.toLowerCase();
+  const dayIndex = Math.floor(nowSeconds / SECONDS_PER_DAY);
+  const placementsId = (0, import_viem19.stringToHex)(`${user}-${dayIndex}`);
+  logger.debug("fetching placement limits from subgraph", { subgraphUrl, user, dayIndex });
+  return querySubgraph(subgraphUrl, {
+    query: PLACEMENT_LIMITS_QUERY,
+    variables: { placementsId, configId: PLACEMENT_LIMIT_CONFIG_ID }
+  }).mapErr(
+    (e) => new OrdersError(e.message, {
+      code: "SUBGRAPH_REQUEST_FAILED",
+      cause: e.cause ?? e,
+      context: { user, dayIndex, ...e.context ?? {} }
+    })
+  ).andThen(
+    (data) => validate(
+      ZodSubgraphPlacementLimitsResponseSchema,
+      data,
+      (message, cause, d) => new OrdersError(message, {
+        code: "SUBGRAPH_VALIDATION_FAILED",
+        cause,
+        context: { data: d }
+      })
+    )
+  ).map((validated) => {
+    const placements = validated.userDailyPlacements;
+    const config = validated.orderPlacementLimitConfig;
+    const buyUsed = placements ? Number(placements.buyPlacements) : 0;
+    const sellUsed = placements ? Number(placements.sellPlacements) : 0;
+    return {
+      dayIndex,
+      resetsAt: (dayIndex + 1) * SECONDS_PER_DAY,
+      // A zero BUY cap is a hard block on-chain, not "unlimited".
+      buy: bucket(
+        buyUsed,
+        config ? Number(config.dailyBuyOrderPlacementLimit) : 0,
+        config?.buyLimitConfigured ?? false,
+        false
+      ),
+      sellPay: bucket(
+        sellUsed,
+        config ? Number(config.dailySellOrderPlacementLimit) : 0,
+        config?.sellLimitConfigured ?? false,
+        true
+      )
+    };
+  });
+}
 
 // src/orders/watch-events.ts
 var PLACED_CONFIG = {
@@ -6807,6 +6907,19 @@ function createOrders(config) {
         ({ userAddress, skip, limit }) => getOrdersForUser(subgraphUrl, userAddress, skip, limit, logger)
       );
     },
+    getPlacementLimits(params) {
+      return validate(
+        ZodGetPlacementLimitsParamsSchema,
+        params,
+        (message, cause, d) => new OrdersError(message, {
+          code: "INVALID_PLACEMENT_LIMITS_PARAMS",
+          cause,
+          context: { params: d }
+        })
+      ).asyncAndThen(
+        ({ userAddress }) => getPlacementLimitsForUser(subgraphUrl, userAddress, Math.floor(Date.now() / 1e3), logger)
+      );
+    },
     getFeeConfig(params) {
       return validate(
         ZodGetFeeConfigParamsSchema,
@@ -6877,7 +6990,7 @@ function createPrices(config) {
 
 // src/profile/contracts/actions.ts
 var import_neverthrow19 = require("neverthrow");
-var import_viem19 = require("viem");
+var import_viem20 = require("viem");
 function getBalances(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
     ZodGetBalancesParamsSchema,
@@ -6902,8 +7015,8 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
         })
       )
     ]).map(([usdc, priceConfig]) => {
-      const usdcFormatted = Number((0, import_viem19.formatUnits)(usdc, 6));
-      const sellPriceFormatted = Number((0, import_viem19.formatUnits)(priceConfig.sellPrice, 6));
+      const usdcFormatted = Number((0, import_viem20.formatUnits)(usdc, 6));
+      const sellPriceFormatted = Number((0, import_viem20.formatUnits)(priceConfig.sellPrice, 6));
       return {
         usdc: usdcFormatted,
         fiat: usdcFormatted * sellPriceFormatted,
@@ -6926,7 +7039,7 @@ function createProfile(config) {
 
 // src/stake/actions/cancel-unstake.ts
 var import_neverthrow21 = require("neverthrow");
-var import_viem20 = require("viem");
+var import_viem21 = require("viem");
 
 // src/stake/tx.ts
 var import_neverthrow20 = require("neverthrow");
@@ -6982,7 +7095,7 @@ function createCancelUnstakeAction(input) {
   const { publicClient, diamondAddress } = input;
   const prepareFn = () => (0, import_neverthrow21.okAsync)({
     to: diamondAddress,
-    data: (0, import_viem20.encodeFunctionData)({
+    data: (0, import_viem21.encodeFunctionData)({
       abi: ABIS.FACETS.STAKE,
       functionName: "p2pBoostCancelUnstake",
       args: []
@@ -7003,12 +7116,12 @@ function createCancelUnstakeAction(input) {
 
 // src/stake/actions/claim-unstake.ts
 var import_neverthrow22 = require("neverthrow");
-var import_viem21 = require("viem");
+var import_viem22 = require("viem");
 function createClaimUnstakeAction(input) {
   const { publicClient, diamondAddress } = input;
   const prepareFn = () => (0, import_neverthrow22.okAsync)({
     to: diamondAddress,
-    data: (0, import_viem21.encodeFunctionData)({
+    data: (0, import_viem22.encodeFunctionData)({
       abi: ABIS.FACETS.STAKE,
       functionName: "p2pBoostClaimUnstake",
       args: []
@@ -7029,12 +7142,12 @@ function createClaimUnstakeAction(input) {
 
 // src/stake/actions/request-unstake.ts
 var import_neverthrow23 = require("neverthrow");
-var import_viem22 = require("viem");
+var import_viem23 = require("viem");
 function createRequestUnstakeAction(input) {
   const { publicClient, diamondAddress } = input;
   const prepareFn = () => (0, import_neverthrow23.okAsync)({
     to: diamondAddress,
-    data: (0, import_viem22.encodeFunctionData)({
+    data: (0, import_viem23.encodeFunctionData)({
       abi: ABIS.FACETS.STAKE,
       functionName: "p2pBoostRequestUnstake",
       args: []
@@ -7054,7 +7167,7 @@ function createRequestUnstakeAction(input) {
 }
 
 // src/stake/actions/stake.ts
-var import_viem23 = require("viem");
+var import_viem24 = require("viem");
 function createStakeAction(input) {
   const { publicClient, diamondAddress } = input;
   const prepareFn = (params) => validate(
@@ -7067,7 +7180,7 @@ function createStakeAction(input) {
     })
   ).map(({ tokens }) => ({
     to: diamondAddress,
-    data: (0, import_viem23.encodeFunctionData)({
+    data: (0, import_viem24.encodeFunctionData)({
       abi: ABIS.FACETS.STAKE,
       functionName: "p2pBoostStake",
       args: [tokens]
@@ -7087,7 +7200,7 @@ function createStakeAction(input) {
 }
 
 // src/stake/actions/top-up.ts
-var import_viem24 = require("viem");
+var import_viem25 = require("viem");
 function createTopUpAction(input) {
   const { publicClient, diamondAddress } = input;
   const prepareFn = (params) => validate(
@@ -7100,7 +7213,7 @@ function createTopUpAction(input) {
     })
   ).map(({ tokens }) => ({
     to: diamondAddress,
-    data: (0, import_viem24.encodeFunctionData)({
+    data: (0, import_viem25.encodeFunctionData)({
       abi: ABIS.FACETS.STAKE,
       functionName: "p2pBoostTopUp",
       args: [tokens]
@@ -7290,16 +7403,74 @@ function useFraudEngine() {
   return fraudEngine;
 }
 
-// src/react/use-watch-orders.ts
+// src/react/use-placement-limits.ts
 var import_react2 = require("react");
+function usePlacementLimits(params) {
+  const orders = useOrders();
+  const { userAddress, pollMs } = params;
+  const [limits, setLimits] = (0, import_react2.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const requestIdRef = (0, import_react2.useRef)(0);
+  const mountedRef = (0, import_react2.useRef)(true);
+  (0, import_react2.useEffect)(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const refresh = (0, import_react2.useCallback)(() => {
+    if (!userAddress) {
+      requestIdRef.current++;
+      setLimits(null);
+      setError(null);
+      setIsLoading(false);
+      return;
+    }
+    const requestId = ++requestIdRef.current;
+    setIsLoading(true);
+    orders.getPlacementLimits({ userAddress }).match(
+      (next) => {
+        if (!mountedRef.current || requestId !== requestIdRef.current) return;
+        setLimits(next);
+        setError(null);
+        setIsLoading(false);
+      },
+      (cause) => {
+        if (!mountedRef.current || requestId !== requestIdRef.current) return;
+        setError(cause);
+        setIsLoading(false);
+      }
+    );
+  }, [orders, userAddress]);
+  (0, import_react2.useEffect)(() => {
+    refresh();
+  }, [refresh]);
+  (0, import_react2.useEffect)(() => {
+    if (!pollMs || !userAddress) return;
+    const timer = setInterval(refresh, pollMs);
+    return () => clearInterval(timer);
+  }, [pollMs, userAddress, refresh]);
+  (0, import_react2.useEffect)(() => {
+    if (!limits || !userAddress) return;
+    const msUntilReset = limits.resetsAt * 1e3 - Date.now();
+    if (msUntilReset <= 0) return;
+    const timer = setTimeout(refresh, msUntilReset + 1e3);
+    return () => clearTimeout(timer);
+  }, [limits, userAddress, refresh]);
+  return { limits, isLoading, error, refresh };
+}
+
+// src/react/use-watch-orders.ts
+var import_react3 = require("react");
 function useWatchOrders(params) {
   const orders = useOrders();
   const { user, onEvent, onError } = params;
-  const onEventRef = (0, import_react2.useRef)(onEvent);
-  const onErrorRef = (0, import_react2.useRef)(onError);
+  const onEventRef = (0, import_react3.useRef)(onEvent);
+  const onErrorRef = (0, import_react3.useRef)(onError);
   onEventRef.current = onEvent;
   onErrorRef.current = onError;
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     const unsubscribe = orders.watchEvents({
       user,
       onEvent: (event) => onEventRef.current(event),
@@ -7310,12 +7481,12 @@ function useWatchOrders(params) {
 }
 
 // src/fraud-engine/react/use-fingerprint.ts
-var import_react3 = require("react");
+var import_react4 = require("react");
 function useFingerprint(enabled) {
-  const [data, setData] = (0, import_react3.useState)(null);
-  const [error, setError] = (0, import_react3.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
-  (0, import_react3.useEffect)(() => {
+  const [data, setData] = (0, import_react4.useState)(null);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
+  (0, import_react4.useEffect)(() => {
     if (!enabled) return;
     let cancelled = false;
     setIsLoading(true);
@@ -7348,6 +7519,7 @@ function useFingerprint(enabled) {
   useFingerprint,
   useFraudEngine,
   useOrders,
+  usePlacementLimits,
   usePrices,
   useProfile,
   useSdk,