Claim Condition End-points (#358)

* Added ERC721 ClaimConditions Read End-points

* Added all claim-conditions end-points

* updated cron logic to not run multiple servers and avoid connection pool issues

* Added Prisma INFO level logging to get connection_pool details

* updated all claim end-points after testing

* updated setBatch conditions

* Added Erc20 & Erc1155 routes to index files

* updates

Author: farhanW3

src/db/client.ts

@@ -3,7 +3,9 @@ import pg, { Knex } from "knex";
 import { PrismaTransaction } from "../schema/prisma";
 import { env } from "../utils/env";
 
-export const prisma = new PrismaClient();
+export const prisma = new PrismaClient({
+  log: ["info"],
+});
 
 export const getPrismaWithPostgresTx = (pgtx?: PrismaTransaction) => {
   return pgtx || prisma;

src/server/index.ts

@@ -70,6 +70,14 @@ const main = async () => {
     },
   );
 
+  logger({
+    service: "server",
+    level: "info",
+    message: `Listening on ${env.ENABLE_HTTPS ? "https://" : "http://"}${
+      env.HOST
+    }:${env.PORT}`,
+  });
+
   writeOpenApiToFile(server);
 };
 

src/server/routes/contract/extensions/erc1155/index.ts

@@ -1,11 +1,17 @@
 import { FastifyInstance } from "fastify";
+import { erc1155BalanceOf } from "./read/balanceOf";
+import { erc1155CanClaim } from "./read/canClaim";
 import { erc1155Get } from "./read/get";
+import { erc1155GetActiveClaimConditions } from "./read/getActiveClaimConditions";
 import { erc1155GetAll } from "./read/getAll";
-import { erc1155BalanceOf } from "./read/balanceOf";
-import { erc1155IsApproved } from "./read/isApproved";
+import { erc1155GetAllClaimConditions } from "./read/getAllClaimConditions";
+import { erc1155GetClaimIneligibilityReasons } from "./read/getClaimIneligibilityReasons";
+import { erc1155GetClaimerProofs } from "./read/getClaimerProofs";
 import { erc1155GetOwned } from "./read/getOwned";
-import { erc1155TotalSupply } from "./read/totalSupply";
+import { erc1155IsApproved } from "./read/isApproved";
+import { erc1155SignatureGenerate } from "./read/signatureGenerate";
 import { erc1155TotalCount } from "./read/totalCount";
+import { erc1155TotalSupply } from "./read/totalSupply";
 import { erc1155airdrop } from "./write/airdrop";
 import { erc1155burn } from "./write/burn";
 import { erc1155burnBatch } from "./write/burnBatch";
@@ -15,10 +21,12 @@ import { erc1155mintAdditionalSupplyTo } from "./write/mintAdditionalSupplyTo";
 import { erc1155mintBatchTo } from "./write/mintBatchTo";
 import { erc1155mintTo } from "./write/mintTo";
 import { erc1155SetApprovalForAll } from "./write/setApprovalForAll";
+import { erc1155SetBatchClaimConditions } from "./write/setBatchClaimConditions";
+import { erc1155SetClaimCondition } from "./write/setClaimConditions";
+import { erc1155SignatureMint } from "./write/signatureMint";
 import { erc1155transfer } from "./write/transfer";
 import { erc1155transferFrom } from "./write/transferFrom";
