feat: added retrie and block by step fetch log

Author: Tarens2

src/common/config/env.validation.ts

@@ -96,6 +96,14 @@ export class EnvironmentVariables {
   @Transform(({ value }) => value === 'true')
   @IsBoolean()
   IS_SERVICE_UNAVAILABLE = false;
+
+  @IsOptional()
+  @IsNumber()
+  EL_RETRY_COUNT = 2;
+
+  @IsOptional()
+  @IsNumber()
+  EL_BLOCK_STEP = 500;
 }
 export const ENV_KEYS = Object.keys(new EnvironmentVariables());
 

src/common/execution-provider/execution-provider.service.ts

@@ -1,16 +1,20 @@
 import { SimpleFallbackJsonRpcBatchProvider } from '@lido-nestjs/execution';
 import { CHAINS } from '@lido-nestjs/constants';
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { ethers } from 'ethers';
 import { ConfigService } from '@nestjs/config';
 import { PrometheusService } from '../prometheus';
+import { Filter, Log } from '@ethersproject/abstract-provider';
+import { LoggerService } from '@lido-nestjs/logger';
+import { LOGGER_PROVIDER } from '../logger';
 
 @Injectable()
 export class ExecutionProviderService {
   constructor(
     protected readonly provider: SimpleFallbackJsonRpcBatchProvider,
     protected readonly prometheusService: PrometheusService,
     protected readonly configService: ConfigService,
+    @Inject(LOGGER_PROVIDER) protected readonly logger: LoggerService,
   ) {}
 
   /**
@@ -44,4 +48,52 @@ export class ExecutionProviderService {
       throw error;
     }
   }
+
+  public async getLogsByBlockStepsWithRetry(
+    filter: Filter,
+    eventName: string,
+    serviceName: string,
+    retryCount = this.configService.get('EL_RETRY_COUNT'),
+    blockStep = this.configService.get('EL_BLOCK_STEP'),
+  ): Promise<Log[]> {
+    let logs: Log[] = [];
+    const latestBlock = await this.provider.getBlockNumber();
+
+    const fromBlock = Number(filter.fromBlock) ?? 0;
+    const toBlock = typeof filter.toBlock === 'string' ? latestBlock : Number(filter.toBlock);
+
+    for (let startBlock = fromBlock; startBlock <= toBlock; startBlock += blockStep) {
+      const endBlock = Math.min(startBlock + blockStep - 1, toBlock);
+
+      const blockFilter = { ...filter, fromBlock: startBlock, toBlock: endBlock };
+
+      let attempt = 0;
+      let blockLogs: Log[] = [];
+
+      while (blockLogs.length === 0 && attempt < retryCount) {
+        try {
+          blockLogs = await this.provider.getLogs(blockFilter);
+        } catch (error) {
+          this.logger.error(`${eventName}: Error fetching logs for blocks ${startBlock} - ${endBlock}: ${error}`, {
+            service: serviceName,
+          });
+        }
+
+        if (blockLogs.length === 0) {
+          this.logger.warn(
+            `${eventName}: No logs found for blocks ${startBlock} - ${endBlock}. Retrying in 200 ms...`,
+            {
+              service: serviceName,
+            },
+          );
+          await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        attempt += 1;
+      }
+
+      logs = logs.concat(blockLogs);
+    }
+
+    return logs;
+  }
 }

src/common/sweep/sweep.service.ts

@@ -121,7 +121,6 @@ export class SweepService {
       pendingPartialWithdrawalsNumber,
       pendingPartialWithdrawalsMaxNumberInCycle,
     );
-
     return validatorsWithdrawalsNumber + pendingPartialWithdrawalsNumberInCycle;
   }
 

src/events/rewards/rewards.service.ts

@@ -21,8 +21,7 @@ import { LOGGER_PROVIDER, LoggerService } from '../../common/logger';
 import { ConfigService } from '../../common/config';
 import { ContractConfigStorageService, RewardsStorageService } from '../../storage';
 import { PrometheusService } from '../../common/prometheus';
-
-import { getLogsByRetryCount } from './rewards.utils';
+import { ExecutionProviderService } from '../../common/execution-provider';
 
 @Injectable()
 export class RewardsService {
@@ -37,6 +36,7 @@ export class RewardsService {
     protected readonly contractConfig: ContractConfigStorageService,
     protected readonly configService: ConfigService,
     protected readonly provider: SimpleFallbackJsonRpcBatchProvider,
+    protected readonly executionProvider: ExecutionProviderService,
   ) {}
 
   /**
@@ -147,12 +147,17 @@ export class RewardsService {
 
   protected async getElRewards(fromBlock: number): Promise<BigNumber> {
     const res = this.contractLido.filters.ELRewardsReceived();
-    const logs = await this.provider.getLogs({
-      topics: res.topics,
-      toBlock: 'latest',
-      fromBlock,
-      address: res.address,
-    });
+
+    const logs = await this.executionProvider.getLogsByBlockStepsWithRetry(
+      {
+        topics: res.topics,
+        toBlock: 'latest',
+        fromBlock,
+        address: res.address,
+      },
+      'ELRewardsReceived',
+      RewardsService.SERVICE_LOG_NAME,
+    );
     const lastLog = logs[0];
 
     if (!lastLog) {
@@ -170,16 +175,15 @@ export class RewardsService {
     postCLBalance: BigNumber;
   }> {
     const res = this.contractLido.filters.ETHDistributed();
-    const logs = await getLogsByRetryCount(
-      this.provider,
+    const logs = await this.executionProvider.getLogsByBlockStepsWithRetry(
       {
         topics: res.topics,
         toBlock: 'latest',
         fromBlock,
         address: res.address,
       },
-      this.logger,
       'ETHDistributed',
+      RewardsService.SERVICE_LOG_NAME,
     );
 
     this.logger.log('ETHDistributed event logs', { service: RewardsService.SERVICE_LOG_NAME, logsCount: logs.length });
@@ -216,16 +220,15 @@ export class RewardsService {
 
   protected async getWithdrawalsReceived(fromBlock: number): Promise<BigNumber> {
     const res = this.contractLido.filters.WithdrawalsReceived();
-    const logs = await getLogsByRetryCount(
-      this.provider,
+    const logs = await this.executionProvider.getLogsByBlockStepsWithRetry(
       {
         topics: res.topics,
         toBlock: 'latest',
         fromBlock,
         address: res.address,
       },
-      this.logger,
       'WithdrawalsReceived',
+      RewardsService.SERVICE_LOG_NAME,
     );
 
     this.logger.log('WithdrawalsReceived event logs', {
@@ -256,16 +259,15 @@ export class RewardsService {
 
     const res = this.contractLido.filters.TokenRebased();
 
-    const logs = await getLogsByRetryCount(
-      this.provider,
+    const logs = await this.executionProvider.getLogsByBlockStepsWithRetry(
       {
         topics: res.topics,
         toBlock: 'latest',
         fromBlock: weekAgoBlock,
         address: res.address,
       },
-      this.logger,
       'TokenRebased',
+      RewardsService.SERVICE_LOG_NAME,
     );
 
     this.logger.log('TokenRebase event logs for last week', {