feat(fallbacks): add fallbacks for topic0 hash

jagnani73 · jagnani73 · commit cd14e430be29 · 2024-02-16T18:08:27.000+05:30
diff --git a/services/decoder/decoder.ts b/services/decoder/decoder.ts
@@ -12,20 +12,24 @@ import {
     type DecodingFunctions,
     type EventType,
     type DecoderConfig,
+    type Fallbacks,
 } from "./decoder.types";
 import { encodeEventTopics, type Abi } from "viem";
 
 export class GoldRushDecoder {
     private static configs: DecoderConfig = {};
     private static decoders: Decoders = {};
+    private static fallbacks: Fallbacks = {};
     private static decoding_functions: DecodingFunctions = [];
 
     public static initDecoder = () => {
-        const directoryPath: string = join(__dirname, "/protocols");
-        const protocols = readdirSync(directoryPath);
+        console.info("Initializing GoldrushDecoder Service...");
+
+        const protocolsDirectoryPath: string = join(__dirname, "/protocols");
+        const protocols = readdirSync(protocolsDirectoryPath);
         let protocolsCount: number = 0;
         for (const protocol of protocols) {
-            const protocolPath = join(directoryPath, protocol);
+            const protocolPath = join(protocolsDirectoryPath, protocol);
             const files = readdirSync(protocolPath);
             let configFile: string | null = null,
                 decodersFile: string | null = null;
@@ -56,6 +60,27 @@ export class GoldRushDecoder {
             }
         }
 
+        const fallbacksDirectoryPath: string = join(__dirname, "/fallbacks");
+        const fallbacks = readdirSync(fallbacksDirectoryPath);
+        let fallbacksCount: number = 0;
+        for (const fallback of fallbacks) {
+            const fallbackPath = join(fallbacksDirectoryPath, fallback);
+            const files = readdirSync(fallbackPath);
+            let fallbackFile: string | null = null;
+            files.forEach((file) => {
+                const fileExtension =
+                    process.env.NODE_ENV !== "test" ? "js" : "ts";
+                if (file.endsWith(`.fallback.${fileExtension}`)) {
+                    fallbackFile = file;
+                }
+            });
+            if (fallbackFile) {
+                fallbacksCount++;
+                require(join(fallbackPath, fallbackFile));
+            }
+        }
+
+        const decodersCount = Object.keys(this.decoding_functions).length;
         const configsCount = Object.values(this.configs).reduce(
             (networkCount, network) => {
                 return (
@@ -68,11 +93,10 @@ export class GoldRushDecoder {
             0
         );
 
-        const decodersCount = Object.keys(this.decoding_functions).length;
-
-        console.info(
-            `Created ${configsCount} configs and ${decodersCount} decoders for ${protocolsCount} protocols!`
-        );
+        console.info(`${protocolsCount.toLocaleString()} protocols found`);
+        console.info(`${configsCount.toLocaleString()} configs generated`);
+        console.info(`${decodersCount.toLocaleString()} decoders generated`);
+        console.info(`${fallbacksCount.toLocaleString()} fallbacks generated`);
     };
 
     public static on = (
@@ -82,7 +106,7 @@ export class GoldRushDecoder {
         decoding_function: DecodingFunction
     ) => {
         const [protocol, event_name] = event_id.split(":");
-        const [topic0] = encodeEventTopics({
+        const [topic0_hash] = encodeEventTopics({
             abi: abi,
             eventName: event_name,
         });
@@ -101,12 +125,27 @@ export class GoldRushDecoder {
             Object.keys(this.configs[network][protocol]).forEach((address) => {
                 this.decoders[network] ??= {};
                 this.decoders[network][address] ??= {};
-                this.decoders[network][address][topic0] =
+                this.decoders[network][address][topic0_hash] =
                     decoding_function_index;
             });
         });
     };
 
+    public static fallback = (
+        event_name: string,
+        abi: Abi,
+        decoding_function: DecodingFunction
+    ) => {
+        const [topic0_hash] = encodeEventTopics({
+            abi: abi,
+            eventName: event_name,
+        });
+        this.decoding_functions.push(decoding_function);
+        const decoding_function_index: number =
+            this.decoding_functions.length - 1;
+        this.fallbacks[topic0_hash] = decoding_function_index;
+    };
+
     public static decode = async (
         network: Chain,
         tx: Transaction,
@@ -123,17 +162,18 @@ export class GoldRushDecoder {
                     // !ERROR: add factory_contract_address in the log_event(s)
                     // factory_contract_address,
                 } = log;
-                const function_index =
+                const decoding_index =
                     // !ERROR: add factory_contract_address in the log_event(s)
                     // factory_contract_address ||
                     this.decoders[network][contract_address]?.[topic0_hash];
-                if (function_index !== undefined) {
-                    const event = await this.decoding_functions[function_index](
-                        log,
-                        tx,
-                        network,
-                        covalent_client
-                    );
+                const fallback_index = this.fallbacks[topic0_hash];
+                if (
+                    decoding_index !== undefined ||
+                    fallback_index !== undefined
+                ) {
+                    const event = await this.decoding_functions[
+                        decoding_index ?? fallback_index
+                    ](log, tx, network, covalent_client);
                     events.push(event);
                 }
             }
diff --git a/services/decoder/decoder.types.ts b/services/decoder/decoder.types.ts
@@ -86,4 +86,10 @@ export type Decoders =
       }
     | Record<string, never>;
 
+export type Fallbacks =
+    | {
+          [topic0_hash: string]: number;
+      }
+    | Record<string, never>;
+
 export type DecodingFunctions = DecodingFunction[];
diff --git a/services/decoder/fallbacks/transfer/abis/transfer.abi.json b/services/decoder/fallbacks/transfer/abis/transfer.abi.json
@@ -0,0 +1,27 @@
+[
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    }
+]
diff --git a/services/decoder/fallbacks/transfer/transfer.fallback.ts b/services/decoder/fallbacks/transfer/transfer.fallback.ts
@@ -0,0 +1,91 @@
+import { GoldRushDecoder } from "../../decoder";
+import { type EventType } from "../../decoder.types";
+import {
+    DECODED_ACTION,
+    DECODED_EVENT_CATEGORY,
+} from "../../decoder.constants";
+import { decodeEventLog, type Abi } from "viem";
+import ABI from "./abis/transfer.abi.json";
+import { TimestampParser } from "../../../../utils/functions";
+import { prettifyCurrency } from "@covalenthq/client-sdk";
+
+GoldRushDecoder.fallback(
+    "Transfer",
+    ABI as Abi,
+    async (log_event, tx, chain_name, covalent_client): Promise<EventType> => {
+        const { raw_log_data, raw_log_topics } = log_event;
+
+        const { args: decoded } = decodeEventLog({
+            abi: ABI,
+            topics: raw_log_topics as [],
+            data: raw_log_data as `0x${string}`,
+            eventName: "Transfer",
+        }) as {
+            eventName: "Transfer";
+            args: {
+                from: string;
+                to: string;
+                value: bigint;
+            };
+        };
+
+        const date = TimestampParser(log_event.block_signed_at, "YYYY-MM-DD");
+        const { data } = await covalent_client.PricingService.getTokenPrices(
+            chain_name,
+            "USD",
+            log_event.sender_address,
+            {
+                from: date,
+                to: date,
+            }
+        );
+
+        const pretty_quote =
+            data?.[0]?.items?.[0]?.price *
+            (Number(decoded.value) /
+                Math.pow(
+                    10,
+                    data?.[0]?.items?.[0]?.contract_metadata
+                        ?.contract_decimals ?? 18
+                ));
+
+        return {
+            action: DECODED_ACTION.SWAPPED,
+            category: DECODED_EVENT_CATEGORY.DEX,
+            name: "Transfer",
+            protocol: {
+                logo: log_event.sender_logo_url as string,
+                name: log_event.sender_name as string,
+            },
+            details: [
+                {
+                    title: "From",
+                    value: decoded.from,
+                    type: "address",
+                },
+                {
+                    title: "To",
+                    value: decoded.to,
+                    type: "address",
+                },
+            ],
+            tokens: [
+                {
+                    decimals:
+                        data?.[0]?.items?.[0]?.contract_metadata
+                            ?.contract_decimals ?? 18,
+                    heading: "Token Amount",
+                    pretty_quote: pretty_quote
+                        ? prettifyCurrency(pretty_quote)
+                        : "",
+                    ticker_logo:
+                        data?.[0]?.items?.[0]?.contract_metadata?.logo_url,
+                    ticker_symbol:
+                        data?.[0]?.items?.[0]?.contract_metadata
+                            ?.contract_ticker_symbol,
+                    value: decoded.value.toString(),
+                },
+            ],
+        };
+    }
+);
diff --git a/services/decoder/fallbacks/transfer/transfer.test.ts b/services/decoder/fallbacks/transfer/transfer.test.ts
@@ -0,0 +1,23 @@
+import request from "supertest";
+import app from "../../../../api";
+import { type EventType } from "../../decoder.types";
+
+describe("fallback", () => {
+    test("Transfer", async () => {
+        const res = await request(app)
+            .post("/api/v1/tx/decode")
+            .set({ "x-covalent-api-key": process.env.TEST_COVALENT_API_KEY })
+            .send({
+                network: "eth-mainnet",
+                tx_hash:
+                    "0xe7b894fdac8c037fa69bbabe168fe7984033226e1b1871bd9f70c861b6f6a35d",
+            });
+        const { events } = res.body as { events: EventType[] };
+        const event = events.find(({ name }) => name === "Transfer");
+        if (!event) {
+            throw Error("Event not found");
+        }
+        expect(event.details?.length).toEqual(2);
+        expect(event.tokens?.length).toEqual(1);
+    });
+});
