[indexer] run event listener

fc-community-indexer/package.json

@@ -1,8 +1,10 @@
 {
   "scripts": {
     "build": "tsc",
-    "dev": "tsc && node --env-file=.env dist/main.js",
-    "start": "node dist/main.js",
+    "sync-dev": "tsc && node --env-file=.env dist/synchroniser.js",
+    "sync": "node dist/synchroniser.js",
+    "dev": "tsc && node --env-file=.env dist/listener.js",
+    "start": "node dist/listener.js",
     "prettier": "prettier --write --ignore-unknown \"{config,public,src}/**/*.{html,css,js,ts,json}\"",
     "prettier:check": "prettier -l --ignore-unknown \"{config,public,src}/**/*.{html,css,js,ts,json}\""
   },

fc-community-indexer/src/events.ts

@@ -1721,7 +1721,9 @@ export const getEventsForNetwork = async (
   }
   const provider = new ethers.JsonRpcProvider(network.rpcUrl);
 
-  console.log(`Getting events for network ${networkName} from block ${fromBlock} to block ${toBlock}`);
+  console.log(
+    `Getting events for network ${networkName} from block ${fromBlock} to block ${toBlock}`,
+  );
   const maxBlockSpan = 10000;
   let currentBlock = fromBlock;
   const events: any[] = [];
@@ -1788,3 +1790,48 @@ const getEvents = async (
   );
   return allLogs.flat();
 };
+
+export const listenToEvents = (
+  handler: (factchainEvent: FactchainEvent) => void,
+) => {
+  supportedNetworks.map((network) => {
+    listenToEventsForNetwork(network, handler);
+  });
+};
+
+const listenToEventsForNetwork = (
+  network: any,
+  handler: (factchainEvent: FactchainEvent) => void,
+) => {
+  const provider = new ethers.WebSocketProvider(
+    network.rpcUrl.replace("https", "wss"),
+  );
+  network.contracts.map((factchainContract: FactchainContract) => {
+    const contract = new ethers.Contract(
+      factchainContract.address,
+      factchainContract.abi,
+      provider,
+    );
+
+    console.log(
+      `Listening to events for contract ${factchainContract.address} on network ${network.name}`,
+    );
+    contract.on("*", (newEvent) => {
+      try {
+        const event = newEvent.log;
+        console.log("New event received", event);
+        const factchainEvent = {
+          networkName: network.name,
+          contractAddress: event.address,
+          eventName: event.eventName,
+          blockTimestamp: Date.now(),
+          blockNumber: event.blockNumber,
+          eventArgs: factchainContract.parseEvent(event),
+        };
+        handler(factchainEvent);
+      } catch (e) {
+        console.error("Error processing event", e);
+      }
+    });
+  });
+};

fc-community-indexer/src/listener.ts

@@ -0,0 +1,10 @@
+import { listenToEvents } from "./events";
+import { writeEvent } from "./mongo";
+
+async function run() {
+  listenToEvents((factchainEvent) => {
+    console.log("Created factchain event", factchainEvent);
+    writeEvent(factchainEvent);
+  });
+}
+run().catch(console.dir);

fc-community-indexer/src/mongo.ts

@@ -32,21 +32,11 @@ const readLastBlockNumber = async (networkName: string) => {
 export const readNetworkBlocks = async (): Promise<NetworkBlock[]> => {
   const client = getClient();
   try {
-    await client.connect();
-    const collection = client.db("fc-community").collection("blocks");
-    const documents = await collection.find().toArray();
-
     return Promise.all(
       supportedNetworks.map(async (network) => {
-        const document = documents.find(
-          (doc) => doc.networkName === network.name,
-        );
         return {
           networkName: network.name,
-          // Default the fromBlock to the last event's block if no document is found for the network
-          fromBlock: document
-            ? document.fromBlock
-            : await readLastBlockNumber(network.name),
+          fromBlock: await readLastBlockNumber(network.name),
         };
       }),
     );
@@ -70,17 +60,13 @@ export const writeEvents = async (events: any[]) => {
   }
 };
 
-export const writeNetworkBlocks = async (networkBlocks: NetworkBlock[]) => {
-  console.log("Writing new network blocks", networkBlocks);
-  if (networkBlocks.length <= 0) {
-    return;
-  }
+export const writeEvent = async (event: any) => {
+  console.log("Writing new event", event);
   const client = getClient();
   try {
     await client.connect();
-    const collection = client.db("fc-community").collection("blocks");
-    await collection.deleteMany({});
-    await collection.insertMany(networkBlocks);
+    const collection = client.db("fc-community").collection("events");
+    await collection.insertOne(event);
   } finally {
     await client.close();
   }

fc-community-indexer/src/main.ts → fc-community-indexer/src/synchroniser.ts

@@ -1,4 +1,4 @@
-import { readNetworkBlocks, writeEvents, writeNetworkBlocks } from "./mongo";
+import { readNetworkBlocks, writeEvents } from "./mongo";
 import { getEventsForNetwork, getNetworkToBlocks } from "./events";
 import { NetworkBlock } from "./types";
 
@@ -16,14 +16,13 @@ async function run() {
           // Find the toBlock
           networkToBlocks.find(
             (networkToBlock) =>
-              networkToBlock.networkName === networkFromBlock.networkName
-          )!.fromBlock
+              networkToBlock.networkName === networkFromBlock.networkName,
+          )!.fromBlock,
         ),
       ),
     )
   ).flat();
 
   await writeEvents(events);
-  await writeNetworkBlocks(networkToBlocks);
 }
 run().catch(console.dir);