Code cleanup and make parsing more reliable

Author: lorcan-codes

indexer/src/indexer.ts

@@ -3,7 +3,6 @@ import { requiredEnv } from "./utils/envs";
 import {
   GetTransactionReceiptResponse,
   ParsedEvent,
-  ParsedEvents,
 } from "starknet";
 import { Event } from "./entity/event";
 import { Transaction } from "./entity/transaction";
@@ -18,6 +17,7 @@ import {
 } from "./utils/contract";
 import { IsNull, Not } from "typeorm";
 import assert from "assert";
+import { eventNameMap } from "./utils/const";
 
 type ReturnedTransactionStatus = {
   tx_status: string;
@@ -30,19 +30,31 @@ const contractAddress = requiredEnv("CONTRACT_ADDRESS");
 
 function parseEvent(emittedEvent: EMITTED_EVENT): ParsedEvent {
   let parsedEvent: ParsedEvent | undefined = undefined;
+  const shouldUseNewContract = emittedEvent.block_number == null || emittedEvent.block_number > OLD_CONTRACT_BLOCK_END;
 
-  if (emittedEvent.block_number == null || emittedEvent.block_number >= OLD_CONTRACT_BLOCK_END) {
-    parsedEvent = contract
-      .parseEvents({
-        events: [emittedEvent],
-      } as GetTransactionReceiptResponse)
-      .at(0);
-  } else {
-    parsedEvent = oldContract
+  try {
+    const parsingContract = shouldUseNewContract ? contract : oldContract;
+    parsedEvent = parsingContract
       .parseEvents({
         events: [emittedEvent],
       } as GetTransactionReceiptResponse)
       .at(0);
+  } catch (e) {
+    console.error("Error parsing event with default parser", e);
+  }
+  
+  if (parsedEvent == undefined) {
+    console.debug("Parsing with fallback parser");
+    const parsingContract = shouldUseNewContract ? oldContract : contract;
+    try {
+      parsedEvent = parsingContract
+        .parseEvents({
+          events: [emittedEvent],
+        } as GetTransactionReceiptResponse)
+        .at(0);
+    } catch (e) {
+      console.error("Error parsing event with fallback parser", e);
+    }
   }
 
   assert(parsedEvent != null, "Parsed event is null.");
@@ -178,12 +190,6 @@ async function pullEvents() {
   }
 }
 
-const eventNameMap = {
-  GameCreated: "game_created",
-  GameEvolved: "game_evolved",
-  CellRevived: "cell_revived",
-} as { [key: string]: string };
-
 type MaterializedViewName = "balance" | "creator" | "infinite";
 
 async function refreshMaterializedView(name: MaterializedViewName) {

indexer/src/utils/const.ts

@@ -4,6 +4,11 @@ export const indexerApp = "indexer";
 export const viewRefresherApp = "viewRefresher";
 export const generator = "generator";
 export const apps = [indexerApp, viewRefresherApp, generator];
+export const eventNameMap = {
+  GameCreated: "game_created",
+  GameEvolved: "game_evolved",
+  CellRevived: "cell_revived",
+} as { [key: string]: string };
 
 export const abi = [
   {

indexer/src/utils/events-old.ts

@@ -1,10 +1,5 @@
-// import { contractOldAbiPromise, contractPromise } from "./contract";
-// import { requiredEnv } from "./envs";
-
 const uint256Shift = BigInt("0x100000000000000000000000000000000");
 
-// const OLD_CONTRACT_BLOCK_END = requiredEnv("OLD_CONTRACT_BLOCK_END");
-
 const isObject = (value: any): boolean => {
     return Object.prototype.toString.call(value) === '[object Object]'
 }
@@ -27,46 +22,4 @@ export const deserializeContent = (parsedEvent: any): any => {
 
     return eventContent;
 };
-
-// export const getParsedEvent = async (emittedEvent: any) => {
-//     const contractWithNewAbi = await contractPromise;
-//     const contractWithOldAbi = await contractOldAbiPromise;
-//     let parsedEvent: any = null;
-//     let failed = 0
-//     let parser = 'new'
-    
-//     if(OLD_CONTRACT_BLOCK_END && emittedEvent.block_number <= OLD_CONTRACT_BLOCK_END){
-//       parser = 'old'
-//     }
-  
-//     try {
-//       const contract = parser === 'new' ? contractWithNewAbi : contractWithOldAbi
-//       const [ParsedEvent] = contract.parseEvents({
-//         events: [emittedEvent],
-//       } as any);
-//       parsedEvent = ParsedEvent;
-//     } catch (e) {
-//       failed++;
-//       console.log(`Could not parse with ${parser} contract`, e);
-//     }
-  
-//     if (!parsedEvent || parsedEvent?.length === 0) {
-//       const fallbackContract = parser === 'new' ? contractWithOldAbi : contractWithNewAbi
-//       try {
-//         const [ParsedEvent] = fallbackContract.parseEvents({
-//           events: [emittedEvent],
-//         } as any);
-//           parsedEvent = ParsedEvent;
-//       } catch (e) {
-//         failed++;
-//         console.log("Could not parse with fallback contract", e);
-//       }
-//     }
-  
-//     if(failed === 2){
-//         console.error("Failed to parse event in both parsers", emittedEvent)
-//     }
-  
-//     return parsedEvent
-//   }