feat: track additional evm transaction properties (gasUsed, gasPrice, gasLimit, value, nonce, type)

Author: kuco23

packages/fasset-indexer-core/src/indexer/eventlib/event-parser.ts

@@ -2,20 +2,10 @@ import { AgentVault } from "../../orm/entities/agent"
 import { Context } from "../../context/context"
 import type { EntityManager } from "@mikro-orm/knex"
 import type { Log } from "ethers"
-import type { Event } from "./event-scraper"
 import type { FAssetIface } from "../../shared"
+import type { Block, Transaction, Event } from "./types"
 
 
-interface Block {
-  index: number
-  timestamp: number
-}
-
-interface Transaction {
-  hash: string
-  source: string
-  target: string | null
-}
 
 export class EventParser {
   private topicToIface = new Map<string, FAssetIface>()
@@ -27,7 +17,8 @@ export class EventParser {
   }
 
   async logToEvent(log: Log): Promise<Event | null> {
-    const iface = this.topicToIface.get(log.topics[0])
+    const topic = log.topics[0]
+    const iface = this.topicToIface.get(topic)
     if (iface == null) return null
     const valid = await this.validLogSource(iface, log.address)
     if (!valid) return null
@@ -37,16 +28,12 @@ export class EventParser {
     const transaction = await this.getTransaction(log.transactionHash)
     return {
       name: parsed.name,
+      topic,
       args: parsed.args,
-      blockNumber: log.blockNumber,
-      transactionIndex: log.transactionIndex,
-      logIndex: log.index,
       source: log.address,
-      blockTimestamp: block.timestamp,
-      transactionHash: log.transactionHash,
-      transactionSource: transaction.source,
-      transactionTarget: transaction.target,
-      topic: log.topics[0]
+      index: log.index,
+      transaction: transaction,
+      block: block,
     }
   }
 
@@ -107,7 +94,7 @@ export class EventParser {
         throw new Error(`Failed to fetch block ${blockNumber}`)
       }
       this.blockCache = {
-        index: blockNumber,
+        index: block.number,
         timestamp: block.timestamp
       }
     }
@@ -117,13 +104,21 @@ export class EventParser {
   protected async getTransaction(transactionHash: string): Promise<Transaction> {
     if (this.transactionCache === null || this.transactionCache.hash !== transactionHash) {
       const transaction = await this.context.provider.getTransaction(transactionHash)
-      if (transaction === null) {
+      const receipt = await this.context.provider.getTransactionReceipt(transactionHash)
+      if (transaction == null || receipt == null) {
         throw new Error(`Failed to fetch transaction ${transactionHash}`)
       }
       this.transactionCache = {
         hash: transactionHash,
         source: transaction.from,
-        target: transaction.to
+        target: transaction.to ?? receipt.to,
+        gasUsed: receipt.gasUsed,
+        gasPrice: transaction.gasPrice,
+        gasLimit: transaction.gasLimit,
+        type: transaction.type,
+        value: transaction.value,
+        nonce: transaction.nonce,
+        index: transaction.index
       }
     }
     return this.transactionCache

packages/fasset-indexer-core/src/indexer/eventlib/event-scraper.ts

@@ -2,22 +2,6 @@ import type { Context } from "../../context/context"
 import type { Log } from "ethers"
 
 
-export type EventArgs = any
-
-export interface Event {
-  topic: string
-  name: string
-  args: EventArgs
-  blockNumber: number
-  transactionIndex: number
-  logIndex: number
-  source: string
-  blockTimestamp: number
-  transactionHash: string
-  transactionSource: string
-  transactionTarget: string | null
-}
-
 interface LogUri {
   blockNumber: number
   transactionIndex: number

packages/fasset-indexer-core/src/indexer/eventlib/event-storer.ts

@@ -7,7 +7,7 @@ import { AssetManagerEventMigration } from "./migrations/asset-manager-migration
 import { EVENTS } from '../../config/constants'
 import type { EntityManager } from "@mikro-orm/knex"
 import type { ORM } from "../../orm/interface"
-import type { Event } from "./event-scraper"
+import type { Event } from "./types"
 import type * as AssetManager from "../../../chain/typechain/assetManager/IAssetManager__latest"
 import type * as CollateralPool from "../../../chain/typechain/collateralPool/ICollateralPool__latest"
 import type * as CollateralPoolPreUpgrade  from "../../../chain/typechain/collateralPool/ICollateralPool__initial"
@@ -313,8 +313,8 @@ export class EventStorer {
   }
 
   protected async logExists(em: EntityManager, log: Event): Promise<boolean> {
-    const { blockNumber, logIndex } = log
-    const evmLog = await em.findOne(Entities.EvmLog, { index: logIndex, block: { index: blockNumber }})
+    const { block: { index: blockIndex }, index } = log
+    const evmLog = await em.findOne(Entities.EvmLog, { index, block: { index: blockIndex }})
     return evmLog !== null
   }
 
@@ -1520,19 +1520,16 @@ export class EventStorer {
   // will not persist new transactions, blocks, and events if the latter will not be successfully processed
   // we do have to persist addresses as they can be refereced during event processing
   private async createLogEntity(em: EntityManager, log: Event): Promise<Entities.EvmLog> {
-    const transactionSource = await findOrCreateEntity(em, Entities.EvmAddress, { hex: log.transactionSource })
-    const transactionTarget = log.transactionTarget === null ? undefined
-      : await findOrCreateEntity(em, Entities.EvmAddress, { hex: log.transactionTarget })
+    const source = await findOrCreateEntity(em, Entities.EvmAddress, { hex: log.transaction.source })
+    const target = log.transaction.target === null ? undefined
+      : await findOrCreateEntity(em, Entities.EvmAddress, { hex: log.transaction.target })
     const block = await findOrCreateEntity(em, Entities.EvmBlock,
-      { index: log.blockNumber }, { persist: false }, { timestamp: log.blockTimestamp })
+      { index: log.block.index }, { persist: false }, { timestamp: log.block.timestamp })
     const transaction = await findOrCreateEntity(em, Entities.EvmTransaction,
-      { hash: log.transactionHash }, { persist: false },
-      { block, index: log.transactionIndex, source: transactionSource, target: transactionTarget }
-    )
-    const eventSource = await findOrCreateEntity(em, Entities.EvmAddress, { hex: log.source })
-    return em.create(Entities.EvmLog, {
-      index: log.logIndex, name: log.name, address: eventSource, transaction, block
-    }, { persist: false })
+      { hash: log.transaction.hash }, { persist: false }, { block, ...log.transaction, source, target })
+    const address = await findOrCreateEntity(em, Entities.EvmAddress, { hex: log.source })
+    return em.create(Entities.EvmLog,
+      { index: log.index, name: log.name, address, transaction, block }, { persist: false })
   }
 
   private async changeTokenBalance(

packages/fasset-indexer-core/src/indexer/eventlib/types.ts

@@ -0,0 +1,29 @@
+export interface Block {
+  index: number
+  timestamp: number
+}
+
+export interface Transaction {
+  hash: string
+  index: number
+  source: string
+  nonce: number
+  target: string | null
+  gasUsed: bigint
+  gasPrice: bigint
+  gasLimit: bigint
+  value: bigint
+  type: number
+}
+
+export type EventArgs = any
+
+export interface Event {
+  topic: string
+  name: string
+  args: EventArgs
+  source: string
+  index: number
+  transaction: Transaction
+  block: Block
+}

packages/fasset-indexer-core/src/indexer/indexer.ts

@@ -65,9 +65,9 @@ export class EventIndexer {
     for (const log of logs) {
       const fullLog = await this.eventParser.logToEvent(log)
       if (fullLog != null) {
-        logger.info(`event indexer is processing event ${fullLog.name} (block: ${fullLog.blockNumber}, log: ${fullLog.logIndex})`)
+        logger.info(`event indexer is processing event ${fullLog.name} (block: ${fullLog.block.index}, log: ${fullLog.index})`)
         const processed = await this.stateUpdater.processEvent(fullLog)
-        logger.info(`event indexer ${processed ? 'stored' : 'skipped storing'} event (${fullLog.blockNumber}, ${fullLog.logIndex})`)
+        logger.info(`event indexer ${processed ? 'stored' : 'skipped storing'} event (${fullLog.block.index}, ${fullLog.index})`)
       }
     }
   }

packages/fasset-indexer-core/src/orm/entities/evm/transaction.ts

@@ -2,6 +2,7 @@ import { Entity, PrimaryKey, Property, Unique, ManyToOne } from "@mikro-orm/core
 import { EvmAddress } from "./address"
 import { EvmBlock } from "./block"
 import { BYTES32_LENGTH } from "../../../config/constants"
+import { uint256 } from "../../custom/uint"
 
 
 @Entity()
@@ -25,4 +26,22 @@ export class EvmTransaction {
 
   @ManyToOne({ entity: () => EvmAddress, nullable: true })
   target?: EvmAddress
+
+  @Property({ type: new uint256(), nullable: true })
+  value!: bigint
+
+  @Property({ type: new uint256(), nullable: true })
+  gasUsed!: bigint
+
+  @Property({ type: new uint256(), nullable: true })
+  gasPrice!: bigint
+
+  @Property({ type: new uint256(), nullable: true })
+  gasLimit!: bigint
+
+  @Property({ type: 'number', nullable: true })
+  type!: number
+
+  @Property({ type: 'number', nullable: true })
+  nonce!: number
 }