Feature/scan 432 parse ethereum executed event

apps/crawler/src/config/config.module.ts

@@ -31,6 +31,8 @@ export type Config = {
   prometheusPort: number;
 
   batchSize: number;
+
+  rpcProviderUrl: string;
 };
 
 const loadConfig = (): Config => ({
@@ -59,6 +61,9 @@ const loadConfig = (): Config => ({
   prometheusPort: +process.env.PROMETHEUS_PORT || 9090,
 
   batchSize: +process.env.BATCH_SIZE || 10,
+
+  rpcProviderUrl:
+    process.env.RPC_PROVIDER_URL || 'https://rpc-opal.unique.network',
 });
 
 export const GlobalConfigModule = ConfigModule.forRoot({

apps/crawler/src/sdk/sdk.service.ts

@@ -1,5 +1,6 @@
 import { CACHE_MANAGER, Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
+import { Cache } from 'cache-manager';
 import { Client } from '@unique-nft/substrate-client';
 import {
   CollectionInfoWithSchema,

apps/crawler/src/services/event/event.service.ts

@@ -16,11 +16,13 @@ import {
 import { EventArgumentsService } from './event.arguments.service';
 import { EventArgs } from './event.types';
 import { AccountRecord } from '../account/account.types';
+import { EvmService } from '../evm/evm.service';
 
 @Injectable()
 export class EventService {
   constructor(
     private eventArgumentsService: EventArgumentsService,
+    private evmService: EvmService,
 
     @InjectRepository(Event)
     private eventsRepository: Repository<Event>,
@@ -29,7 +31,7 @@ export class EventService {
   private extractEventItems(blockItems: IBlockItem[]): IEvent[] {
     return blockItems
       .map((item) => {
-        if (item.kind == 'event') {
+        if (item.kind === 'event') {
           return item.event as IEvent;
         }
         return null;
@@ -105,6 +107,16 @@ export class EventService {
       eventItems,
     });
 
+    const ethereumEvents = eventsData.filter(
+      ({ section, method }) =>
+        section === EventSection.ETHEREUM && method === EventMethod.EXECUTED,
+    );
+
+    await this.evmService.parseEvents(
+      ethereumEvents,
+      blockCommonData.blockTimestamp,
+    );
+
     await this.eventsRepository.upsert(eventsData, [
       'block_number',
       'event_index',

apps/crawler/src/services/evm/evm.service.ts

@@ -0,0 +1,102 @@
+import { Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Event } from '@entities/Event';
+import { ethers } from 'ethers';
+import { ConfigService } from '@nestjs/config';
+import { EvmTransaction } from '@entities/EvmTransaction';
+import { SentryService } from '@ntegral/nestjs-sentry';
+import { normalizeTimestamp } from '@common/utils';
+import { Config } from '../../config/config.module';
+
+@Injectable()
+export class EvmService {
+  provider: ethers.providers.JsonRpcProvider;
+
+  constructor(
+    @InjectRepository(EvmTransaction)
+    private transactionRepository: Repository<EvmTransaction>,
+    private configService: ConfigService<Config>,
+    private readonly sentry: SentryService,
+  ) {
+    this.provider = new ethers.providers.JsonRpcProvider(
+      this.configService.get('rpcProviderUrl'),
+    );
+
+    this.sentry.setContext(EvmService.name);
+  }
+
+  public async parseEvents(events: Event[], timestamp: number) {
+    try {
+      const transactions: ethers.providers.TransactionReceipt[] = [];
+
+      for (const event of events) {
+        const [, , transactionHash] = event.data.split(',');
+        if (transactionHash && typeof transactionHash === 'string') {
+          const hash = transactionHash.replaceAll('"', '');
+
+          const transaction = await (
+            await this.provider.getTransaction(hash)
+          ).wait();
+
+          transactions.push({ ...transaction });
+        }
+      }
+
+      if (transactions.length) {
+        await this.transactionRepository.upsert(
+          this.convertForDb(transactions, timestamp),
+          ['block_hash', 'transaction_hash'],
+        );
+      }
+    } catch (error) {
+      this.sentry.instance().captureException({ error });
+    }
+  }
+
+  private convertForDb(
+    transactions: ethers.providers.TransactionReceipt[],
+    timestamp: number,
+  ) {
+    const utcTimestamp = String(normalizeTimestamp(timestamp));
+
+    return transactions.map((transaction) => {
+      const {
+        to,
+        from,
+        byzantium,
+        transactionHash,
+        confirmations,
+        cumulativeGasUsed,
+        status,
+        type,
+        blockNumber,
+        gasUsed,
+        effectiveGasPrice,
+        blockHash,
+        logsBloom,
+        transactionIndex,
+        contractAddress,
+      } = transaction;
+
+      return {
+        to,
+        from,
+        contract_address: contractAddress,
+        transaction_index: transactionIndex,
+        gas_used: gasUsed.toNumber(),
+        logs_bloom: logsBloom,
+        block_hash: blockHash,
+        transaction_hash: transactionHash,
+        block_number: blockNumber,
+        confirmations,
+        cumulative_gas_used: cumulativeGasUsed.toNumber(),
+        effective_gas_price: effectiveGasPrice.toNumber(),
+        status,
+        type,
+        byzantium,
+        timestamp: utcTimestamp,
+      };
+    });
+  }
+}

apps/crawler/src/services/services.module.ts

@@ -2,11 +2,12 @@ import { Block } from '@entities/Block';
 import { Collections } from '@entities/Collections';
 import { Tokens } from '@entities/Tokens';
 import { Event } from '@entities/Event';
+import { EvmTransaction } from '@entities/EvmTransaction';
+import { Extrinsic } from '@entities/Extrinsic';
+import { Account } from '@entities/Account';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { Extrinsic } from '@entities/Extrinsic';
-import { Account } from '@entities/Account';
 import { CollectionService } from './collection.service';
 import { AccountService } from './account/account.service';
 import { TokenService } from './token/token.service';
@@ -16,6 +17,7 @@ import { ExtrinsicService } from './extrinsic.service';
 import { EventArgumentsService } from './event/event.arguments.service';
 import { SdkModule } from '../sdk/sdk.module';
 import { TokenNestingService } from './token/nesting.service';
+import { EvmService } from './evm/evm.service';
 
 @Module({
   imports: [
@@ -26,6 +28,7 @@ import { TokenNestingService } from './token/nesting.service';
       Event,
       Extrinsic,
       Tokens,
+      EvmTransaction,
     ]),
     ConfigModule,
     SdkModule,
@@ -39,6 +42,7 @@ import { TokenNestingService } from './token/nesting.service';
     ExtrinsicService,
     TokenService,
     TokenNestingService,
+    EvmService,
   ],
   exports: [
     AccountService,
@@ -48,6 +52,7 @@ import { TokenNestingService } from './token/nesting.service';
     ExtrinsicService,
     TokenService,
     TokenNestingService,
+    EvmService,
   ],
 })
 export class ServicesModule {}

apps/web-api/src/app.module.ts

@@ -19,6 +19,7 @@ import { TransactionModule } from './transaction/transaction.module';
 import { SentryModule } from '@ntegral/nestjs-sentry';
 import { ContractModule } from './contract/contract.module';
 import { AttributesModule } from './attributes/attributes.module';
+import { EvmTransactionModule } from './evm-transactions/evm-transaction.module';
 
 @Module({
   imports: [
@@ -59,6 +60,7 @@ import { AttributesModule } from './attributes/attributes.module';
     StatisticsModule,
     TransactionModule,
     AttributesModule,
+    EvmTransactionModule,
   ],
   providers: [
     {

apps/web-api/src/event/event.service.ts

@@ -1,12 +1,11 @@
 import { Event } from '@entities/Event';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, Not, Repository, SelectQueryBuilder } from 'typeorm';
+import { Repository, SelectQueryBuilder } from 'typeorm';
+import { GraphQLResolveInfo } from 'graphql';
 import { BaseService } from '../utils/base.service';
 import { IDataListResponse, IGQLQueryArgs } from '../utils/gql-query-args';
 import { EventDTO } from './event.dto';
-import { EventMethod, EventSection } from '@common/constants';
-import { GraphQLResolveInfo } from 'graphql';
 
 const customQueryFields = {
   amount: `

apps/web-api/src/evm-transactions/evm-transaction.dto.ts

@@ -0,0 +1,53 @@
+import { Field, Float, Int, ObjectType } from '@nestjs/graphql';
+import { EvmTransaction } from '@entities/EvmTransaction';
+
+@ObjectType('evmTransaction')
+export class EvmTransactionDTO implements Partial<EvmTransaction> {
+  @Field()
+  to?: string;
+
+  @Field()
+  from?: string;
+
+  @Field({ nullable: true })
+  contract_address?: string | null;
+
+  @Field(() => Int)
+  transaction_index?: number;
+
+  @Field(() => Float)
+  gas_used?: number;
+
+  @Field()
+  logs_bloom?: string;
+
+  @Field()
+  block_hash?: string;
+
+  @Field()
+  transaction_hash?: string;
+
+  @Field(() => Int)
+  block_number?: number;
+
+  @Field(() => Int)
+  confirmations?: number;
+
+  @Field(() => Float)
+  cumulative_gas_used?: number;
+
+  @Field(() => Float)
+  effective_gas_price?: number;
+
+  @Field(() => Int)
+  status?: number;
+
+  @Field(() => Int)
+  type?: number;
+
+  @Field(() => Boolean)
+  byzantium?: boolean;
+
+  @Field(() => Int, { nullable: true })
+  timestamp?: string;
+}

apps/web-api/src/evm-transactions/evm-transaction.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { EvmTransaction } from '@entities/EvmTransaction';
+import { EvmTransactionResolver } from './evm-transaction.resolver';
+import { EvmTransactionService } from './evm-transaction.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([EvmTransaction])],
+  providers: [EvmTransactionResolver, EvmTransactionService],
+})
+export class EvmTransactionModule {}

apps/web-api/src/evm-transactions/evm-transaction.resolver.ts

@@ -0,0 +1,84 @@
+import {
+  Args,
+  ArgsType,
+  Field,
+  Info,
+  InputType,
+  ObjectType,
+  Query,
+  Resolver,
+} from '@nestjs/graphql';
+import {
+  GQLOrderByParamsArgs,
+  GQLQueryPaginationArgs,
+  GQLWhereOpsInt,
+  GQLWhereOpsString,
+  IDataListResponse,
+  IGQLQueryArgs,
+  ListDataType,
+  TOrderByParams,
+  TWhereParams,
+} from '../utils/gql-query-args';
+import { EvmTransactionDTO } from './evm-transaction.dto';
+import { EvmTransactionService } from './evm-transaction.service';
+
+@InputType()
+class EvmTransactionWhereParams implements TWhereParams<EvmTransactionDTO> {
+  @Field(() => GQLWhereOpsString, { nullable: true })
+  from?: GQLWhereOpsString;
+
+  @Field(() => GQLWhereOpsString, { nullable: true })
+  to?: GQLWhereOpsString;
+
+  @Field(() => GQLWhereOpsInt, { nullable: true })
+  block_number?: GQLWhereOpsInt;
+
+  @Field(() => GQLWhereOpsString, { nullable: true })
+  block_hash?: GQLWhereOpsString;
+
+  @Field(() => GQLWhereOpsString, { nullable: true })
+  transaction_hash?: GQLWhereOpsString;
+
+  @Field(() => [EvmTransactionWhereParams], { nullable: true })
+  _and?: EvmTransactionWhereParams[];
+
+  @Field(() => [EvmTransactionWhereParams], { nullable: true })
+  _or?: EvmTransactionWhereParams[];
+}
+
+@InputType()
+class EvmTransactionOrderByParams implements TOrderByParams<EvmTransactionDTO> {
+  @Field(() => GQLOrderByParamsArgs, { nullable: true })
+  block_number?: GQLOrderByParamsArgs;
+
+  @Field(() => GQLOrderByParamsArgs, { nullable: true })
+  timestamp?: GQLOrderByParamsArgs;
+}
+
+@ObjectType()
+class EmvTransactionDataResponse extends ListDataType(EvmTransactionDTO) {}
+
+@ArgsType()
+export class QueryArgs
+  extends GQLQueryPaginationArgs
+  implements IGQLQueryArgs<EvmTransactionDTO>
+{
+  @Field(() => EvmTransactionWhereParams, { nullable: true })
+  where?: EvmTransactionWhereParams;
+
+  @Field(() => EvmTransactionOrderByParams, { nullable: true })
+  order_by?: EvmTransactionOrderByParams;
+}
+
+@Resolver(() => EvmTransactionDTO)
+export class EvmTransactionResolver {
+  constructor(private service: EvmTransactionService) {}
+
+  @Query(() => EmvTransactionDataResponse)
+  public async evmTransactions(
+    @Args() args: QueryArgs,
+    @Info() info,
+  ): Promise<IDataListResponse<EvmTransactionDTO>> {
+    return this.service.find(args, info);
+  }
+}