feat: added validators info endpoint

fix: fixed cache refill ether parsing, fixed validators balances case

Author: Tarens2

src/http/http.constants.ts

@@ -1,6 +1,7 @@
 export const HTTP_PATHS = {
   1: {
     nft: 'nft',
+    validators: 'validators',
     'request-time': 'request-time',
     'estimate-gas': 'estimate-gas',
   },

src/http/http.module.ts

@@ -12,9 +12,10 @@ import { CacheModule, CacheControlHeadersInterceptor } from './common/cache';
 import { RequestTimeModule } from './request-time';
 import { NFTModule } from './nft';
 import { EstimateModule } from './estimate';
+import { ValidatorsModule } from './validators';
 
 @Module({
-  imports: [RequestTimeModule, NFTModule, EstimateModule, CacheModule, ThrottlerModule],
+  imports: [RequestTimeModule, NFTModule, EstimateModule, ValidatorsModule, CacheModule, ThrottlerModule],
   providers: [
     { provide: APP_GUARD, useClass: ThrottlerBehindProxyGuard },
     { provide: APP_INTERCEPTOR, useClass: CacheControlHeadersInterceptor },

src/http/validators/dto/index.ts

@@ -0,0 +1 @@
+export * from './validators.dto';

src/http/validators/dto/validators.dto.ts

@@ -0,0 +1,27 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ValidatorsDto {
+  @ApiProperty({
+    example: 1658650005,
+    description: 'ms time when data was last updated at',
+  })
+  lastUpdatedAt: number;
+
+  @ApiProperty({
+    example: 1724856617,
+    description: 'max exit epoch over all CL network',
+  })
+  maxExitEpoch: number;
+
+  @ApiProperty({
+    example: '{}',
+    description: 'sum of balances Lido validators with withdrawable_epoch by frame',
+  })
+  frameBalances: Record<string, string>;
+
+  @ApiProperty({
+    example: 100000,
+    description: 'total number of validators in network',
+  })
+  totalValidators: number;
+}

src/http/validators/index.ts

@@ -0,0 +1,3 @@
+export * from './validators.controller';
+export * from './validators.module';
+export * from './validators.service';

src/http/validators/validators.controller.ts

@@ -0,0 +1,28 @@
+import {
+  ClassSerializerInterceptor,
+  Controller,
+  Get,
+  HttpStatus,
+  UseInterceptors,
+  Version,
+  CacheTTL,
+} from '@nestjs/common';
+import { ApiResponse, ApiTags } from '@nestjs/swagger';
+import { HTTP_PATHS } from 'http/http.constants';
+import { ValidatorsService } from './validators.service';
+import { ValidatorsDto } from './dto';
+
+@Controller(HTTP_PATHS[1].validators)
+@ApiTags('Validators')
+@UseInterceptors(ClassSerializerInterceptor)
+export class ValidatorsController {
+  constructor(protected readonly validatorsService: ValidatorsService) {}
+
+  @Version('1')
+  @Get('/')
+  @CacheTTL(20 * 1000)
+  @ApiResponse({ status: HttpStatus.OK, type: ValidatorsDto })
+  async validatorsV1(): Promise<ValidatorsDto> {
+    return this.validatorsService.getAllValidatorsInfo();
+  }
+}

src/http/validators/validators.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from 'common/config';
+import { ValidatorsController } from './validators.controller';
+import { ValidatorsService } from './validators.service';
+import { ValidatorsStorageModule } from '../../storage';
+
+@Module({
+  imports: [ConfigModule, ValidatorsStorageModule],
+  controllers: [ValidatorsController],
+  providers: [ValidatorsService],
+})
+export class ValidatorsModule {}

src/http/validators/validators.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from 'common/config';
+import { ValidatorsStorageService } from '../../storage';
+
+@Injectable()
+export class ValidatorsService {
+  constructor(
+    protected readonly configService: ConfigService,
+    protected readonly validatorsServiceStorage: ValidatorsStorageService,
+  ) {}
+
+  getAllValidatorsInfo() {
+    const lastUpdatedAt = this.validatorsServiceStorage.getLastUpdate();
+    const maxExitEpoch = Number(this.validatorsServiceStorage.getMaxExitEpoch());
+    const frameBalancesBigNumber = this.validatorsServiceStorage.getFrameBalances();
+    const totalValidators = this.validatorsServiceStorage.getTotal();
+
+    const frameBalances = Object.keys(frameBalancesBigNumber).reduce((acc, item) => {
+      acc[item] = frameBalancesBigNumber[item].toString();
+      return acc;
+    }, {} as Record<string, string>);
+
+    return {
+      lastUpdatedAt,
+      maxExitEpoch,
+      frameBalances,
+      totalValidators,
+    };
+  }
+}

src/storage/validators/validators-cache.service.ts

@@ -4,7 +4,6 @@ import * as path from 'path';
 import { LOGGER_PROVIDER, LoggerService } from '../../common/logger';
 import { ValidatorsStorageService } from './validators.service';
 import { BigNumber } from '@ethersproject/bignumber';
-import { parseEther } from '@ethersproject/units';
 
 @Injectable()
 export class ValidatorsCacheService {
@@ -97,7 +96,7 @@ export class ValidatorsCacheService {
   protected parseFrameBalances(frameBalancesStr: string) {
     const frameBalances = JSON.parse(frameBalancesStr);
     return Object.keys(frameBalances).reduce((acc, key) => {
-      return { ...acc, [key]: parseEther(frameBalances[key]) };
+      return { ...acc, [key]: BigNumber.from(frameBalances[key]) };
     }, {});
   }
 }

src/waiting-time/utils/calculate-frame-by-validator-balances.ts

@@ -17,7 +17,7 @@ export const calculateFrameByValidatorBalances = (args: calculateFrameByValidato
   let lastFrame = BigNumber.from(currentFrame);
 
   const frames = Object.keys(frameBalances);
-  let result = null;
+  let result: BigNumber = null;
 
   for (let i = 0; i < frames.length; i++) {
     const frame = frames[i];
@@ -43,8 +43,9 @@ export const calculateFrameByValidatorBalances = (args: calculateFrameByValidato
   const sweepingMean = calculateSweepingMean(totalValidators).toNumber();
   const framesOfSweepingMean = Math.ceil(sweepingMean / epochPerFrame);
 
-  const resultFrame = result.add(framesOfSweepingMean).toNumber();
-
-  // If withdrawable_epoch is less than current frame, should return next frame
-  return resultFrame < currentFrame ? currentFrame + 1 : resultFrame;
+  // todo: return back previous version of calculation after rework sweeping mean
+  // If resulted withdrawable_epoch is less than current frame, should return next frame
+  result = result.lt(currentFrame) ? BigNumber.from(currentFrame) : result;
+  const resultWithSweep = result.add(framesOfSweepingMean).toNumber();
+  return resultWithSweep;
 };