@p2pdotme/sdk 1.1.8 → 1.1.9

package/dist/orders.mjs

@@ -485,6 +485,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 = [
   {
@@ -691,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,
@@ -3376,15 +3469,15 @@ function weierstrassPoints(opts) {
       throw new Error("ProjectivePoint expected");
   }
   const toAffineMemo = memoized((p, iz) => {
-    const { px: x, py: y, pz: z9 } = p;
-    if (Fp.eql(z9, Fp.ONE))
+    const { px: x, py: y, pz: z10 } = p;
+    if (Fp.eql(z10, Fp.ONE))
       return { x, y };
     const is0 = p.is0();
     if (iz == null)
-      iz = is0 ? Fp.ONE : Fp.inv(z9);
+      iz = is0 ? Fp.ONE : Fp.inv(z10);
     const ax = Fp.mul(x, iz);
     const ay = Fp.mul(y, iz);
-    const zz = Fp.mul(z9, iz);
+    const zz = Fp.mul(z10, iz);
     if (is0)
       return { x: Fp.ZERO, y: Fp.ZERO };
     if (!Fp.eql(zz, Fp.ONE))
@@ -4379,7 +4472,7 @@ function createSetSellOrderUpiAction(input) {
 }
 
 // src/orders/internal/routing/client.ts
-import { stringToHex as stringToHex6 } from "viem";
+import { stringToHex as stringToHex7 } from "viem";
 
 // src/contracts/error-messages.ts
 var contractErrorMessages = {
@@ -5162,105 +5255,127 @@ var ZodCurrencyScopedParamsSchema = z6.object({
   currency: ZodCurrencySchema
 });
 
+// src/contracts/p2p-stake/index.ts
+import { ResultAsync as ResultAsync8 } from "neverthrow";
+import { stringToHex as stringToHex5 } from "viem";
+
+// src/stake/validation.ts
+import { z as z7 } from "zod";
+var ZodGetUserStakeParamsSchema = z7.object({
+  user: ZodAddressSchema
+});
+var ZodGetStakeBoostConfigParamsSchema = z7.object({
+  currency: ZodCurrencySchema
+});
+var ZodGetP2pTokenBalanceParamsSchema = z7.object({
+  address: ZodAddressSchema
+});
+var ZodStakeParamsSchema = z7.object({
+  tokens: z7.bigint().positive()
+});
+var ZodTopUpParamsSchema = z7.object({
+  tokens: z7.bigint().positive()
+});
+
 // src/contracts/reputation-manager/writes.ts
 import { Result as Result2 } from "neverthrow";
 import { encodeFunctionData as encodeFunctionData7 } from "viem";
 
 // src/zkkyc/validation.ts
-import { z as z7 } from "zod";
-var ZodAnonAadharProofParamsSchema = z7.object({
-  nullifierSeed: z7.bigint(),
-  nullifier: z7.bigint(),
-  timestamp: z7.bigint(),
-  signal: z7.bigint(),
-  revealArray: z7.tuple([z7.bigint(), z7.bigint(), z7.bigint(), z7.bigint()]),
-  packedGroth16Proof: z7.tuple([
-    z7.bigint(),
-    z7.bigint(),
-    z7.bigint(),
-    z7.bigint(),
-    z7.bigint(),
-    z7.bigint(),
-    z7.bigint(),
-    z7.bigint()
+import { z as z8 } from "zod";
+var ZodAnonAadharProofParamsSchema = z8.object({
+  nullifierSeed: z8.bigint(),
+  nullifier: z8.bigint(),
+  timestamp: z8.bigint(),
+  signal: z8.bigint(),
+  revealArray: z8.tuple([z8.bigint(), z8.bigint(), z8.bigint(), z8.bigint()]),
+  packedGroth16Proof: z8.tuple([
+    z8.bigint(),
+    z8.bigint(),
+    z8.bigint(),
+    z8.bigint(),
+    z8.bigint(),
+    z8.bigint(),
+    z8.bigint(),
+    z8.bigint()
   ])
 });
-var ZodSocialVerifyParamsSchema = z7.object({
-  _socialName: z7.string(),
-  proofs: z7.array(
-    z7.object({
-      claimInfo: z7.object({
-        provider: z7.string(),
-        parameters: z7.string(),
-        context: z7.string()
+var ZodSocialVerifyParamsSchema = z8.object({
+  _socialName: z8.string(),
+  proofs: z8.array(
+    z8.object({
+      claimInfo: z8.object({
+        provider: z8.string(),
+        parameters: z8.string(),
+        context: z8.string()
       }),
-      signedClaim: z7.object({
-        claim: z7.object({
-          identifier: z7.string(),
+      signedClaim: z8.object({
+        claim: z8.object({
+          identifier: z8.string(),
           owner: ZodAddressSchema,
-          timestampS: z7.number(),
-          epoch: z7.number()
+          timestampS: z8.number(),
+          epoch: z8.number()
         }),
-        signatures: z7.array(z7.string())
+        signatures: z8.array(z8.string())
       })
     })
   )
 });
-var ZodSolidityVerifierParametersSchema = z7.object({
-  version: z7.string().refine((val) => val.startsWith("0x"), {
+var ZodSolidityVerifierParametersSchema = z8.object({
+  version: z8.string().refine((val) => val.startsWith("0x"), {
     message: "Version must be a hex string"
   }),
-  proofVerificationData: z7.object({
-    vkeyHash: z7.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+  proofVerificationData: z8.object({
+    vkeyHash: z8.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
       message: "Invalid bytes32 hex string"
     }),
-    proof: z7.string().refine((val) => val.startsWith("0x"), {
+    proof: z8.string().refine((val) => val.startsWith("0x"), {
       message: "Proof must be a hex string"
     }),
-    publicInputs: z7.array(
-      z7.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
+    publicInputs: z8.array(
+      z8.string().refine((val) => /^0x[a-fA-F0-9]{64}$/.test(val), {
         message: "Each public input must be a valid bytes32 hex string"
       })
     )
   }),
-  committedInputs: z7.string().refine((val) => val.startsWith("0x"), {
+  committedInputs: z8.string().refine((val) => val.startsWith("0x"), {
     message: "Committed inputs must be a hex string"
   }),
-  serviceConfig: z7.object({
-    validityPeriodInSeconds: z7.number().int().nonnegative(),
-    domain: z7.string(),
-    scope: z7.string(),
-    devMode: z7.boolean()
+  serviceConfig: z8.object({
+    validityPeriodInSeconds: z8.number().int().nonnegative(),
+    domain: z8.string(),
+    scope: z8.string(),
+    devMode: z8.boolean()
   })
 });
-var ZodZkPassportRegisterParamsSchema = z7.object({
+var ZodZkPassportRegisterParamsSchema = z8.object({
   params: ZodSolidityVerifierParametersSchema,
-  isIDCard: z7.boolean()
+  isIDCard: z8.boolean()
 });
 
 // src/contracts/tx-limits/index.ts
-import { ResultAsync as ResultAsync8 } from "neverthrow";
-import { formatUnits, stringToHex as stringToHex5 } from "viem";
+import { ResultAsync as ResultAsync9 } from "neverthrow";
+import { formatUnits, stringToHex as stringToHex6 } from "viem";
 
 // src/profile/validation.ts
-import { z as z8 } from "zod";
-var ZodUsdcBalanceParamsSchema = z8.object({
+import { z as z9 } from "zod";
+var ZodUsdcBalanceParamsSchema = z9.object({
   address: ZodAddressSchema
 });
-var ZodUsdcAllowanceParamsSchema = z8.object({
+var ZodUsdcAllowanceParamsSchema = z9.object({
   owner: ZodAddressSchema
 });
-var ZodGetBalancesParamsSchema = z8.object({
+var ZodGetBalancesParamsSchema = z9.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
-var ZodTxLimitsParamsSchema = z8.object({
+var ZodTxLimitsParamsSchema = z9.object({
   address: ZodAddressSchema,
   currency: ZodCurrencySchema
 });
 
 // src/contracts/usdc/index.ts
-import { ResultAsync as ResultAsync9 } from "neverthrow";
+import { ResultAsync as ResultAsync10 } from "neverthrow";
 import { erc20Abi as erc20Abi3 } from "viem";
 
 // src/orders/internal/routing/routing.ts
@@ -5439,7 +5554,7 @@ function createOrderRouter(config) {
   const logger = config.logger ?? noopLogger;
   return {
     selectCircle(params) {
-      const currencyHex = stringToHex6(params.currency, { size: 32 });
+      const currencyHex = stringToHex7(params.currency, { size: 32 });
       logger.info("selectCircle started", {
         currency: params.currency,
         user: params.user,