chore: Improves performance and adds synthetic transaction support to getBlockReceipts (#3758)

Signed-off-by: Konstantina Blazhukova <[email protected]>

Author: konstantinabl

packages/relay/package.json

@@ -29,6 +29,7 @@
     "test": "nyc ts-mocha --recursive './tests/**/*.spec.ts' './tests/**/**/*.spec.ts' --exit",
     "test-eth": "nyc ts-mocha --recursive './tests/lib/eth/**/*.spec.ts' --exit",
     "test:eth-get-block-by-number": "nyc ts-mocha --recursive './tests/**/*.spec.ts' './tests/**/**/*.spec.ts' -g '@ethGetBlockByNumber' --exit",
+    "test:eth-get-block-receipts": "nyc ts-mocha --recursive './tests/**/*.spec.ts' './tests/**/**/*.spec.ts' -g '@ethGetBlockReceipts' --exit",
     "test:eth-get-block-by-hash": "nyc ts-mocha --recursive './tests/**/*.spec.ts' './tests/**/**/*.spec.ts' -g '@ethGetBlockByHash' --exit",
     "test:eth-get-block-transaction-count-by-number": "nyc ts-mocha --recursive './tests/**/*.spec.ts' './tests/**/**/*.spec.ts' -g '@ethGetBlockTransactionCountByNumber' --exit",
     "test:eth-get-block-transaction-count-by-hash": "nyc ts-mocha --recursive './tests/**/*.spec.ts' './tests/**/**/*.spec.ts' -g '@ethGetBlockTransactionCountByHash' --exit",

packages/relay/src/index.ts

@@ -11,6 +11,7 @@ import {
   IGetLogsParams,
   INewFilterParams,
   ITracerConfig,
+  ITransactionReceipt,
   RequestDetails,
 } from './lib/types';
 
@@ -70,7 +71,7 @@ export interface Eth {
 
   getBalance(account: string, blockNumber: string | null, requestDetails: RequestDetails): Promise<string>;
 
-  getBlockReceipts(blockHashOrNumber: string, requestDetails: RequestDetails): Promise<Receipt[]>;
+  getBlockReceipts(blockHashOrNumber: string, requestDetails: RequestDetails): Promise<ITransactionReceipt[]>;
 
   getBlockByHash(hash: string, showDetails: boolean, requestDetails: RequestDetails): Promise<Block | null>;
 

packages/relay/src/lib/eth.ts

@@ -26,7 +26,14 @@ import { FeeService } from './services/ethService/feeService/FeeService';
 import { IFeeService } from './services/ethService/feeService/IFeeService';
 import { ITransactionService } from './services/ethService/transactionService/ITransactionService';
 import HAPIService from './services/hapiService/hapiService';
-import { IContractCallRequest, IFeeHistory, IGetLogsParams, INewFilterParams, RequestDetails } from './types';
+import {
+  IContractCallRequest,
+  IFeeHistory,
+  IGetLogsParams,
+  INewFilterParams,
+  ITransactionReceipt,
+  RequestDetails,
+} from './types';
 import { ParamType } from './types/validation';
 
 /**
@@ -125,7 +132,7 @@ export class EthImpl implements Eth {
     this.feeService = new FeeService(mirrorNodeClient, this.common, logger);
     this.contractService = new ContractService(cacheService, this.common, hapiService, logger, mirrorNodeClient);
     this.accountService = new AccountService(cacheService, this.common, logger, mirrorNodeClient);
-    this.blockService = new BlockService(chain, this.common, mirrorNodeClient, logger);
+    this.blockService = new BlockService(cacheService, chain, this.common, mirrorNodeClient, logger);
     this.eventEmitter = eventEmitter;
     this.transactionService = new TransactionService(
       cacheService,
@@ -1110,7 +1117,10 @@ export class EthImpl implements Eth {
   @cache(CacheService.getInstance(CACHE_LEVEL.L1), {
     skipParams: [{ index: '0', value: constants.NON_CACHABLE_BLOCK_PARAMS }],
   })
-  public async getBlockReceipts(blockHashOrBlockNumber: string, requestDetails: RequestDetails): Promise<Receipt[]> {
+  public async getBlockReceipts(
+    blockHashOrBlockNumber: string,
+    requestDetails: RequestDetails,
+  ): Promise<ITransactionReceipt[]> {
     return await this.blockService.getBlockReceipts(blockHashOrBlockNumber, requestDetails);
   }
 

packages/relay/src/lib/services/ethService/blockService/BlockService.ts

@@ -3,20 +3,30 @@ import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services'
 import _ from 'lodash';
 import { Logger } from 'pino';
 
-import { nanOrNumberTo0x, nullableNumberTo0x, numberTo0x, toHash32 } from '../../../../formatters';
+import { nanOrNumberTo0x, numberTo0x } from '../../../../formatters';
 import { IReceiptRootHash, ReceiptsRootUtils } from '../../../../receiptsRootUtils';
 import { Utils } from '../../../../utils';
 import { MirrorNodeClient } from '../../../clients/mirrorNodeClient';
 import constants from '../../../constants';
 import { predefined } from '../../../errors/JsonRpcError';
 import { BlockFactory } from '../../../factories/blockFactory';
 import { TransactionFactory } from '../../../factories/transactionFactory';
-import { Block, Log, Receipt, Transaction } from '../../../model';
-import { IContractResultsParams, MirrorNodeBlock, RequestDetails } from '../../../types';
+import {
+  IRegularTransactionReceiptParams,
+  TransactionReceiptFactory,
+} from '../../../factories/transactionReceiptFactory';
+import { Block, Log, Transaction } from '../../../model';
+import { IContractResultsParams, ITransactionReceipt, MirrorNodeBlock, RequestDetails } from '../../../types';
+import { CacheService } from '../../cacheService/cacheService';
 import { IBlockService, ICommonService } from '../../index';
 import { CommonService } from '../ethCommonService/CommonService';
-
 export class BlockService implements IBlockService {
+  /**
+   * The cache service used for caching all responses.
+   * @private
+   */
+  private readonly cacheService: CacheService;
+
   /**
    * The chain id.
    * @private
@@ -47,7 +57,14 @@ export class BlockService implements IBlockService {
   private readonly mirrorNodeClient: MirrorNodeClient;
 
   /** Constructor */
-  constructor(chain: string, common: ICommonService, mirrorNodeClient: MirrorNodeClient, logger: Logger) {
+  constructor(
+    cacheService: CacheService,
+    chain: string,
+    common: ICommonService,
+    mirrorNodeClient: MirrorNodeClient,
+    logger: Logger,
+  ) {
+    this.cacheService = cacheService;
     this.chain = chain;
     this.common = common;
     this.mirrorNodeClient = mirrorNodeClient;
@@ -106,13 +123,28 @@ export class BlockService implements IBlockService {
    * @param {RequestDetails} requestDetails The request details for logging and tracking
    * @returns {Promise<Receipt[]>} Array of transaction receipts for the block
    */
-  public async getBlockReceipts(blockHashOrBlockNumber: string, requestDetails: RequestDetails): Promise<Receipt[]> {
+  public async getBlockReceipts(
+    blockHashOrBlockNumber: string,
+    requestDetails: RequestDetails,
+  ): Promise<ITransactionReceipt[]> {
     const requestIdPrefix = requestDetails.formattedRequestId;
     if (this.logger.isLevelEnabled('trace')) {
       this.logger.trace(`${requestIdPrefix} getBlockReceipt(${JSON.stringify(blockHashOrBlockNumber)})`);
     }
 
     const block = await this.common.getHistoricalBlockResponse(requestDetails, blockHashOrBlockNumber);
+
+    if (block == null) {
+      throw predefined.RESOURCE_NOT_FOUND(`Block: ${blockHashOrBlockNumber}`);
+    }
+
+    const blockNumber = block.number;
+    const cacheKey = `${constants.CACHE_KEY.ETH_GET_BLOCK_RECEIPTS}_${blockNumber}`;
+    const cachedResponse = await this.cacheService.getAsync(cacheKey, constants.ETH_GET_BLOCK_RECEIPTS, requestDetails);
+    if (cachedResponse) {
+      return cachedResponse;
+    }
+
     const paramTimestamp: IContractResultsParams = {
       timestamp: [`lte:${block.timestamp.to}`, `gte:${block.timestamp.from}`],
     };
@@ -122,39 +154,56 @@ export class BlockService implements IBlockService {
       return [];
     }
 
-    const effectiveGas = await this.common.getCurrentGasPriceForBlock(block.hash, requestDetails);
+    const receipts: ITransactionReceipt[] = [];
+    const effectiveGas = numberTo0x(await this.common.getGasPriceInWeibars(block.timestamp.from.split('.')[0]));
 
     const logs = await this.common.getLogsWithParams(null, paramTimestamp, requestDetails);
-    contractResults.forEach((contractResult) => {
-      contractResult.logs = logs.filter((log) => log.transactionHash === contractResult.hash);
-    });
 
-    const receipts: Receipt[] = [];
+    const logsByHash = new Map<string, Log[]>();
+    for (const log of logs) {
+      const existingLogs = logsByHash.get(log.transactionHash) || [];
+      existingLogs.push(log);
+      logsByHash.set(log.transactionHash, existingLogs);
+    }
 
-    for (const contractResult of contractResults) {
-      const from = await this.common.resolveEvmAddress(contractResult.from, requestDetails);
-      const to = await this.common.resolveEvmAddress(contractResult.to, requestDetails);
-
-      const contractAddress = this.common.getContractAddressFromReceipt(contractResult);
-      const receipt = {
-        blockHash: toHash32(contractResult.block_hash),
-        blockNumber: numberTo0x(contractResult.block_number),
-        from: from,
-        to: to,
-        cumulativeGasUsed: numberTo0x(contractResult.block_gas_used),
-        gasUsed: nanOrNumberTo0x(contractResult.gas_used),
-        contractAddress: contractAddress,
+    const receiptPromises = contractResults.map(async (contractResult) => {
+      if (Utils.isRevertedDueToHederaSpecificValidation(contractResult)) {
+        if (this.logger.isLevelEnabled('debug')) {
+          this.logger.debug(
+            `${requestIdPrefix} Transaction with hash ${contractResult.hash} is skipped due to hedera-specific validation failure (${contractResult.result})`,
+          );
+        }
+        return null;
+      }
+      contractResult.logs = logsByHash.get(contractResult.hash) || [];
+      const [from, to] = await Promise.all([
+        this.common.resolveEvmAddress(contractResult.from, requestDetails),
+        this.common.resolveEvmAddress(contractResult.to, requestDetails),
+      ]);
+      const transactionReceiptParams: IRegularTransactionReceiptParams = {
+        effectiveGas,
+        from,
         logs: contractResult.logs,
-        logsBloom: contractResult.bloom === constants.EMPTY_HEX ? constants.EMPTY_BLOOM : contractResult.bloom,
-        transactionHash: toHash32(contractResult.hash),
-        transactionIndex: numberTo0x(contractResult.transaction_index),
-        effectiveGasPrice: effectiveGas,
-        root: contractResult.root || constants.DEFAULT_ROOT_HASH,
-        status: contractResult.status,
-        type: nullableNumberTo0x(contractResult.type),
+        receiptResponse: contractResult,
+        to,
       };
+      return TransactionReceiptFactory.createRegularReceipt(transactionReceiptParams) as ITransactionReceipt;
+    });
+
+    const resolvedReceipts = await Promise.all(receiptPromises);
+    receipts.push(...resolvedReceipts.filter(Boolean));
 
-      receipts.push(receipt);
+    const regularTxHashes = new Set(contractResults.map((result) => result.hash));
+
+    // filtering out the synthetic tx hashes and creating the synthetic receipt
+    for (const [txHash, logGroup] of logsByHash.entries()) {
+      if (!regularTxHashes.has(txHash)) {
+        const syntheticReceipt = TransactionReceiptFactory.createSyntheticReceipt({
+          syntheticLogs: logGroup,
+          gasPriceForTimestamp: effectiveGas,
+        });
+        receipts.push(syntheticReceipt as ITransactionReceipt);
+      }
     }
 
     return receipts;

packages/relay/src/lib/services/ethService/blockService/IBlockService.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
-import { Block, Receipt } from '../../../model';
-import { RequestDetails } from '../../../types';
+import { Block } from '../../../model';
+import { ITransactionReceipt, RequestDetails } from '../../../types';
 
 export interface IBlockService {
   getBlockByNumber: (
@@ -12,7 +12,7 @@ export interface IBlockService {
   getBlockByHash: (hash: string, showDetails: boolean, requestDetails: RequestDetails) => Promise<Block | null>;
   getBlockTransactionCountByHash: (hash: string, requestDetails: RequestDetails) => Promise<string | null>;
   getBlockTransactionCountByNumber: (blockNum: string, requestDetails: RequestDetails) => Promise<string | null>;
-  getBlockReceipts: (blockHash: string, requestDetails: RequestDetails) => Promise<Receipt[]>;
+  getBlockReceipts: (blockHash: string, requestDetails: RequestDetails) => Promise<ITransactionReceipt[]>;
   getUncleByBlockHashAndIndex: (requestDetails: RequestDetails) => Promise<null>;
   getUncleByBlockNumberAndIndex: (requestDetails: RequestDetails) => Promise<null>;
   getUncleCountByBlockHash: (requestDetails: RequestDetails) => Promise<string>;

packages/relay/tests/assertions.ts

@@ -24,6 +24,7 @@ export default class RelayAssertions {
         if (!checkMessage) {
           return err.code === error.code;
         }
+
         return err.code === error.code && err.message === error.message;
       },
     );