@p2pdotme/sdk 1.1.7 → 1.1.9

package/dist/profile.cjs

@@ -505,6 +505,97 @@ 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: [{ 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 = [
   {
@@ -711,14 +802,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_viem.erc20Abi,
@@ -1286,85 +1379,107 @@ function getPriceConfig(publicClient, diamondAddress, params) {
   );
 }
 
-// src/contracts/reputation-manager/writes.ts
+// src/contracts/p2p-stake/index.ts
 var import_neverthrow6 = require("neverthrow");
 var import_viem5 = require("viem");
 
-// src/zkkyc/validation.ts
+// src/stake/validation.ts
 var import_zod4 = require("zod");
-var ZodAnonAadharProofParamsSchema = import_zod4.z.object({
-  nullifierSeed: import_zod4.z.bigint(),
-  nullifier: import_zod4.z.bigint(),
-  timestamp: import_zod4.z.bigint(),
-  signal: import_zod4.z.bigint(),
-  revealArray: import_zod4.z.tuple([import_zod4.z.bigint(), import_zod4.z.bigint(), import_zod4.z.bigint(), import_zod4.z.bigint()]),
-  packedGroth16Proof: import_zod4.z.tuple([
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint(),
-    import_zod4.z.bigint()
+var ZodGetUserStakeParamsSchema = import_zod4.z.object({
+  user: ZodAddressSchema
+});
+var ZodGetStakeBoostConfigParamsSchema = import_zod4.z.object({
+  currency: ZodCurrencySchema
+});
+var ZodGetP2pTokenBalanceParamsSchema = import_zod4.z.object({
+  address: ZodAddressSchema
+});
+var ZodStakeParamsSchema = import_zod4.z.object({
+  tokens: import_zod4.z.bigint().positive()
+});
+var ZodTopUpParamsSchema = import_zod4.z.object({
+  tokens: import_zod4.z.bigint().positive()
+});
+
+// src/contracts/reputation-manager/writes.ts
+var import_neverthrow7 = require("neverthrow");
+var import_viem6 = require("viem");
+
+// src/zkkyc/validation.ts
+var import_zod5 = require("zod");
+var ZodAnonAadharProofParamsSchema = import_zod5.z.object({
+  nullifierSeed: import_zod5.z.bigint(),
+  nullifier: import_zod5.z.bigint(),
+  timestamp: import_zod5.z.bigint(),
+  signal: import_zod5.z.bigint(),
+  revealArray: import_zod5.z.tuple([import_zod5.z.bigint(), import_zod5.z.bigint(), import_zod5.z.bigint(), import_zod5.z.bigint()]),
+  packedGroth16Proof: import_zod5.z.tuple([
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint(),
+    import_zod5.z.bigint()
   ])
 });
-var ZodSocialVerifyParamsSchema = import_zod4.z.object({
-  _socialName: import_zod4.z.string(),
-  proofs: import_zod4.z.array(
-    import_zod4.z.object({
-      claimInfo: import_zod4.z.object({
-        provider: import_zod4.z.string(),
-        parameters: import_zod4.z.string(),
-        context: import_zod4.z.string()
+var ZodSocialVerifyParamsSchema = import_zod5.z.object({
+  _socialName: import_zod5.z.string(),
+  proofs: import_zod5.z.array(
+    import_zod5.z.object({
+      claimInfo: import_zod5.z.object({
+        provider: import_zod5.z.string(),
+        parameters: import_zod5.z.string(),
+        context: import_zod5.z.string()
       }),
-      signedClaim: import_zod4.z.object({
-        claim: import_zod4.z.object({
-          identifier: import_zod4.z.string(),
+      signedClaim: import_zod5.z.object({
+        claim: import_zod5.z.object({
+          identifier: import_zod5.z.string(),
           owner: ZodAddressSchema,
-          timestampS: import_zod4.z.number(),
-          epoch: import_zod4.z.number()
+          timestampS: import_zod5.z.number(),
+          epoch: import_zod5.z.number()
         }),
-        signatures: import_zod4.z.array(import_zod4.z.string())
+        signatures: import_zod5.z.array(import_zod5.z.string())
       })
     })
   )
 });
-var ZodSolidityVerifierParametersSchema = import_zod4.z.object({
-  version: import_zod4.z.string().refine((val) => val.startsWith("0x"), {
+var ZodSolidityVerifierParametersSchema = import_zod5.z.object({
+  version: import_zod5.z.string().refine((val) => val.startsWith("0x"), {
     message: "Version must be a hex string"
   }),
-  proofVerificationData: import_zod4.z.object({
-    vkeyHash: import_zod4.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+  proofVerificationData: import_zod5.z.object({
+    vkeyHash: import_zod5.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
       message: "Invalid bytes32 hex string"
     }),
-    proof: import_zod4.z.string().refine((val) => val.startsWith("0x"), {
+    proof: import_zod5.z.string().refine((val) => val.startsWith("0x"), {
       message: "Proof must be a hex string"
     }),
-    publicInputs: import_zod4.z.array(
-      import_zod4.z.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+    publicInputs: import_zod5.z.array(
+      import_zod5.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_zod4.z.string().refine((val) => val.startsWith("0x"), {
+  committedInputs: import_zod5.z.string().refine((val) => val.startsWith("0x"), {
     message: "Committed inputs must be a hex string"
   }),
-  serviceConfig: import_zod4.z.object({
-    validityPeriodInSeconds: import_zod4.z.number().int().nonnegative(),
-    domain: import_zod4.z.string(),
-    scope: import_zod4.z.string(),
-    devMode: import_zod4.z.boolean()
+  serviceConfig: import_zod5.z.object({
+    validityPeriodInSeconds: import_zod5.z.number().int().nonnegative(),
+    domain: import_zod5.z.string(),
+    scope: import_zod5.z.string(),
+    devMode: import_zod5.z.boolean()
   })
 });
-var ZodZkPassportRegisterParamsSchema = import_zod4.z.object({
+var ZodZkPassportRegisterParamsSchema = import_zod5.z.object({
   params: ZodSolidityVerifierParametersSchema,
-  isIDCard: import_zod4.z.boolean()
+  isIDCard: import_zod5.z.boolean()
 });
 
 // src/contracts/tx-limits/index.ts
-var import_neverthrow7 = require("neverthrow");
-var import_viem6 = require("viem");
+var import_neverthrow8 = require("neverthrow");
+var import_viem7 = require("viem");
 
 // src/profile/errors.ts
 var ProfileError = class extends SdkError {
@@ -1375,18 +1490,18 @@ var ProfileError = class extends SdkError {
 };
 
 // src/profile/validation.ts
-var import_zod5 = require("zod");
-var ZodUsdcBalanceParamsSchema = import_zod5.z.object({
+var import_zod6 = require("zod");
+var ZodUsdcBalanceParamsSchema = import_zod6.z.object({
   address: ZodAddressSchema
 });
-var ZodUsdcAllowanceParamsSchema = import_zod5.z.object({
+var ZodUsdcAllowanceParamsSchema = import_zod6.z.object({
   owner: ZodAddressSchema
 });
-var ZodGetBalancesParamsSchema = import_zod5.z.object({
+var ZodGetBalancesParamsSchema = import_zod6.z.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
-var ZodTxLimitsParamsSchema = import_zod5.z.object({
+var ZodTxLimitsParamsSchema = import_zod6.z.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
@@ -1402,12 +1517,12 @@ function getTxLimits(publicClient, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow7.ResultAsync.fromPromise(
+    (validated) => import_neverthrow8.ResultAsync.fromPromise(
       publicClient.readContract({
         address: diamondAddress,
         abi: ABIS.FACETS.ORDER_FLOW,
         functionName: "userTxLimit",
-        args: [validated.address, (0, import_viem6.stringToHex)(validated.currency, { size: 32 })]
+        args: [validated.address, (0, import_viem7.stringToHex)(validated.currency, { size: 32 })]
       }),
       (error) => new ProfileError("Failed to read tx limits", {
         code: "CONTRACT_READ_ERROR",
@@ -1415,15 +1530,15 @@ function getTxLimits(publicClient, diamondAddress, params) {
         context: { address: validated.address, currency: validated.currency, diamondAddress }
       })
     ).map(([buyLimit, sellLimit]) => ({
-      buyLimit: Number((0, import_viem6.formatUnits)(buyLimit, 6)),
-      sellLimit: Number((0, import_viem6.formatUnits)(sellLimit, 6))
+      buyLimit: Number((0, import_viem7.formatUnits)(buyLimit, 6)),
+      sellLimit: Number((0, import_viem7.formatUnits)(sellLimit, 6))
     }))
   );
 }
 
 // src/contracts/usdc/index.ts
-var import_neverthrow8 = require("neverthrow");
-var import_viem7 = require("viem");
+var import_neverthrow9 = require("neverthrow");
+var import_viem8 = require("viem");
 function getUsdcBalance(publicClient, usdcAddress, params) {
   return validate(
     ZodUsdcBalanceParamsSchema,
@@ -1434,7 +1549,7 @@ function getUsdcBalance(publicClient, usdcAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow8.ResultAsync.fromPromise(
+    (validated) => import_neverthrow9.ResultAsync.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
         abi: ABIS.EXTERNAL.USDC,
@@ -1459,10 +1574,10 @@ function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow8.ResultAsync.fromPromise(
+    (validated) => import_neverthrow9.ResultAsync.fromPromise(
       publicClient.readContract({
         address: usdcAddress,
-        abi: import_viem7.erc20Abi,
+        abi: import_viem8.erc20Abi,
         functionName: "allowance",
         args: [validated.owner, diamondAddress]
       }),
@@ -1476,8 +1591,8 @@ function getUsdcAllowance(publicClient, usdcAddress, diamondAddress, params) {
 }
 
 // src/profile/contracts/actions.ts
-var import_neverthrow9 = require("neverthrow");
-var import_viem8 = require("viem");
+var import_neverthrow10 = require("neverthrow");
+var import_viem9 = require("viem");
 function getBalances(publicClient, usdcAddress, diamondAddress, params) {
   return validate(
     ZodGetBalancesParamsSchema,
@@ -1488,7 +1603,7 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
       context: { params: data }
     })
   ).asyncAndThen(
-    (validated) => import_neverthrow9.ResultAsync.combine([
+    (validated) => import_neverthrow10.ResultAsync.combine([
       getUsdcBalance(publicClient, usdcAddress, {
         address: validated.address
       }),
@@ -1502,8 +1617,8 @@ function getBalances(publicClient, usdcAddress, diamondAddress, params) {
         })
       )
     ]).map(([usdc, priceConfig]) => {
-      const usdcFormatted = Number((0, import_viem8.formatUnits)(usdc, 6));
-      const sellPriceFormatted = Number((0, import_viem8.formatUnits)(priceConfig.sellPrice, 6));
+      const usdcFormatted = Number((0, import_viem9.formatUnits)(usdc, 6));
+      const sellPriceFormatted = Number((0, import_viem9.formatUnits)(priceConfig.sellPrice, 6));
       return {
         usdc: usdcFormatted,
         fiat: usdcFormatted * sellPriceFormatted,