-import { erc1155SignatureGenerate } from "./read/signatureGenerate";
-import { erc1155SignatureMint } from "./write/signatureMint";
+import { erc1155UpdateClaimConditions } from "./write/updateClaimConditions";
 
 export const erc1155Routes = async (fastify: FastifyInstance) => {
   // GET
@@ -30,6 +38,11 @@ export const erc1155Routes = async (fastify: FastifyInstance) => {
   await fastify.register(erc1155TotalCount);
   await fastify.register(erc1155TotalSupply);
   await fastify.register(erc1155SignatureGenerate);
+  await fastify.register(erc1155CanClaim);
+  await fastify.register(erc1155GetActiveClaimConditions);
+  await fastify.register(erc1155GetAllClaimConditions);
+  await fastify.register(erc1155GetClaimerProofs);
+  await fastify.register(erc1155GetClaimIneligibilityReasons);
 
   // POST
   await fastify.register(erc1155airdrop);
@@ -44,4 +57,7 @@ export const erc1155Routes = async (fastify: FastifyInstance) => {
   await fastify.register(erc1155transfer);
   await fastify.register(erc1155transferFrom);
   await fastify.register(erc1155SignatureMint);
+  await fastify.register(erc1155SetClaimCondition);
+  await fastify.register(erc1155SetBatchClaimConditions);
+  await fastify.register(erc1155UpdateClaimConditions);
 };

src/server/routes/contract/extensions/erc1155/read/canClaim.ts

@@ -0,0 +1,75 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { getContract } from "../../../../../../utils/cache/getContract";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+} from "../../../../../schemas/sharedApiSchemas";
+import { getChainIdFromChain } from "../../../../../utils/chain";
+
+// INPUT
+const requestSchema = contractParamSchema;
+const requestQueryString = Type.Object({
+  quantity: Type.String({
+    description: "The amount of tokens to claim.",
+  }),
+  tokenId: Type.String({
+    description: "The token ID of the NFT you want to claim.",
+  }),
+  addressToCheck: Type.Optional(
+    Type.String({
+      description:
+        "The wallet address to check if it can claim tokens. This considers all aspects of the active claim phase, including allowlists, previous claims, etc.",
+      examples: ["0x1946267d81Fb8aDeeEa28e6B98bcD446c8248473"],
+    }),
+  ),
+});
+
+// OUPUT
+const responseSchema = Type.Object({
+  result: Type.Boolean(),
+});
+
+// LOGIC
+export async function erc1155CanClaim(fastify: FastifyInstance) {
+  fastify.route<{
+    Params: Static<typeof requestSchema>;
+    Reply: Static<typeof responseSchema>;
+    Querystring: Static<typeof requestQueryString>;
+  }>({
+    method: "GET",
+    url: "/contract/:chain/:contractAddress/erc1155/claim-conditions/can-claim",
+    schema: {
+      summary: "Check if tokens are available for claiming",
+      description:
+        "Check if tokens are currently available for claiming, optionally specifying if a specific wallet address can claim.",
+      tags: ["ERC1155"],
+      operationId: "canClaim",
+      params: requestSchema,
+      querystring: requestQueryString,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const { chain, contractAddress } = request.params;
+      const { quantity, tokenId, addressToCheck } = request.query;
+
+      const chainId = await getChainIdFromChain(chain);
+      const contract = await getContract({
+        chainId,
+        contractAddress,
+      });
+      const returnData = await contract.erc1155.claimConditions.canClaim(
+        quantity,
+        tokenId,
+        addressToCheck,
+      );
+      reply.status(StatusCodes.OK).send({
+        result: returnData,
+      });
+    },
+  });
+}

src/server/routes/contract/extensions/erc1155/read/getActiveClaimConditions.ts

@@ -0,0 +1,84 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { getContract } from "../../../../../../utils/cache/getContract";
+import { claimConditionOutputSchema } from "../../../../../schemas/claimConditions";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+} from "../../../../../schemas/sharedApiSchemas";
+import { getChainIdFromChain } from "../../../../../utils/chain";
+
+// INPUT
+const requestSchema = contractParamSchema;
+const requestQueryString = Type.Object({
+  tokenId: Type.Union([Type.String(), Type.Number()], {
+    description: "The token ID of the NFT you want to claim.",
+  }),
+  withAllowList: Type.Optional(
+    Type.Boolean({
+      description:
+        "Provide a boolean value to include the allowlist in the response.",
+    }),
+  ),
+});
+
+// OUPUT
+const responseSchema = Type.Object({
+  result: claimConditionOutputSchema,
+});
+
+// LOGIC
+export async function erc1155GetActiveClaimConditions(
+  fastify: FastifyInstance,
+) {
+  fastify.route<{
+    Params: Static<typeof requestSchema>;
+    Reply: Static<typeof responseSchema>;
+    Querystring: Static<typeof requestQueryString>;
+  }>({
+    method: "GET",
+    url: "/contract/:chain/:contractAddress/erc1155/claim-conditions/get-active",
+    schema: {
+      summary: "Get currently active claim phase for a specific token ID.",
+      description:
+        "Retrieve the currently active claim phase for a specific token ID, if any.",
+      tags: ["ERC1155"],
+      operationId: "getActiveClaimConditions",
+      params: requestSchema,
+      querystring: requestQueryString,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const { chain, contractAddress } = request.params;
+      const { tokenId, withAllowList } = request.query;
+
+      const chainId = await getChainIdFromChain(chain);
+      const contract = await getContract({
+        chainId,
+        contractAddress,
+      });
+      const returnData = await contract.erc1155.claimConditions.getActive(
+        tokenId,
+        {
+          withAllowList,
+        },
+      );
+      reply.status(StatusCodes.OK).send({
+        result: {
+          ...returnData,
+          price: returnData.price.toString(),
+          waitInSeconds: returnData.waitInSeconds.toString(),
+          currencyMetadata: {
+            ...returnData.currencyMetadata,
+            value: returnData.currencyMetadata.value.toString(),
+          },
+          startTime: returnData.startTime.toISOString(),
+        },
+      });
+    },
+  });
+}

