@p2pdotme/sdk 1.1.8 → 1.2.0

package/dist/react.cjs

@@ -37,6 +37,7 @@ __export(react_exports, {
   usePrices: () => usePrices,
   useProfile: () => useProfile,
   useSdk: () => useSdk,
+  useStake: () => useStake,
   useWatchOrders: () => useWatchOrders,
   useZkkyc: () => useZkkyc
 });
@@ -685,7 +686,7 @@ function createFraudEngine(config) {
 }
 
 // src/orders/client.ts
-var import_neverthrow17 = require("neverthrow");
+var import_neverthrow18 = require("neverthrow");
 
 // src/contracts/order-processor/index.ts
 var import_neverthrow5 = require("neverthrow");
@@ -1171,6 +1172,104 @@ var p2pConfigFacetAbi = [
   }
 ];
 
+// src/contracts/abis/p2p-stake-boost-facet.ts
+var p2pStakeBoostFacetAbi = [
+  {
+    inputs: [{ internalType: "uint256", name: "tokens", type: "uint256" }],
+    name: "p2pBoostStake",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "tokens", type: "uint256" }],
+    name: "p2pBoostTopUp",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "p2pBoostRequestUnstake",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "p2pBoostClaimUnstake",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "p2pBoostCancelUnstake",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "user", type: "address" }],
+    name: "getUserStake",
+    outputs: [
+      {
+        components: [
+          { internalType: "uint128", name: "stakedAmount", type: "uint128" },
+          { internalType: "uint64", name: "cooldownEnd", type: "uint64" },
+          { internalType: "uint8", name: "status", type: "uint8" }
+        ],
+        internalType: "struct P2PStakeBoostStorage.UserStake",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "currency", type: "bytes32" }],
+    name: "getStakeBoostConfig",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "tokensPerUsdNumerator",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "tokensPerUsdDenominator",
+            type: "uint256"
+          },
+          { internalType: "uint256", name: "maxBoostUsd", type: "uint256" }
+        ],
+        internalType: "struct P2PStakeBoostStorage.BoostConfig",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getStakeBoostGlobals",
+    outputs: [
+      { internalType: "address", name: "p2pToken", type: "address" },
+      { internalType: "address", name: "fraudReserve", type: "address" },
+      { internalType: "uint256", name: "maxStakeTokens", type: "uint256" },
+      { internalType: "uint256", name: "normalCooldown", type: "uint256" },
+      { internalType: "uint256", name: "blacklistCooldown", type: "uint256" },
+      { internalType: "uint8", name: "tokenDecimals", type: "uint8" },
+      { internalType: "uint256", name: "totalStaked", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
 // src/contracts/abis/reputation-manager.ts
 var reputationManagerAbi = [
   {
@@ -1377,14 +1476,16 @@ var reputationManagerAbi = [
 var DIAMOND_ABI = [
   ...orderFlowFacetAbi,
   ...orderProcessorFacetAbi,
-  ...p2pConfigFacetAbi
+  ...p2pConfigFacetAbi,
+  ...p2pStakeBoostFacetAbi
 ];
 var ABIS = {
   DIAMOND: DIAMOND_ABI,
   FACETS: {
     ORDER_FLOW: orderFlowFacetAbi,
     ORDER_PROCESSOR: orderProcessorFacetAbi,
-    CONFIG: p2pConfigFacetAbi
+    CONFIG: p2pConfigFacetAbi,
+    STAKE: p2pStakeBoostFacetAbi
   },
   EXTERNAL: {
     USDC: import_viem2.erc20Abi,
@@ -3898,15 +3999,15 @@ function weierstrassPoints(opts) {
       throw new Error("ProjectivePoint expected");
   }
   const toAffineMemo = memoized((p, iz) => {
-    const { px: x, py: y, pz: z10 } = p;
-    if (Fp.eql(z10, Fp.ONE))
+    const { px: x, py: y, pz: z11 } = p;
+    if (Fp.eql(z11, Fp.ONE))
       return { x, y };
     const is0 = p.is0();
     if (iz == null)
-      iz = is0 ? Fp.ONE : Fp.inv(z10);
+      iz = is0 ? Fp.ONE : Fp.inv(z11);
     const ax = Fp.mul(x, iz);
     const ay = Fp.mul(y, iz);
-    const zz = Fp.mul(z10, iz);
+    const zz = Fp.mul(z11, iz);
     if (is0)
       return { x: Fp.ZERO, y: Fp.ZERO };
     if (!Fp.eql(zz, Fp.ONE))
@@ -4901,7 +5002,7 @@ function createSetSellOrderUpiAction(input) {
 }
 
 // src/orders/internal/routing/client.ts
-var import_viem16 = require("viem");
+var import_viem17 = require("viem");
 
 // src/contracts/errors.ts
 var contractErrors = {
@@ -5493,10 +5594,132 @@ function getReputationPerUsdcLimit(publicClient, diamondAddress, params) {
   );
 }
 
-// src/contracts/reputation-manager/writes.ts
+// src/contracts/p2p-stake/index.ts
 var import_neverthrow11 = require("neverthrow");
 var import_viem13 = require("viem");
 
+// src/stake/errors.ts
+var StakeError = class extends SdkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StakeError";
+  }
+};
+
+// src/stake/validation.ts
+var import_zod8 = require("zod");
+var ZodGetUserStakeParamsSchema = import_zod8.z.object({
+  user: ZodAddressSchema
+});
+var ZodGetStakeBoostConfigParamsSchema = import_zod8.z.object({
+  currency: ZodCurrencySchema
+});
+var ZodGetP2pTokenBalanceParamsSchema = import_zod8.z.object({
+  address: ZodAddressSchema
+});
+var ZodStakeParamsSchema = import_zod8.z.object({
+  tokens: import_zod8.z.bigint().positive()
+});
+var ZodTopUpParamsSchema = import_zod8.z.object({
+  tokens: import_zod8.z.bigint().positive()
+});
+
+// src/contracts/p2p-stake/index.ts
+function getUserStake(publicClient, diamondAddress, params) {
+  return validate(
+    ZodGetUserStakeParamsSchema,
+    params,
+    (message, cause, data) => new StakeError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow11.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: diamondAddress,
+        abi: ABIS.FACETS.STAKE,
+        functionName: "getUserStake",
+        args: [validated.user]
+      }),
+      (error) => new StakeError("Failed to read user stake", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { user: validated.user, diamondAddress }
+      })
+    )
+  );
+}
+function getStakeBoostConfig(publicClient, diamondAddress, params) {
+  return validate(
+    ZodGetStakeBoostConfigParamsSchema,
+    params,
+    (message, cause, data) => new StakeError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow11.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: diamondAddress,
+        abi: ABIS.FACETS.STAKE,
+        functionName: "getStakeBoostConfig",
+        args: [(0, import_viem13.stringToHex)(validated.currency, { size: 32 })]
+      }),
+      (error) => new StakeError("Failed to read stake boost config", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { currency: validated.currency, diamondAddress }
+      })
+    )
+  );
+}
+function getStakeBoostGlobals(publicClient, diamondAddress) {
+  return import_neverthrow11.ResultAsync.fromPromise(
+    publicClient.readContract({
+      address: diamondAddress,
+      abi: ABIS.FACETS.STAKE,
+      functionName: "getStakeBoostGlobals",
+      args: []
+    }),
+    (error) => new StakeError("Failed to read stake boost globals", {
+      code: "CONTRACT_READ_ERROR",
+      cause: error,
+      context: { diamondAddress }
+    })
+  );
+}
+function getP2pTokenBalance(publicClient, p2pTokenAddress, params) {
+  return validate(
+    ZodGetP2pTokenBalanceParamsSchema,
+    params,
+    (message, cause, data) => new StakeError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { params: data }
+    })
+  ).asyncAndThen(
+    (validated) => import_neverthrow11.ResultAsync.fromPromise(
+      publicClient.readContract({
+        address: p2pTokenAddress,
+        abi: ABIS.EXTERNAL.USDC,
+        functionName: "balanceOf",
+        args: [validated.address]
+      }),
+      (error) => new StakeError("Failed to read P2P token balance", {
+        code: "CONTRACT_READ_ERROR",
+        cause: error,
+        context: { address: validated.address, p2pTokenAddress }
+      })
+    )
+  );
+}
+
+// src/contracts/reputation-manager/writes.ts
+var import_neverthrow12 = require("neverthrow");
+var import_viem14 = require("viem");
+
 // src/zkkyc/errors.ts
 var ZkkycError = class extends SdkError {
   constructor(message, options) {
@@ -5506,75 +5729,75 @@ var ZkkycError = class extends SdkError {
 };
 
 // src/zkkyc/validation.ts
-var import_zod8 = require("zod");
-var ZodAnonAadharProofParamsSchema = import_zod8.z.object({
-  nullifierSeed: import_zod8.z.bigint(),
-  nullifier: import_zod8.z.bigint(),
-  timestamp: import_zod8.z.bigint(),
-  signal: import_zod8.z.bigint(),
-  revealArray: import_zod8.z.tuple([import_zod8.z.bigint(), import_zod8.z.bigint(), import_zod8.z.bigint(), import_zod8.z.bigint()]),
-  packedGroth16Proof: import_zod8.z.tuple([
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint(),
-    import_zod8.z.bigint()
+var import_zod9 = require("zod");
+var ZodAnonAadharProofParamsSchema = import_zod9.z.object({
+  nullifierSeed: import_zod9.z.bigint(),
+  nullifier: import_zod9.z.bigint(),
+  timestamp: import_zod9.z.bigint(),
+  signal: import_zod9.z.bigint(),
+  revealArray: import_zod9.z.tuple([import_zod9.z.bigint(), import_zod9.z.bigint(), import_zod9.z.bigint(), import_zod9.z.bigint()]),
+  packedGroth16Proof: import_zod9.z.tuple([
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint(),
+    import_zod9.z.bigint()
   ])
 });
-var ZodSocialVerifyParamsSchema = import_zod8.z.object({
-  _socialName: import_zod8.z.string(),
-  proofs: import_zod8.z.array(
-    import_zod8.z.object({
-      claimInfo: import_zod8.z.object({
-        provider: import_zod8.z.string(),
-        parameters: import_zod8.z.string(),
-        context: import_zod8.z.string()
+var ZodSocialVerifyParamsSchema = import_zod9.z.object({
+  _socialName: import_zod9.z.string(),
+  proofs: import_zod9.z.array(
+    import_zod9.z.object({
+      claimInfo: import_zod9.z.object({
+        provider: import_zod9.z.string(),
+        parameters: import_zod9.z.string(),
+        context: import_zod9.z.string()
       }),
-      signedClaim: import_zod8.z.object({
-        claim: import_zod8.z.object({
-          identifier: import_zod8.z.string(),
+      signedClaim: import_zod9.z.object({
+        claim: import_zod9.z.object({
+          identifier: import_zod9.z.string(),
           owner: ZodAddressSchema,
-          timestampS: import_zod8.z.number(),
-          epoch: import_zod8.z.number()
+          timestampS: import_zod9.z.number(),
+          epoch: import_zod9.z.number()
         }),
-        signatures: import_zod8.z.array(import_zod8.z.string())
+        signatures: import_zod9.z.array(import_zod9.z.string())
       })
     })
   )
 });
-var ZodSolidityVerifierParametersSchema = import_zod8.z.object({
-  version: import_zod8.z.string().refine((val) => val.startsWith("0x"), {
+var ZodSolidityVerifierParametersSchema = import_zod9.z.object({
+  version: import_zod9.z.string().refine((val) => val.startsWith("0x"), {
     message: "Version must be a hex string"
   }),
-  proofVerificationData: import_zod8.z.object({
-    vkeyHash: import_zod8.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+  proofVerificationData: import_zod9.z.object({
+    vkeyHash: import_zod9.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
       message: "Invalid bytes32 hex string"
     }),
-    proof: import_zod8.z.string().refine((val) => val.startsWith("0x"), {
+    proof: import_zod9.z.string().refine((val) => val.startsWith("0x"), {
       message: "Proof must be a hex string"
     }),
-    publicInputs: import_zod8.z.array(
-      import_zod8.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+    publicInputs: import_zod9.z.array(
+      import_zod9.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
         message: "Each public input must be a valid bytes32 hex string"
       })
     )
   }),
-  committedInputs: import_zod8.z.string().refine((val) => val.startsWith("0x"), {
+  committedInputs: import_zod9.z.string().refine((val) => val.startsWith("0x"), {
     message: "Committed inputs must be a hex string"
   }),
-  serviceConfig: import_zod8.z.object({
-    validityPeriodInSeconds: import_zod8.z.number().int().nonnegative(),
-    domain: import_zod8.z.string(),
-    scope: import_zod8.z.string(),
-    devMode: import_zod8.z.boolean()
+  serviceConfig: import_zod9.z.object({
+    validityPeriodInSeconds: import_zod9.z.number().int().nonnegative(),
+    domain: import_zod9.z.string(),
+    scope: import_zod9.z.string(),
+    devMode: import_zod9.z.boolean()
   })
 });
-var ZodZkPassportRegisterParamsSchema = import_zod8.z.object({
+var ZodZkPassportRegisterParamsSchema = import_zod9.z.object({
   params: ZodSolidityVerifierParametersSchema,
-  isIDCard: import_zod8.z.boolean()
+  isIDCard: import_zod9.z.boolean()
 });
 
 // src/contracts/reputation-manager/writes.ts
@@ -5584,10 +5807,10 @@ function prepareSocialVerify(reputationManagerAddress, params) {
     params,
     (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
   ).andThen(
-    (validated) => import_neverthrow11.Result.fromThrowable(
+    (validated) => import_neverthrow12.Result.fromThrowable(
       () => ({
         to: reputationManagerAddress,
-        data: (0, import_viem13.encodeFunctionData)({
+        data: (0, import_viem14.encodeFunctionData)({
           abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
           functionName: "socialVerify",
           args: [
@@ -5619,10 +5842,10 @@ function prepareSubmitAnonAadharProof(reputationManagerAddress, params) {
     params,
     (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
   ).andThen(
-    (validated) => import_neverthrow11.Result.fromThrowable(
+    (validated) => import_neverthrow12.Result.fromThrowable(
       () => ({
         to: reputationManagerAddress,
-        data: (0, import_viem13.encodeFunctionData)({
+        data: (0, import_viem14.encodeFunctionData)({
           abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
           functionName: "submitAnonAadharProof",
           args: [
@@ -5648,7 +5871,7 @@ function prepareZkPassportRegister(reputationManagerAddress, params) {
     params,
     (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
   ).andThen(
-    (validated) => import_neverthrow11.Result.fromThrowable(
+    (validated) => import_neverthrow12.Result.fromThrowable(
       () => {
         const { proofVerificationData, serviceConfig, committedInputs, version } = validated.params;
         const proofVerificationParams = {
@@ -5668,7 +5891,7 @@ function prepareZkPassportRegister(reputationManagerAddress, params) {
         };
         return {
           to: reputationManagerAddress,
-          data: (0, import_viem13.encodeFunctionData)({
+          data: (0, import_viem14.encodeFunctionData)({
             abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
             functionName: "zkPassportRegister",
             args: [proofVerificationParams, validated.isIDCard]
@@ -5684,8 +5907,8 @@ function prepareZkPassportRegister(reputationManagerAddress, params) {
 }
 
 // src/contracts/tx-limits/index.ts
-var import_neverthrow12 = require("neverthrow");
-var import_viem14 = require("viem");
+var import_neverthrow13 = require("neverthrow");
+var import_viem15 = require("viem");
 
 // src/profile/errors.ts
 var ProfileError = class extends SdkError {
@@ -5696,18 +5919,18 @@ var ProfileError = class extends SdkError {
 };
 
 // src/profile/validation.ts
-var import_zod9 = require("zod");
-var ZodUsdcBalanceParamsSchema = import_zod9.z.object({
+var import_zod10 = require("zod");
+var ZodUsdcBalanceParamsSchema = import_zod10.z.object({
   address: ZodAddressSchema
 });
-var ZodUsdcAllowanceParamsSchema = import_zod9.z.object({
+var ZodUsdcAllowanceParamsSchema = import_zod10.z.object({
   owner: ZodAddressSchema
 });
-var ZodGetBalancesParamsSchema = import_zod9.z.object({
+var ZodGetBalancesParamsSchema = import_zod10.z.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
-var ZodTxLimitsParamsSchema = import_zod9.z.object({
+var ZodTxLimitsParamsSchema = import_zod10.z.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
@@ -5723,12 +5946,12 @@ function getTxLimits(publicClient, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow12.ResultAsync.fromPromise(
+    (validated) => import_neverthrow13.ResultAsync.fromPromise(
       publicClient.readContract({
         address: diamondAddress,
         abi: ABIS.FACETS.ORDER_FLOW,
         functionName: "userTxLimit",
-        args: [validated.address, (0, import_viem14.stringToHex)(validated.currency, { size: 32 })]
+        args: [validated.address, (0, import_viem15.stringToHex)(validated.currency, { size: 32 })]
       }),
       (error) => new ProfileError("Failed to read tx limits", {
         code: "CONTRACT_READ_ERROR",
@@ -5736,15 +5959,15 @@ function getTxLimits(publicClient, diamondAddress, params) {
         context: { address: validated.address, currency: validated.currency, diamondAddress }
       })
     ).map(([buyLimit, sellLimit]) => ({
-      buyLimit: Number((0, import_viem14.formatUnits)(buyLimit, 6)),
-      sellLimit: Number((0, import_viem14.formatUnits)(sellLimit, 6))
+      buyLimit: Number((0, import_viem15.formatUnits)(buyLimit, 6)),
+      sellLimit: Number((0, import_viem15.formatUnits)(sellLimit, 6))
     }))
   );
 }
 
 // src/contracts/usdc/index.ts
-var import_neverthrow13 = require("neverthrow");
-var import_viem15 = require("viem");
+var import_neverthrow14 = require("neverthrow");
+var import_viem16 = require("viem");
 function getUsdcBalance(publicClient, usdcAddress, params) {
   return validate(
     ZodUsdcBalanceParamsSchema,
@@ -5755,7 +5978,7 @@ function getUsdcBalance(publicClient, usdcAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow13.ResultAsync.fromPromise(
+    (validated) => import_neverthrow14.ResultAsync.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
         abi: ABIS.EXTERNAL.USDC,
@@ -5780,10 +6003,10 @@ function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow13.ResultAsync.fromPromise(
+    (validated) => import_neverthrow14.ResultAsync.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
-        abi: import_viem15.erc20Abi,
+        abi: import_viem16.erc20Abi,
         functionName: "allowance",
         args: [validated.owner, diamondAddress]
       }),
@@ -5797,7 +6020,7 @@ function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
 }
 
 // src/orders/internal/routing/routing.ts
-var import_neverthrow14 = require("neverthrow");
+var import_neverthrow15 = require("neverthrow");
 var EPSILON = 0.25;
 var RECOVERY_SCALE = 0.3;
 var BOOTSTRAP_MAX_WEIGHT = 25;
@@ -5864,7 +6087,7 @@ function selectCircleForOrderAsync(circles, orderCurrency, validateCircle, logge
         attemptsLeft,
         remainingCircles: remaining.length
       });
-      return (0, import_neverthrow14.errAsync)(
+      return (0, import_neverthrow15.errAsync)(
         new OrderRoutingError("No eligible circles found", {
           code: "NO_ELIGIBLE_CIRCLES"
         })
@@ -5872,7 +6095,7 @@ function selectCircleForOrderAsync(circles, orderCurrency, validateCircle, logge
     }
     const selected = selectCircle(remaining);
     if (!selected) {
-      return (0, import_neverthrow14.errAsync)(
+      return (0, import_neverthrow15.errAsync)(
         new OrderRoutingError("No eligible circles found", {
           code: "NO_ELIGIBLE_CIRCLES"
         })
@@ -5890,11 +6113,11 @@ function selectCircleForOrderAsync(circles, orderCurrency, validateCircle, logge
         circleId: String(circleId),
         error: String(error)
       });
-      return (0, import_neverthrow14.okAsync)(false);
+      return (0, import_neverthrow15.okAsync)(false);
     }).andThen((isValid) => {
       if (isValid) {
         logger.info("circle validated successfully", { circleId: String(circleId) });
-        return (0, import_neverthrow14.okAsync)(circleId);
+        return (0, import_neverthrow15.okAsync)(circleId);
       }
       logger.debug("circle failed validation, retrying", {
         circleId: String(circleId),
@@ -5972,7 +6195,7 @@ function createOrderRouter(config) {
   const logger = config.logger ?? noopLogger;
   return {
     selectCircle(params) {
-      const currencyHex = (0, import_viem16.stringToHex)(params.currency, { size: 32 });
+      const currencyHex = (0, import_viem17.stringToHex)(params.currency, { size: 32 });
       logger.info("selectCircle started", {
         currency: params.currency,
         user: params.user,
@@ -6004,8 +6227,8 @@ function createOrderRouter(config) {
 }
 
 // src/orders/normalize.ts
-var import_neverthrow15 = require("neverthrow");
-var import_viem17 = require("viem");
+var import_neverthrow16 = require("neverthrow");
+var import_viem18 = require("viem");
 var ORDER_TYPE_MAP = {
   [ORDER_TYPE.BUY]: "buy",
   [ORDER_TYPE.SELL]: "sell",
@@ -6031,23 +6254,23 @@ function malformed(field, value, context) {
 }
 function mapOrderType(v, ctx) {
   const t = ORDER_TYPE_MAP[v];
-  return t ? (0, import_neverthrow15.ok)(t) : (0, import_neverthrow15.err)(malformed("orderType", v, ctx));
+  return t ? (0, import_neverthrow16.ok)(t) : (0, import_neverthrow16.err)(malformed("orderType", v, ctx));
 }
 function mapOrderStatus(v, ctx) {
   const s = ORDER_STATUS_MAP[v];
-  return s ? (0, import_neverthrow15.ok)(s) : (0, import_neverthrow15.err)(malformed("status", v, ctx));
+  return s ? (0, import_neverthrow16.ok)(s) : (0, import_neverthrow16.err)(malformed("status", v, ctx));
 }
 function mapDisputeStatus(v, ctx) {
   const s = DISPUTE_STATUS_MAP[v];
-  return s ? (0, import_neverthrow15.ok)(s) : (0, import_neverthrow15.err)(malformed("disputeStatus", v, ctx));
+  return s ? (0, import_neverthrow16.ok)(s) : (0, import_neverthrow16.err)(malformed("disputeStatus", v, ctx));
 }
 function decodeCurrency(hex) {
-  return (0, import_viem17.hexToString)(hex, { size: 32 }).replaceAll("\0", "");
+  return (0, import_viem18.hexToString)(hex, { size: 32 }).replaceAll("\0", "");
 }
 function normalizeContractOrder(raw, details) {
-  if (raw.id === 0n && (0, import_viem17.isAddressEqual)(raw.user, import_viem17.zeroAddress)) return (0, import_neverthrow15.ok)(null);
+  if (raw.id === 0n && (0, import_viem18.isAddressEqual)(raw.user, import_viem18.zeroAddress)) return (0, import_neverthrow16.ok)(null);
   const ctx = { orderId: raw.id.toString() };
-  return import_neverthrow15.Result.combine([
+  return import_neverthrow16.Result.combine([
     mapOrderType(raw.orderType, ctx),
     mapOrderStatus(raw.status, ctx),
     mapDisputeStatus(raw.disputeInfo.status, ctx)
@@ -6078,7 +6301,7 @@ function normalizeContractOrder(raw, details) {
 }
 function normalizeSubgraphOrder(raw) {
   const ctx = { orderId: raw.orderId };
-  return import_neverthrow15.Result.combine([
+  return import_neverthrow16.Result.combine([
     mapOrderType(raw.type, ctx),
     mapOrderStatus(raw.status, ctx),
     mapDisputeStatus(raw.disputeStatus, ctx)
@@ -6111,7 +6334,7 @@ function normalizeSubgraphOrder(raw) {
 }
 
 // src/orders/subgraph/index.ts
-var import_neverthrow16 = require("neverthrow");
+var import_neverthrow17 = require("neverthrow");
 
 // src/orders/subgraph/queries.ts
 var ORDERS_BY_USER_QUERY = (
@@ -6172,7 +6395,7 @@ function getOrdersForUser(subgraphUrl, userAddress, skip, limit, logger = noopLo
         context: { data: d }
       })
     ).andThen(
-      (validated) => import_neverthrow16.Result.combine(validated.orders_collection.map(normalizeSubgraphOrder))
+      (validated) => import_neverthrow17.Result.combine(validated.orders_collection.map(normalizeSubgraphOrder))
     )
   );
 }
@@ -6326,7 +6549,7 @@ function createOrders(config) {
       ).andThen(
         ({ order, details }) => normalizeContractOrder(order, details).asyncAndThen((normalized) => {
           if (!normalized) {
-            return (0, import_neverthrow17.errAsync)(
+            return (0, import_neverthrow18.errAsync)(
               new OrdersError("Order not found", {
                 code: "ORDER_NOT_FOUND",
                 context: { orderId: params.orderId.toString() }
@@ -6334,7 +6557,7 @@ function createOrders(config) {
             );
           }
           logger.debug("getOrder resolved", { orderId: params.orderId.toString() });
-          return (0, import_neverthrow17.okAsync)(normalized);
+          return (0, import_neverthrow18.okAsync)(normalized);
         })
       );
     },
@@ -6420,8 +6643,8 @@ function createPrices(config) {
 }
 
 // src/profile/contracts/actions.ts
-var import_neverthrow18 = require("neverthrow");
-var import_viem18 = require("viem");
+var import_neverthrow19 = require("neverthrow");
+var import_viem19 = require("viem");
 function getBalances(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
     ZodGetBalancesParamsSchema,
@@ -6432,7 +6655,7 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow18.ResultAsync.combine([
+    (validated) => import_neverthrow19.ResultAsync.combine([
       getUsdcBalance(publicClient, usdcAddress, {
         address: validated.address
       }),
@@ -6446,8 +6669,8 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
         })
       )
     ]).map(([usdc, priceConfig]) => {
-      const usdcFormatted = Number((0, import_viem18.formatUnits)(usdc, 6));
-      const sellPriceFormatted = Number((0, import_viem18.formatUnits)(priceConfig.sellPrice, 6));
+      const usdcFormatted = Number((0, import_viem19.formatUnits)(usdc, 6));
+      const sellPriceFormatted = Number((0, import_viem19.formatUnits)(priceConfig.sellPrice, 6));
       return {
         usdc: usdcFormatted,
         fiat: usdcFormatted * sellPriceFormatted,
@@ -6468,6 +6691,252 @@ function createProfile(config) {
   };
 }
 
+// src/stake/actions/cancel-unstake.ts
+var import_neverthrow21 = require("neverthrow");
+var import_viem20 = require("viem");
+
+// src/stake/tx.ts
+var import_neverthrow20 = require("neverthrow");
+function submitPreparedTx2(input) {
+  const { prepared, walletClient, publicClient, waitForReceipt } = input;
+  const account = walletClient.account;
+  if (!account) {
+    return (0, import_neverthrow20.errAsync)(
+      new StakeError("WalletClient is missing an account", {
+        code: "TX_SUBMISSION_FAILED"
+      })
+    );
+  }
+  const chain = walletClient.chain;
+  return import_neverthrow20.ResultAsync.fromPromise(
+    walletClient.sendTransaction({
+      account,
+      chain,
+      to: prepared.to,
+      data: prepared.data,
+      value: prepared.value
+    }),
+    (cause) => new StakeError("walletClient.sendTransaction rejected", {
+      code: "TX_SUBMISSION_FAILED",
+      cause
+    })
+  ).andThen((hash) => {
+    if (!waitForReceipt) {
+      return (0, import_neverthrow20.okAsync)({ hash });
+    }
+    return import_neverthrow20.ResultAsync.fromPromise(
+      publicClient.waitForTransactionReceipt({ hash }),
+      (cause) => new StakeError("waitForTransactionReceipt failed", {
+        code: "RECEIPT_TIMEOUT",
+        cause
+      })
+    ).andThen((receipt) => {
+      if (receipt.status !== "success") {
+        return (0, import_neverthrow20.errAsync)(
+          new StakeError("Transaction reverted", {
+            code: "TX_REVERTED",
+            context: { hash, blockNumber: receipt.blockNumber.toString() }
+          })
+        );
+      }
+      return (0, import_neverthrow20.okAsync)({ hash, receipt });
+    });
+  });
+}
+
+// src/stake/actions/cancel-unstake.ts
+function createCancelUnstakeAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = () => (0, import_neverthrow21.okAsync)({
+    to: diamondAddress,
+    data: (0, import_viem20.encodeFunctionData)({
+      abi: ABIS.FACETS.STAKE,
+      functionName: "p2pBoostCancelUnstake",
+      args: []
+    }),
+    value: 0n
+  });
+  return {
+    prepare() {
+      return prepareFn();
+    },
+    execute({ walletClient, waitForReceipt }) {
+      return prepareFn().andThen(
+        (prepared) => submitPreparedTx2({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/stake/actions/claim-unstake.ts
+var import_neverthrow22 = require("neverthrow");
+var import_viem21 = require("viem");
+function createClaimUnstakeAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = () => (0, import_neverthrow22.okAsync)({
+    to: diamondAddress,
+    data: (0, import_viem21.encodeFunctionData)({
+      abi: ABIS.FACETS.STAKE,
+      functionName: "p2pBoostClaimUnstake",
+      args: []
+    }),
+    value: 0n
+  });
+  return {
+    prepare() {
+      return prepareFn();
+    },
+    execute({ walletClient, waitForReceipt }) {
+      return prepareFn().andThen(
+        (prepared) => submitPreparedTx2({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/stake/actions/request-unstake.ts
+var import_neverthrow23 = require("neverthrow");
+var import_viem22 = require("viem");
+function createRequestUnstakeAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = () => (0, import_neverthrow23.okAsync)({
+    to: diamondAddress,
+    data: (0, import_viem22.encodeFunctionData)({
+      abi: ABIS.FACETS.STAKE,
+      functionName: "p2pBoostRequestUnstake",
+      args: []
+    }),
+    value: 0n
+  });
+  return {
+    prepare() {
+      return prepareFn();
+    },
+    execute({ walletClient, waitForReceipt }) {
+      return prepareFn().andThen(
+        (prepared) => submitPreparedTx2({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/stake/actions/stake.ts
+var import_viem23 = require("viem");
+function createStakeAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodStakeParamsSchema,
+    params,
+    (message, cause, data) => new StakeError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).map(({ tokens }) => ({
+    to: diamondAddress,
+    data: (0, import_viem23.encodeFunctionData)({
+      abi: ABIS.FACETS.STAKE,
+      functionName: "p2pBoostStake",
+      args: [tokens]
+    }),
+    value: 0n
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params).asyncMap(async (tx) => tx);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).asyncAndThen(
+        (prepared) => submitPreparedTx2({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/stake/actions/top-up.ts
+var import_viem24 = require("viem");
+function createTopUpAction(input) {
+  const { publicClient, diamondAddress } = input;
+  const prepareFn = (params) => validate(
+    ZodTopUpParamsSchema,
+    params,
+    (message, cause, data) => new StakeError(message, {
+      code: "VALIDATION_ERROR",
+      cause,
+      context: { data }
+    })
+  ).map(({ tokens }) => ({
+    to: diamondAddress,
+    data: (0, import_viem24.encodeFunctionData)({
+      abi: ABIS.FACETS.STAKE,
+      functionName: "p2pBoostTopUp",
+      args: [tokens]
+    }),
+    value: 0n
+  }));
+  return {
+    prepare(params) {
+      return prepareFn(params).asyncMap(async (tx) => tx);
+    },
+    execute({ walletClient, waitForReceipt, ...params }) {
+      return prepareFn(params).asyncAndThen(
+        (prepared) => submitPreparedTx2({ prepared, walletClient, publicClient, waitForReceipt })
+      );
+    }
+  };
+}
+
+// src/stake/normalize.ts
+var STATUS_MAP = {
+  0: "none",
+  1: "active",
+  2: "cooldown",
+  3: "seized"
+};
+function normalizeUserStake(raw) {
+  return {
+    stakedAmount: raw.stakedAmount,
+    cooldownEnd: raw.cooldownEnd,
+    status: STATUS_MAP[raw.status] ?? "none"
+  };
+}
+function normalizeStakeBoostGlobals(raw) {
+  const [
+    p2pToken,
+    fraudReserve,
+    maxStakeTokens,
+    normalCooldown,
+    blacklistCooldown,
+    tokenDecimals,
+    totalStaked
+  ] = raw;
+  return {
+    p2pToken,
+    fraudReserve,
+    maxStakeTokens,
+    normalCooldown,
+    blacklistCooldown,
+    tokenDecimals,
+    totalStaked
+  };
+}
+
+// src/stake/client.ts
+function createStake(config) {
+  const { publicClient, diamondAddress, p2pTokenAddress } = config;
+  return {
+    getUserStake: (params) => getUserStake(publicClient, diamondAddress, params).map(normalizeUserStake),
+    getStakeBoostConfig: (params) => getStakeBoostConfig(publicClient, diamondAddress, params),
+    getStakeBoostGlobals: () => getStakeBoostGlobals(publicClient, diamondAddress).map(normalizeStakeBoostGlobals),
+    getP2pTokenBalance: (params) => getP2pTokenBalance(publicClient, p2pTokenAddress, params),
+    stake: createStakeAction({ publicClient, diamondAddress }),
+    topUp: createTopUpAction({ publicClient, diamondAddress }),
+    requestUnstake: createRequestUnstakeAction({ publicClient, diamondAddress }),
+    cancelUnstake: createCancelUnstakeAction({ publicClient, diamondAddress }),
+    claimUnstake: createClaimUnstakeAction({ publicClient, diamondAddress })
+  };
+}
+
 // src/zkkyc/client.ts
 function createZkkyc(config) {
   const { reputationManagerAddress } = config;
@@ -6527,6 +6996,11 @@ function SdkProvider({ children, ...config }) {
         relayIdentity,
         logger
       }),
+      stake: createStake({
+        publicClient,
+        diamondAddress: config.diamondAddress,
+        p2pTokenAddress: config.p2pTokenAddress
+      }),
       zkkyc: config.reputationManagerAddress ? createZkkyc({
         reputationManagerAddress: config.reputationManagerAddress
       }) : void 0,
@@ -6537,6 +7011,7 @@ function SdkProvider({ children, ...config }) {
     config.subgraphUrl,
     config.diamondAddress,
     config.usdcAddress,
+    config.p2pTokenAddress,
     config.reputationManagerAddress,
     relayIdentityStore,
     relayIdentity,
@@ -6561,6 +7036,9 @@ function usePrices() {
 function useOrders() {
   return useSdk().orders;
 }
+function useStake() {
+  return useSdk().stake;
+}
 function useZkkyc() {
   const zkkyc = useSdk().zkkyc;
   if (!zkkyc) {
@@ -6637,6 +7115,7 @@ function useFingerprint(enabled) {
   usePrices,
   useProfile,
   useSdk,
+  useStake,
   useWatchOrders,
   useZkkyc
 });