test: generate a expectedTransformData.json (#1329)

* feat: generate expectedTransformData.json and fix test

* fix: comment

* fix: fmt

* fix: comment and hardcoded path

* fix: testConstant

indexer/src/testConstants.ts

@@ -0,0 +1,7 @@
+// Path to the JSON file containing real transaction data
+export const TRANSACTIONS_DATA_FILE =
+  "indexer/src/test-data/transactionsData.json";
+
+// Path to the JSON file containing the expected data trasformed with transform function and toTypedEthTx
+export const EXPECTED_TRANSFORM_DATA_FILE =
+  "indexer/src/test-data/expectedTransformData.json";

indexer/src/transform.test.ts

@@ -24,11 +24,22 @@ import {
   TypedTransaction,
 } from "./deps.ts";
 import { JsonRpcReceipt } from "./types/receipt.ts";
+import {
+  EXPECTED_TRANSFORM_DATA_FILE,
+  TRANSACTIONS_DATA_FILE,
+} from "./testConstants.ts";
+
+// Transaction data including headers, events, and transactions
+const jsonTransactionsData = await Deno.readTextFile(
+  TRANSACTIONS_DATA_FILE,
+);
+const transactionsData = JSON.parse(jsonTransactionsData);
 
-const jsonData = await Deno.readTextFile(
-  "indexer/src/test-data/transactionsData.json",
+// Expected output after transform and toTypedEthTx transformation for comparison in tests
+const jsonExpectedTransformData = await Deno.readTextFile(
+  EXPECTED_TRANSFORM_DATA_FILE,
 );
-const transactionsData = JSON.parse(jsonData);
+const expectedTransformData = JSON.parse(jsonExpectedTransformData);
 
 function assertHasHeader(data: any): asserts data is { header: JsonRpcBlock } {
   if (!data || typeof data.header === "undefined") {
@@ -616,13 +627,17 @@ Deno.test("transform with real data", async () => {
     const header = headersList[i];
     const events = eventsList[i];
     const transactions = transactionsList[i];
+    const expectedTransformedData = expectedTransformData.expectedTransform[i];
 
     const result = await transform({
       header: header,
       events: events,
       transactions: transactions,
     });
 
-    assertExists(result);
+    assertEquals(
+      JSON.stringify(result),
+      JSON.stringify(expectedTransformedData),
+    );
   }
 });

indexer/src/types/transaction.test.ts

@@ -24,11 +24,22 @@ import {
 import { assertEquals } from "https://deno.land/[email protected]/assert/assert_equals.ts";
 import { Common } from "https://esm.sh/v135/@ethereumjs/[email protected]/denonext/common.mjs";
 import { ExtendedJsonRpcTx } from "./interfaces.ts";
+import {
+  EXPECTED_TRANSFORM_DATA_FILE,
+  TRANSACTIONS_DATA_FILE,
+} from "../testConstants.ts";
+
+// Transaction data including headers, events, and transactions
+const jsonTransactionsData = await Deno.readTextFile(
+  TRANSACTIONS_DATA_FILE,
+);
+const transactionsData = JSON.parse(jsonTransactionsData);
 
-const jsonData = await Deno.readTextFile(
-  "indexer/src/test-data/transactionsData.json",
+// Expected output after transform and toTypedEthTx transformation for comparison in tests
+const jsonExpectedTransformData = await Deno.readTextFile(
+  EXPECTED_TRANSFORM_DATA_FILE,
 );
-const transactionsData = JSON.parse(jsonData);
+const expectedTransformData = JSON.parse(jsonExpectedTransformData);
 
 // Utility functions
 function createReceipt(
@@ -551,11 +562,19 @@ Deno.test("toTypedEthTx EIP2930 Transaction before release with 31 bytes chunks
 
 Deno.test("toTypedEthTx with real data", () => {
   transactionsData.transactionsList.forEach(
-    (transactions: TransactionWithReceipt[]) => {
-      const ethTx = toTypedEthTx({
-        transaction: transactions[0].transaction,
-      }) as LegacyTransaction;
-      assertExists(ethTx);
+    (transactions: TransactionWithReceipt[], outerIndex: number) => {
+      transactions.map((transaction, innerIndex) => {
+        const ethTx = toTypedEthTx({
+          transaction: transaction.transaction,
+        });
+        assertEquals(
+          JSON.stringify(ethTx),
+          JSON.stringify(
+            expectedTransformData
+              .expectedToTypedEthTxTransactions[outerIndex][innerIndex],
+          ),
+        );
+      });
     },
   );
 });

scripts/fetchKakarotTx.ts

@@ -4,30 +4,45 @@ import {
   Event,
   EventWithTransaction,
   PrefixedHexString,
+  Transaction,
   TransactionWithReceipt,
 } from "../indexer/src/deps.ts";
 import { TRANSACTION_EXECUTED } from "../indexer/src/constants.ts";
+import {
+  EXPECTED_TRANSFORM_DATA_FILE,
+  TRANSACTIONS_DATA_FILE,
+} from "../indexer/src/testConstants.ts";
 import { padString } from "../indexer/src/utils/hex.ts";
+import transform from "../indexer/src/main.ts";
+import { toTypedEthTx } from "../indexer/src/types/transaction.ts";
 
+// Initialize the provider with the specified node URL
 const provider = new RpcProvider({
   nodeUrl: "https://juno-kakarot-dev.karnot.xyz/",
 });
 
+// Function to fetch a block by its number
 async function fetchBlock(blockNumber: number) {
   const block = await provider.getBlock(blockNumber);
   return block;
 }
+
+// Function to collect transactions until a target count is reached
 async function collectTransactions(targetCount: number) {
   const transactionsList: any[] = [];
   const eventsList: any[] = [];
   const headersList: any[] = [];
+  const expectedTransform: any[] = [];
   let header: BlockHeader = {} as BlockHeader;
   let transactions: TransactionWithReceipt[] = [];
   let events: EventWithTransaction[] = [];
+  let expectedToTypedEthTxTransactions: Transaction[] = [];
 
+  // Fetch the latest block to start the process
   let blockObj = await provider.getBlock("latest");
   let blockNumber = blockObj.block_number;
 
+  // Loop to collect transactions until the target count is met
   while (transactionsList.length < targetCount) {
     const block = await fetchBlock(blockNumber);
     console.log(
@@ -39,6 +54,8 @@ async function collectTransactions(targetCount: number) {
     let getTransaction = await Promise.all(
       block.transactions.map((tx) => provider.getTransaction(tx)),
     );
+
+    // Combine transaction data with receipts
     let transactionReceipts = getTransaction.map((tx) => {
       let receipt = getTransactionReceipts.find((r) =>
         "transaction_hash" in tx && r.transaction_hash === tx.transaction_hash
@@ -48,27 +65,46 @@ async function collectTransactions(targetCount: number) {
 
     blockNumber -= 1;
 
+    // Transform block header and transactions
     header = transformBlockHeader(block);
-    const transformationResult = transformTransactionsAndEvents(
+    const {
+      transformedTransactions,
+      eventsWithTransaction,
+      toTypedEthTxTransaction,
+    } = transformTransactionsAndEvents(
       transactionReceipts,
     );
-    transactions = transformationResult.transformedTransactions;
-    events = transformationResult.eventsWithTransaction;
+    transactions = transformedTransactions;
+    events = eventsWithTransaction;
+
+    // Transform the data for storage or further processing
+    const transforResult = await transform({ header, events, transactions });
 
+    // Add the collected data to the respective lists
     transactionsList.push(transactions);
     headersList.push(header);
     eventsList.push(events);
+    expectedTransform.push(transforResult);
+    expectedToTypedEthTxTransactions.push(toTypedEthTxTransaction);
 
+    // Check if the genesis block is reached
     if (blockNumber < 0) {
       throw new Error(
         "Reached genesis block without collecting enough transactions.",
       );
     }
   }
 
-  return { headersList, eventsList, transactionsList };
+  return {
+    headersList,
+    eventsList,
+    transactionsList,
+    expectedTransform,
+    expectedToTypedEthTxTransactions,
+  };
 }
 
+// Function to transform block header data into the desired format
 function transformBlockHeader(block: any): BlockHeader {
   return {
     blockNumber: block.block_number,
@@ -80,15 +116,19 @@ function transformBlockHeader(block: any): BlockHeader {
   };
 }
 
+// Function to transform transactions and events
 function transformTransactionsAndEvents(
   transactions: any[],
 ): {
   transformedTransactions: TransactionWithReceipt[];
   eventsWithTransaction: EventWithTransaction[];
+  toTypedEthTxTransaction: Transaction[];
 } {
   const transformedTransactions: TransactionWithReceipt[] = [];
   const eventsWithTransaction: EventWithTransaction[] = [];
+  const toTypedEthTxTransaction: Transaction[] = [];
 
+  // Iterate through each transaction to transform it and extract events
   transactions.forEach((tx: any, txIndex: number) => {
     const transaction = {
       meta: {
@@ -104,6 +144,9 @@ function transformTransactionsAndEvents(
       },
     };
 
+    // Convert to typed Ethereum transaction
+    const typedEthTx = toTypedEthTx({ transaction });
+
     const receipt = {
       executionStatus: tx.execution_status,
       transactionHash: tx.transaction_hash,
@@ -120,11 +163,15 @@ function transformTransactionsAndEvents(
         })),
     };
 
+    // Add the transformed transaction and receipt to the list
     transformedTransactions.push({
       transaction,
       receipt,
     });
 
+    toTypedEthTxTransaction.push(typedEthTx);
+
+    // Extract events related to the transaction
     tx.events.forEach((ev: any, eventIndex: number) => {
       if (ev.keys[0] === TRANSACTION_EXECUTED) {
         const event: Event = {
@@ -139,20 +186,44 @@ function transformTransactionsAndEvents(
     });
   });
 
-  return { transformedTransactions, eventsWithTransaction };
+  return {
+    transformedTransactions,
+    eventsWithTransaction,
+    toTypedEthTxTransaction,
+  };
 }
+
 async function main() {
   try {
     const targetCount = 100;
-    const transactions = await collectTransactions(targetCount);
-
+    const {
+      headersList,
+      eventsList,
+      transactionsList,
+      expectedTransform,
+      expectedToTypedEthTxTransactions,
+    } = await collectTransactions(targetCount);
+
+    // Save the collected transactions to a file
     await Deno.writeTextFile(
-      "indexer/src/test-data/transactionsData.json",
-      JSON.stringify(transactions, null, 2),
+      TRANSACTIONS_DATA_FILE,
+      JSON.stringify({ headersList, eventsList, transactionsList }, null, 2),
     );
     console.log("Transactions saved to transactions.json");
+
+    // Save the expected transformed data to a file
+    await Deno.writeTextFile(
+      EXPECTED_TRANSFORM_DATA_FILE,
+      JSON.stringify(
+        { expectedTransform, expectedToTypedEthTxTransactions },
+        null,
+        2,
+      ),
+    );
+    console.log("Expected data saved to expectedTransformData.json");
   } catch (error) {
     console.error("Error collecting transactions:", error);
   }
 }
+
 await main();