src/server/routes/contract/extensions/erc1155/read/getAllClaimConditions.ts

@@ -0,0 +1,88 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { getContract } from "../../../../../../utils/cache/getContract";
+import { claimConditionOutputSchema } from "../../../../../schemas/claimConditions";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+} from "../../../../../schemas/sharedApiSchemas";
+import { getChainIdFromChain } from "../../../../../utils/chain";
+
+// INPUT
+const requestSchema = contractParamSchema;
+const requestQueryString = Type.Object({
+  tokenId: Type.Union([Type.String(), Type.Number()], {
+    description:
+      "The token ID of the NFT you want to get the claim conditions for.",
+  }),
+  withAllowList: Type.Optional(
+    Type.Boolean({
+      description:
+        "Provide a boolean value to include the allowlist in the response.",
+    }),
+  ),
+});
+
+// OUPUT
+const responseSchema = Type.Object({
+  result: Type.Array(claimConditionOutputSchema),
+});
+
+// LOGIC
+export async function erc1155GetAllClaimConditions(fastify: FastifyInstance) {
+  fastify.route<{
+    Params: Static<typeof requestSchema>;
+    Reply: Static<typeof responseSchema>;
+    Querystring: Static<typeof requestQueryString>;
+  }>({
+    method: "GET",
+    url: "/contract/:chain/:contractAddress/erc1155/claim-conditions/get-all",
+    schema: {
+      summary: "Get all the claim phases configured for a specific token ID.",
+      description:
+        "Get all the claim phases configured for a specific token ID.",
+      tags: ["ERC1155"],
+      operationId: "getAllClaimConditions",
+      params: requestSchema,
+      querystring: requestQueryString,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const { chain, contractAddress } = request.params;
+      const { tokenId, withAllowList } = request.query;
+
+      const chainId = await getChainIdFromChain(chain);
+      const contract = await getContract({
+        chainId,
+        contractAddress,
+      });
+      const returnData = await contract.erc1155.claimConditions.getAll(
+        tokenId,
+        {
+          withAllowList,
+        },
+      );
+
+      const sanitizedReturnData = returnData.map((item) => {
+        return {
+          ...item,
+          price: item.price.toString(),
+          waitInSeconds: item.waitInSeconds.toString(),
+          currencyMetadata: {
+            ...item.currencyMetadata,
+            value: item.currencyMetadata.value.toString(),
+          },
+          startTime: item.startTime.toISOString(),
+        };
+      });
+
+      reply.status(StatusCodes.OK).send({
+        result: sanitizedReturnData,
+      });
+    },
+  });
+}