@p2pdotme/sdk 1.1.8 → 1.2.0

package/dist/profile.mjs

@@ -478,6 +478,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 = [
   {
@@ -684,14 +782,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: erc20Abi,
@@ -1259,85 +1359,107 @@ function getPriceConfig(publicClient, diamondAddress, params) {
   );
 }
 
+// src/contracts/p2p-stake/index.ts
+import { ResultAsync as ResultAsync5 } from "neverthrow";
+import { stringToHex as stringToHex3 } from "viem";
+
+// src/stake/validation.ts
+import { z as z4 } from "zod";
+var ZodGetUserStakeParamsSchema = z4.object({
+  user: ZodAddressSchema
+});
+var ZodGetStakeBoostConfigParamsSchema = z4.object({
+  currency: ZodCurrencySchema
+});
+var ZodGetP2pTokenBalanceParamsSchema = z4.object({
+  address: ZodAddressSchema
+});
+var ZodStakeParamsSchema = z4.object({
+  tokens: z4.bigint().positive()
+});
+var ZodTopUpParamsSchema = z4.object({
+  tokens: z4.bigint().positive()
+});
+
 // src/contracts/reputation-manager/writes.ts
 import { Result } from "neverthrow";
 import { encodeFunctionData } from "viem";
 
 // src/zkkyc/validation.ts
-import { z as z4 } from "zod";
-var ZodAnonAadharProofParamsSchema = z4.object({
-  nullifierSeed: z4.bigint(),
-  nullifier: z4.bigint(),
-  timestamp: z4.bigint(),
-  signal: z4.bigint(),
-  revealArray: z4.tuple([z4.bigint(), z4.bigint(), z4.bigint(), z4.bigint()]),
-  packedGroth16Proof: z4.tuple([
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint(),
-    z4.bigint()
+import { z as z5 } from "zod";
+var ZodAnonAadharProofParamsSchema = z5.object({
+  nullifierSeed: z5.bigint(),
+  nullifier: z5.bigint(),
+  timestamp: z5.bigint(),
+  signal: z5.bigint(),
+  revealArray: z5.tuple([z5.bigint(), z5.bigint(), z5.bigint(), z5.bigint()]),
+  packedGroth16Proof: z5.tuple([
+    z5.bigint(),
+    z5.bigint(),
+    z5.bigint(),
+    z5.bigint(),
+    z5.bigint(),
+    z5.bigint(),
+    z5.bigint(),
+    z5.bigint()
   ])
 });
-var ZodSocialVerifyParamsSchema = z4.object({
-  _socialName: z4.string(),
-  proofs: z4.array(
-    z4.object({
-      claimInfo: z4.object({
-        provider: z4.string(),
-        parameters: z4.string(),
-        context: z4.string()
+var ZodSocialVerifyParamsSchema = z5.object({
+  _socialName: z5.string(),
+  proofs: z5.array(
+    z5.object({
+      claimInfo: z5.object({
+        provider: z5.string(),
+        parameters: z5.string(),
+        context: z5.string()
       }),
-      signedClaim: z4.object({
-        claim: z4.object({
-          identifier: z4.string(),
+      signedClaim: z5.object({
+        claim: z5.object({
+          identifier: z5.string(),
           owner: ZodAddressSchema,
-          timestampS: z4.number(),
-          epoch: z4.number()
+          timestampS: z5.number(),
+          epoch: z5.number()
         }),
-        signatures: z4.array(z4.string())
+        signatures: z5.array(z5.string())
       })
     })
   )
 });
-var ZodSolidityVerifierParametersSchema = z4.object({
-  version: z4.string().refine((val) => val.startsWith("0x"), {
+var ZodSolidityVerifierParametersSchema = z5.object({
+  version: z5.string().refine((val) => val.startsWith("0x"), {
     message: "Version must be a hex string"
   }),
-  proofVerificationData: z4.object({
-    vkeyHash: z4.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+  proofVerificationData: z5.object({
+    vkeyHash: z5.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
       message: "Invalid bytes32 hex string"
     }),
-    proof: z4.string().refine((val) => val.startsWith("0x"), {
+    proof: z5.string().refine((val) => val.startsWith("0x"), {
       message: "Proof must be a hex string"
     }),
-    publicInputs: z4.array(
-      z4.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+    publicInputs: z5.array(
+      z5.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
         message: "Each public input must be a valid bytes32 hex string"
       })
     )
   }),
-  committedInputs: z4.string().refine((val) => val.startsWith("0x"), {
+  committedInputs: z5.string().refine((val) => val.startsWith("0x"), {
     message: "Committed inputs must be a hex string"
   }),
-  serviceConfig: z4.object({
-    validityPeriodInSeconds: z4.number().int().nonnegative(),
-    domain: z4.string(),
-    scope: z4.string(),
-    devMode: z4.boolean()
+  serviceConfig: z5.object({
+    validityPeriodInSeconds: z5.number().int().nonnegative(),
+    domain: z5.string(),
+    scope: z5.string(),
+    devMode: z5.boolean()
   })
 });
-var ZodZkPassportRegisterParamsSchema = z4.object({
+var ZodZkPassportRegisterParamsSchema = z5.object({
   params: ZodSolidityVerifierParametersSchema,
-  isIDCard: z4.boolean()
+  isIDCard: z5.boolean()
 });
 
 // src/contracts/tx-limits/index.ts
-import { ResultAsync as ResultAsync5 } from "neverthrow";
-import { formatUnits, stringToHex as stringToHex3 } from "viem";
+import { ResultAsync as ResultAsync6 } from "neverthrow";
+import { formatUnits, stringToHex as stringToHex4 } from "viem";
 
 // src/profile/errors.ts
 var ProfileError = class extends SdkError {
@@ -1348,18 +1470,18 @@ var ProfileError = class extends SdkError {
 };
 
 // src/profile/validation.ts
-import { z as z5 } from "zod";
-var ZodUsdcBalanceParamsSchema = z5.object({
+import { z as z6 } from "zod";
+var ZodUsdcBalanceParamsSchema = z6.object({
   address: ZodAddressSchema
 });
-var ZodUsdcAllowanceParamsSchema = z5.object({
+var ZodUsdcAllowanceParamsSchema = z6.object({
   owner: ZodAddressSchema
 });
-var ZodGetBalancesParamsSchema = z5.object({
+var ZodGetBalancesParamsSchema = z6.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
-var ZodTxLimitsParamsSchema = z5.object({
+var ZodTxLimitsParamsSchema = z6.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
@@ -1375,12 +1497,12 @@ function getTxLimits(publicClient, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync5.fromPromise(
+    (validated) => ResultAsync6.fromPromise(
       publicClient.readContract({
         address: diamondAddress,
         abi: ABIS.FACETS.ORDER_FLOW,
         functionName: "userTxLimit",
-        args: [validated.address, stringToHex3(validated.currency, { size: 32 })]
+        args: [validated.address, stringToHex4(validated.currency, { size: 32 })]
       }),
       (error) => new ProfileError("Failed to read tx limits", {
         code: "CONTRACT_READ_ERROR",
@@ -1395,7 +1517,7 @@ function getTxLimits(publicClient, diamondAddress, params) {
 }
 
 // src/contracts/usdc/index.ts
-import { ResultAsync as ResultAsync6 } from "neverthrow";
+import { ResultAsync as ResultAsync7 } from "neverthrow";
 import { erc20Abi as erc20Abi2 } from "viem";
 function getUsdcBalance(publicClient, usdcAddress, params) {
   return validate(
@@ -1407,7 +1529,7 @@ function getUsdcBalance(publicClient, usdcAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync6.fromPromise(
+    (validated) => ResultAsync7.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
         abi: ABIS.EXTERNAL.USDC,
@@ -1432,7 +1554,7 @@ function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync6.fromPromise(
+    (validated) => ResultAsync7.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
         abi: erc20Abi2,
@@ -1449,7 +1571,7 @@ function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
 }
 
 // src/profile/contracts/actions.ts
-import { ResultAsync as ResultAsync7 } from "neverthrow";
+import { ResultAsync as ResultAsync8 } from "neverthrow";
 import { formatUnits as formatUnits2 } from "viem";
 function getBalances(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
@@ -1461,7 +1583,7 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => ResultAsync7.combine([
+    (validated) => ResultAsync8.combine([
       getUsdcBalance(publicClient, usdcAddress, {
         address: validated.address
       }),