CRUD endpoints

Author: arcoraven

src/db/contractSubscriptions/createContractSubscription.ts

@@ -3,13 +3,22 @@ import { prisma } from "../client";
 interface CreateContractSubscriptionParams {
   chainId: number;
   contractAddress: string;
+  webhookId?: number;
 }
 
 export const createContractSubscription = async ({
   chainId,
   contractAddress,
+  webhookId,
 }: CreateContractSubscriptionParams) => {
   return prisma.contractSubscriptions.create({
-    data: { chainId, contractAddress },
+    data: {
+      chainId,
+      contractAddress,
+      webhookId,
+    },
+    include: {
+      webhook: true,
+    },
   });
 };

src/db/contractSubscriptions/deleteContractSubscription.ts

@@ -1,20 +1,8 @@
 import { prisma } from "../client";
 
-interface RemoveContractSubscriptionParams {
-  chainId: number;
-  contractAddress: string;
-}
-
-export const deleteContractSubscription = async ({
-  chainId,
-  contractAddress,
-}: RemoveContractSubscriptionParams) => {
-  return prisma.contractSubscriptions.updateMany({
-    where: {
-      chainId,
-      contractAddress,
-      deletedAt: null,
-    },
+export const deleteContractSubscription = async (id: string) => {
+  return prisma.contractSubscriptions.update({
+    where: { id },
     data: {
       deletedAt: new Date(),
     },

src/db/contractSubscriptions/getContractSubscriptions.ts

@@ -9,16 +9,14 @@ export const isContractSubscribed = async ({
   chainId,
   contractAddress,
 }: GetContractSubscriptionsParams) => {
-  const subscribedContract = await prisma.contractSubscriptions.findMany({
+  const contractSubscription = await prisma.contractSubscriptions.findFirst({
     where: {
       chainId,
       contractAddress,
       deletedAt: null,
     },
   });
-
-  if (subscribedContract.length === 0) return false;
-  else return true;
+  return contractSubscription !== null;
 };
 
 export const getContractSubscriptionsByChainId = async (
@@ -41,6 +39,9 @@ export const getAllContractSubscriptions = async () => {
     where: {
       deletedAt: null,
     },
+    include: {
+      webhook: true,
+    },
   });
 };
 

src/db/webhooks/getWebhook.ts

@@ -0,0 +1,7 @@
+import { prisma } from "../client";
+
+export const getWebhook = async (id: number) => {
+  return await prisma.webhooks.findUnique({
+    where: { id },
+  });
+};

src/db/webhooks/revokeWebhook.ts

@@ -1,34 +1,13 @@
-import { StatusCodes } from "http-status-codes";
-import { createCustomError } from "../../server/middleware/error";
 import { prisma } from "../client";
 
-interface RevokeWebhooksParams {
-  id: number;
-}
-
-export const markWebhookAsRevoked = async ({ id }: RevokeWebhooksParams) => {
-  const currentTimestamp = new Date();
-
-  const exists = await prisma.webhooks.findUnique({
-    where: {
-      id,
-    },
-  });
-
-  if (!exists)
-    throw createCustomError(
-      `Webhook with id ${id} does not exist`,
-      StatusCodes.BAD_REQUEST,
-      "BAD_REQUEST",
-    );
+export const deleteWebhook = async (id: number) => {
+  const now = new Date();
 
   return prisma.webhooks.update({
-    where: {
-      id,
-    },
+    where: { id },
     data: {
-      revokedAt: currentTimestamp,
-      updatedAt: currentTimestamp,
+      revokedAt: now,
+      updatedAt: now,
     },
   });
 };

src/server/middleware/auth.ts

@@ -17,7 +17,7 @@ import { THIRDWEB_DASHBOARD_ISSUER, handleSiwe } from "../../utils/auth";
 import { getAccessToken } from "../../utils/cache/accessToken";
 import { getAuthWallet } from "../../utils/cache/authWallet";
 import { getConfig } from "../../utils/cache/getConfig";
-import { getWebhook } from "../../utils/cache/getWebhook";
+import { getWebhooksByEventType } from "../../utils/cache/getWebhook";
 import { getKeypair } from "../../utils/cache/keypair";
 import { env } from "../../utils/env";
 import { logger } from "../../utils/logger";
@@ -397,7 +397,7 @@ const handleSecretKey = async (req: FastifyRequest): Promise<AuthResponse> => {
 const handleAuthWebhooks = async (
   req: FastifyRequest,
 ): Promise<AuthResponse> => {
-  const authWebhooks = await getWebhook(WebhooksEventTypes.AUTH);
+  const authWebhooks = await getWebhooksByEventType(WebhooksEventTypes.AUTH);
   if (authWebhooks.length > 0) {
     const authResponses = await Promise.all(
       authWebhooks.map(async (webhook) => {

src/server/routes/configuration/cors/remove.ts

@@ -29,8 +29,8 @@ export async function removeUrlToCorsConfiguration(fastify: FastifyInstance) {
     method: "DELETE",
     url: "/configuration/cors",
     schema: {
-      summary: "Remove Url from CORS configuration",
-      description: "Remove Url from CORS configuration",
+      summary: "Remove CORS URLs",
+      description: "Remove URLs from CORS configuration",
       tags: ["Configuration"],
       operationId: "removeUrlToCorsConfiguration",
       body: BodySchema,

src/server/routes/contract/subscriptions/addContractSubscription.ts

@@ -3,91 +3,112 @@ import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { upsertChainIndexer } from "../../../../db/chainIndexers/upsertChainIndexer";
 import { createContractSubscription } from "../../../../db/contractSubscriptions/createContractSubscription";
-import {
-  getContractSubscriptionsUniqueChainIds,
-  isContractSubscribed,
-} from "../../../../db/contractSubscriptions/getContractSubscriptions";
+import { getContractSubscriptionsUniqueChainIds } from "../../../../db/contractSubscriptions/getContractSubscriptions";
+import { insertWebhook } from "../../../../db/webhooks/createWebhook";
+import { WebhooksEventTypes } from "../../../../schema/webhooks";
 import { getSdk } from "../../../../utils/cache/getSdk";
+import { createCustomError } from "../../../middleware/error";
 import {
-  contractParamSchema,
-  standardResponseSchema,
-} from "../../../schemas/sharedApiSchemas";
+  contractSubscriptionSchema,
+  toContractSubscriptionSchema,
+} from "../../../schemas/contractSubscription";
+import { standardResponseSchema } from "../../../schemas/sharedApiSchemas";
 import { getChainIdFromChain } from "../../../utils/chain";
+import { isValidHttpUrl } from "../../../utils/validator";
 
-const responseSchema = Type.Object({
-  result: Type.Object({
-    chain: Type.String(),
-    contractAddress: Type.String(),
-    status: Type.String(),
+const bodySchema = Type.Object({
+  chain: Type.String({
+    description: "The chain for the contract.",
+  }),
+  contractAddress: Type.String({
+    description: "The address for the contract.",
   }),
+  webhookUrl: Type.Optional(
+    Type.String({
+      description: "Webhook URL",
+      examples: ["https://example.com/webhook"],
+    }),
+  ),
+});
+
+const responseSchema = Type.Object({
+  result: contractSubscriptionSchema,
 });
 
 responseSchema.example = {
   result: {
-    chain: "ethereum",
+    chain: 1,
     contractAddress: "0x....",
     status: "success",
   },
 };
 
 export async function addContractSubscription(fastify: FastifyInstance) {
   fastify.route<{
-    Params: Static<typeof contractParamSchema>;
+    Body: Static<typeof bodySchema>;
     Reply: Static<typeof responseSchema>;
   }>({
     method: "POST",
-    url: "/contract/:chain/:contractAddress/subscriptions/subscribe",
+    url: "/contract-subscriptions/add",
     schema: {
-      summary: "Subscribe to contract events and transactions",
-      description: "Subscribe to contract events and transactions",
+      summary: "Add contract subscription",
+      description:
+        "Subscribe to event logs and transaction receipts for a contract.",
       tags: ["Contract-Subscriptions"],
       operationId: "addContractSubscription",
-      params: contractParamSchema,
+      body: bodySchema,
       response: {
         ...standardResponseSchema,
         [StatusCodes.OK]: responseSchema,
       },
     },
     handler: async (request, reply) => {
-      const { chain, contractAddress } = request.params;
+      const { chain, contractAddress, webhookUrl } = request.body;
 
-      const standardizedContractAddress = contractAddress.toLowerCase();
       const chainId = await getChainIdFromChain(chain);
+      const standardizedContractAddress = contractAddress.toLowerCase();
 
-      const isAlreadySubscribed = await isContractSubscribed({
-        chainId,
-        contractAddress: standardizedContractAddress,
-      });
-
-      if (!isAlreadySubscribed) {
-        const subscribedChainIds =
-          await getContractSubscriptionsUniqueChainIds();
+      // If not currently indexed, upsert the latest block number.
+      const subscribedChainIds = await getContractSubscriptionsUniqueChainIds();
+      if (!subscribedChainIds.includes(chainId)) {
+        try {
+          const sdk = await getSdk({ chainId });
+          const provider = sdk.getProvider();
+          const currentBlockNumber = await provider.getBlockNumber();
+          await upsertChainIndexer({ chainId, currentBlockNumber });
+        } catch (error) {
+          // this is fine, must be already locked, so don't need to update current block as this will be recent
+        }
+      }
 
-        // if not currently indexed, upsert the latest block number
-        if (!subscribedChainIds.includes(chainId)) {
-          try {
-            const sdk = await getSdk({ chainId });
-            const provider = sdk.getProvider();
-            const currentBlockNumber = await provider.getBlockNumber();
-            await upsertChainIndexer({ chainId, currentBlockNumber });
-          } catch (error) {
-            // this is fine, must be already locked, so don't need to update current block as this will be recent
-          }
+      // Create the webhook (if provided).
+      let webhookId: number | undefined;
+      if (webhookUrl) {
+        if (!isValidHttpUrl(webhookUrl)) {
+          throw createCustomError(
+            "Invalid webhook URL. Make sure it starts with 'https://'.",
+            StatusCodes.BAD_REQUEST,
+            "BAD_REQUEST",
+          );
         }
 
-        // upsert indexed contract, this will be picked up
-        await createContractSubscription({
-          chainId,
-          contractAddress: standardizedContractAddress,
+        const webhook = await insertWebhook({
+          eventType: WebhooksEventTypes.CONTRACT_SUBSCRIPTION,
+          name: "Auto-generated for contract subscription",
+          url: webhookUrl,
         });
+        webhookId = webhook.id;
       }
 
+      // Create the contract subscription.
+      const contractSubscription = await createContractSubscription({
+        chainId,
+        contractAddress: standardizedContractAddress,
+        webhookId,
+      });
+
       reply.status(StatusCodes.OK).send({
-        result: {
-          chain,
-          contractAddress: standardizedContractAddress,
-          status: "success",
-        },
+        result: toContractSubscriptionSchema(contractSubscription),
       });
     },
   });

src/server/routes/contract/subscriptions/getContractSubscriptions.ts

@@ -2,41 +2,37 @@ import { Static, Type } from "@sinclair/typebox";
 import { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { getAllContractSubscriptions } from "../../../../db/contractSubscriptions/getContractSubscriptions";
+import {
+  contractSubscriptionSchema,
+  toContractSubscriptionSchema,
+} from "../../../schemas/contractSubscription";
 import { standardResponseSchema } from "../../../schemas/sharedApiSchemas";
 
 const responseSchema = Type.Object({
-  result: Type.Object({
-    contracts: Type.Array(
-      Type.Object({
-        chainId: Type.Number(),
-        contractAddress: Type.String(),
-      }),
-    ),
-    status: Type.String(),
-  }),
+  result: Type.Array(contractSubscriptionSchema),
 });
 
 responseSchema.example = {
-  result: {
-    contracts: [
-      {
-        chain: "ethereum",
-        contractAddress: "0x....",
+  result: [
+    {
+      chain: "ethereum",
+      contractAddress: "0x....",
+      webhook: {
+        url: "https://...",
       },
-    ],
-    status: "success",
-  },
+    },
+  ],
 };
 
 export async function getContractSubscriptions(fastify: FastifyInstance) {
   fastify.route<{
     Reply: Static<typeof responseSchema>;
   }>({
     method: "GET",
-    url: "/contract/subscriptions/get-all",
+    url: "/contract-subscriptions/get-all",
     schema: {
-      summary: "Get all subscribed contracts",
-      description: "Get all subscribed contracts",
+      summary: "Get contract subscriptions",
+      description: "Get all contract subscriptions.",
       tags: ["Contract-Subscriptions"],
       operationId: "getContractSubscriptions",
       response: {
@@ -47,16 +43,8 @@ export async function getContractSubscriptions(fastify: FastifyInstance) {
     handler: async (request, reply) => {
       const contractSubscriptions = await getAllContractSubscriptions();
 
-      const contracts = contractSubscriptions.map((val) => ({
-        chainId: val.chainId,
-        contractAddress: val.contractAddress,
-      }));
-
       reply.status(StatusCodes.OK).send({
-        result: {
-          contracts,
-          status: "success",
-        },
+        result: contractSubscriptions.map(toContractSubscriptionSchema),
       });
     },
   });