created own types for events for backward compatibility

Author: nischitpra

src/server/routes/contract/events/get-all-events.ts

@@ -1,7 +1,6 @@
 import { type Static, Type } from "@sinclair/typebox";
 import type { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { BigNumber } from "ethers";
 import {
   contractEventSchema,
   eventsQuerystringSchema,
@@ -14,6 +13,8 @@ import { thirdwebClient } from "../../../../shared/utils/sdk";
 import { getChain } from "../../../../shared/utils/chain";
 import { getChainIdFromChain } from "../../../utils/chain";
 import { getContract, getContractEvents } from "thirdweb";
+import { maybeBigInt } from "../../../../shared/utils/primitive-types";
+import { toContractEventV4Schema } from "../../../schemas/event";
 
 const requestSchema = contractParamSchema;
 
@@ -91,61 +92,20 @@ export async function getAllEvents(fastify: FastifyInstance) {
         address: contractAddress,
         chain: await getChain(chainId),
       });
-      const returnData = mapEventsV4ToV5(
-        await getContractEvents({
-          contract: contract,
-          fromBlock: BigInt(fromBlock),
-          toBlock: BigInt(toBlock),
-        }),
-        order,
-      );
+
+      const eventsV5 = await getContractEvents({
+        contract: contract,
+        fromBlock: maybeBigInt(fromBlock?.toString()),
+        toBlock: maybeBigInt(toBlock?.toString()),
+      });
 
       reply.status(StatusCodes.OK).send({
-        result: returnData,
+        result: eventsV5.map(toContractEventV4Schema).sort((a, b) => {
+          return order === "desc"
+            ? b.transaction.blockNumber - a.transaction.blockNumber
+            : a.transaction.blockNumber - b.transaction.blockNumber;
+        }),
       });
     },
   });
 }
-
-/**
- * Mapping of events v5 response to v4 for backward compatiblity.
- * Clients may be using this api and dont want to break things.
- * @param eventsV5 events data returned by v5 sdk
- * @param order asc or desc
- * @returns {Type.Array(contractEventSchema)}
- */
-export function mapEventsV4ToV5(eventsV5 = [], order = "desc") {
-  if (!eventsV5?.length) return [];
-
-  return eventsV5
-    .map((event) => {
-      const eventName = event.eventName;
-      const data = {};
-
-      // backwards compatibility of BigInt(v5) to BigNumber(v4)
-      Object.keys(event.args).forEach((key) => {
-        let value = event.args[key];
-        if (typeof value == "bigint") {
-          value = BigNumber.from(value.toString());
-        }
-        data[key] = value;
-      });
-
-      delete event.eventName;
-      delete event.args;
-      const transaction = event;
-      transaction.blockNumber = parseInt(transaction.blockNumber);
-      transaction.event = eventName;
-
-      return {
-        eventName,
-        data,
-        transaction,
-      };
-    })
-    .sort((a, b) => {
-      return order === "desc"
-        ? b.transaction.blockNumber - a.transaction.blockNumber
-        : a.transaction.blockNumber - b.transaction.blockNumber;
-    });
-}

src/server/schemas/event.ts

@@ -0,0 +1,69 @@
+import { BigNumber } from "ethers";
+
+export type ContractEventV5 = {
+  eventName: string;
+  args: Record<string, any>;
+  address: string;
+  topic: string[];
+  data: string;
+  blockNumber: bigint;
+  transactionHash: string;
+  transactionIndex: number;
+  blockHash: string;
+  logIndex: number;
+  removed: boolean;
+};
+
+export type ContractEventV4 = {
+  eventName: string;
+  data: Record<string, any>;
+  transaction: {
+    blockNumber: bigint;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    address: string;
+    data: string;
+    topic: string[];
+    transactionHash: string;
+    logIndex: number;
+    event: string;
+    eventSignature: string | undefined;
+  };
+};
+
+/**
+ * Mapping of events v5 response to v4 for backward compatiblity.
+ * Clients may be using this api and dont want to break things.
+ */
+export function toContractEventV4Schema(eventV5: ContractEventV5) {
+  const eventName = eventV5.eventName;
+
+  // backwards compatibility of BigInt(v5) to BigNumber(v4)
+  const data: Record<string, unknown> = {};
+  Object.keys(eventV5.args).forEach((key) => {
+    let value = eventV5.args[key];
+    if (typeof value === "bigint") {
+      value = BigNumber.from(value.toString());
+    }
+    data[key] = value;
+  });
+
+  return {
+    eventName,
+    data,
+    transaction: {
+      blockNumber: Number(eventV5.blockNumber),
+      blockHash: eventV5.blockHash,
+      transactionIndex: eventV5.transactionIndex,
+      removed: eventV5.removed,
+      address: eventV5.address,
+      data: eventV5.data,
+      topic: eventV5.topic,
+      transactionHash: eventV5.transactionHash,
+      logIndex: eventV5.logIndex,
+      event: eventV5.eventName,
+      // todo: eventV5.eventSignature is not returned so ignoring for now
+    },
+  };
+}

tests/unit/migrationV5.test.ts

@@ -8,12 +8,10 @@ import { getBalance } from "thirdweb/extensions/erc20";
 import { getContractEvents } from "thirdweb";
 import { getContract as getContractV5 } from "thirdweb";
 import { getContract as getContractV4 } from "../../src/shared/utils/cache/get-contract";
-import { mapEventsV4ToV5 } from "../../src/server/routes/contract/events/get-all-events";
+import { maybeBigInt } from "../../src/shared/utils/primitive-types";
+import { toContractEventV4Schema } from "../../src/server/schemas/event";
 
 /**
- * need to pass THIRDWEB_API_SECRET_KEY as env when running test case
- * THIRDWEB_API_SECRET_KEY=<secret> npx vitest run tests/unit/migrationV5.test.ts
- *
  * todo: remove all dependencies including tests after everything is migrated properly.
  */
 describe("migration from v4 to v5", () => {
@@ -75,7 +73,7 @@ describe("migration from v4 to v5", () => {
     const contractAddress = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
     const fromBlock = 65334800;
     const toBlock = 65334801;
-    const order = "asc";
+    const order = Math.random() > 0.5 ? "asc" : "desc";
 
     // v4
     const contractV4 = await getContractV4({ chainId, contractAddress });
@@ -84,22 +82,24 @@ describe("migration from v4 to v5", () => {
       toBlock,
       order,
     });
-    // console.log(eventsV4);
 
     // v5.
     const contractV5 = getContractV5({
       client: thirdwebClient,
       address: contractAddress,
       chain: await getChain(chainId),
     });
-    const eventsV5 = mapEventsV4ToV5(
-      await getContractEvents({
-        contract: contractV5,
-        fromBlock: BigInt(fromBlock),
-        toBlock: BigInt(toBlock),
-      }),
-      order,
-    );
+    const eventsV5Raw = await getContractEvents({
+      contract: contractV5,
+      fromBlock: maybeBigInt(fromBlock?.toString()),
+      toBlock: maybeBigInt(toBlock?.toString()),
+    });
+
+    const eventsV5 = eventsV5Raw.map(toContractEventV4Schema).sort((a, b) => {
+      return order === "desc"
+        ? b.transaction.blockNumber - a.transaction.blockNumber
+        : a.transaction.blockNumber - b.transaction.blockNumber;
+    });
 
     // check two array ordering is the same
     expect(eventsV4.length).eq(eventsV5.length);