feat: added JSON devnet config

Author: Tarens2

devnet-configs/devnet.example.json

@@ -0,0 +1,10 @@
+{
+  "name":"devnet-example",
+  "WithdrawalQueue": "0x0..",
+  "Lido": "0x0..",
+  "OracleReportSanityChecker": "0x0..",
+  "AccountingOracleHashConsensus": "0x0..",
+  "ValidatorsExitBusOracleHashConsensus": "0x0..",
+  "LidoLocator": "0x0..",
+  "KeysApiBasePath": ""
+}

src/common/config/config.service.ts

@@ -1,5 +1,4 @@
 import { ConfigService as ConfigServiceSource } from '@nestjs/config';
-import { EnvironmentVariables } from './env.validation';
 import {
   AccountingOracleHashConsensusModule,
   LidoContractModule,
@@ -8,8 +7,9 @@ import {
   ValidatorsExitBusOracleHashConsensusModule,
   WithdrawalQueueContractModule,
 } from '@lido-nestjs/contracts';
-import { devnetConfigs } from './devnets/configs';
-import { DevnetName } from './devnets/devnet-config.interface';
+import { EnvironmentVariables } from './env.validation';
+import { findDevnetConfig } from './utils/find-devnet-config';
+import { KEYS_API_PATHS } from '../../jobs/validators/lido-keys/lido-keys.constants';
 
 export class ConfigService extends ConfigServiceSource<EnvironmentVariables> {
   /**
@@ -29,28 +29,45 @@ export class ConfigService extends ConfigServiceSource<EnvironmentVariables> {
     return super.get(key, { infer: true }) as EnvironmentVariables[T];
   }
 
-  public getCustomConfigContractsAddressMap() {
-    if (!this.get('DEVNET_NAME')) {
+  public async getCustomConfigContractsAddressMap() {
+    const name = this.get('DEVNET_NAME');
+
+    if (!name) {
       return null;
     }
 
+    const devnetConfig = await findDevnetConfig(name);
+
     return new Map<symbol, string>([
-      [WithdrawalQueueContractModule.contractToken, devnetConfigs[DevnetName.Devnet8].contracts['WithdrawalQueue']],
-
-      [LidoContractModule.contractToken, devnetConfigs[DevnetName.Devnet8].contracts['Lido']],
-      [
-        OracleReportSanityCheckerModule.contractToken,
-        devnetConfigs[DevnetName.Devnet8].contracts['OracleReportSanityChecker'],
-      ],
-      [
-        AccountingOracleHashConsensusModule.contractToken,
-        devnetConfigs[DevnetName.Devnet8].contracts['AccountingOracleHashConsensus'],
-      ],
-      [
-        ValidatorsExitBusOracleHashConsensusModule.contractToken,
-        devnetConfigs[DevnetName.Devnet8].contracts['ValidatorsExitBusOracleHashConsensus'],
-      ],
-      [LidoLocatorContractModule.contractToken, devnetConfigs[DevnetName.Devnet8].contracts['LidoLocator']],
+      [WithdrawalQueueContractModule.contractToken, devnetConfig['WithdrawalQueue']],
+
+      [LidoContractModule.contractToken, devnetConfig['Lido']],
+      [OracleReportSanityCheckerModule.contractToken, devnetConfig['OracleReportSanityChecker']],
+      [AccountingOracleHashConsensusModule.contractToken, devnetConfig['AccountingOracleHashConsensus']],
+      [ValidatorsExitBusOracleHashConsensusModule.contractToken, devnetConfig['ValidatorsExitBusOracleHashConsensus']],
+      [LidoLocatorContractModule.contractToken, devnetConfig['LidoLocator']],
     ]);
   }
+
+  public async getKeysApiBasePath(): Promise<string> {
+    const name = this.get('DEVNET_NAME');
+
+    if (name) {
+      const devnetConfig = await findDevnetConfig(name);
+      const keysApiBasePath = devnetConfig['KeysApiBasePath'];
+
+      if (keysApiBasePath) {
+        return keysApiBasePath;
+      }
+    }
+
+    const envUrl = this.get('KEYS_API_BASE_PATH');
+
+    if (envUrl) {
+      return envUrl;
+    }
+
+    const chainId = this.get('CHAIN_ID');
+    return KEYS_API_PATHS[chainId];
+  }
 }

src/common/config/devnets/configs/devent-8.ts

@@ -1,18 +1,10 @@
-export enum DevnetName {
-  Devnet8 = 'Devnet8',
-}
-
-export const requiredContracts = [
-  'WithdrawalQueue',
-  'Lido',
-  'OracleReportSanityChecker',
-  'AccountingOracleHashConsensus',
-  'ValidatorsExitBusOracleHashConsensus',
-  'LidoLocator',
-] as const;
-
 export interface DevnetConfig {
-  name: DevnetName;
-  contracts: Record<(typeof requiredContracts)[number], string>;
-  keysApiBasePath: string;
+  name: string;
+  WithdrawalQueue: string;
+  Lido: string;
+  OracleReportSanityChecker: string;
+  AccountingOracleHashConsensus: string;
+  ValidatorsExitBusOracleHashConsensus: string;
+  LidoLocator: string;
+  KeysApiBasePath: string;
 }

src/common/config/devnets/configs/index.ts

@@ -12,8 +12,6 @@ import {
   IsBoolean,
 } from 'class-validator';
 import { Environment, LogLevel, LogFormat } from './interfaces';
-import { DevnetName } from './devnets/devnet-config.interface';
-import { devnetConfigs } from './devnets/configs';
 
 const toNumber =
   ({ defaultValue }) =>
@@ -96,7 +94,6 @@ export class EnvironmentVariables {
 
   @IsOptional()
   @IsString()
-  @Transform(({ value }) => (devnetConfigs[value] ? devnetConfigs[value].keysApiBasePath : ''))
   KEYS_API_BASE_PATH = '';
 
   @IsOptional()
@@ -116,7 +113,7 @@ export class EnvironmentVariables {
 
   @IsOptional()
   @IsString()
-  DEVNET_NAME: DevnetName = null;
+  DEVNET_NAME: string = null;
 }
 export const ENV_KEYS = Object.keys(new EnvironmentVariables());
 

src/common/config/devnets/devnet-config.interface.ts

@@ -0,0 +1,30 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { DevnetConfig } from '../devnets';
+
+export async function findDevnetConfig(name: string, directory = './devnet-configs'): Promise<DevnetConfig> {
+  try {
+    const files = await readdir(directory);
+
+    for (const file of files) {
+      if (extname(file) === '.json') {
+        const filePath = join(directory, file);
+
+        try {
+          const content = await readFile(filePath, 'utf8');
+          const json = JSON.parse(content);
+
+          if (json.name === name) {
+            return json;
+          }
+        } catch (err) {
+          console.error(`Error reading file ${file}: ${err.message}`);
+        }
+      }
+    }
+  } catch (err) {
+    console.error(`Error ready directory: ${err.message}`);
+  }
+
+  return null;
+}

src/common/config/env.validation.ts

@@ -22,7 +22,7 @@ import { ConfigService } from '../config';
   ].map((module) =>
     module.forRootAsync({
       async useFactory(provider: ExecutionProvider, config: ConfigService) {
-        const addressMap = config.getCustomConfigContractsAddressMap();
+        const addressMap = await config.getCustomConfigContractsAddressMap();
         const address = addressMap ? addressMap.get(module.contractToken) : undefined;
         return { provider, address };
       },

src/common/config/utils/find-devnet-config.ts

@@ -1,33 +1,27 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
 import { LOGGER_PROVIDER, LoggerService } from '../../../common/logger';
 import { ConfigService } from '../../../common/config';
-import { KEYS_API_PATHS } from './lido-keys.constants';
 import { LidoKeysData } from './lido-keys.types';
 
 @Injectable()
-export class LidoKeysClient {
+export class LidoKeysClient implements OnModuleInit {
   protected endpoints = {
     usedKeys: '/v1/keys?used=true',
   };
 
+  protected basePath: string;
+
   constructor(
     @Inject(LOGGER_PROVIDER) protected readonly logger: LoggerService,
     protected readonly configService: ConfigService,
   ) {}
 
-  protected getBasePath(): string {
-    const envUrl = this.configService.get('KEYS_API_BASE_PATH');
-
-    if (envUrl) {
-      return envUrl;
-    }
-
-    const chainId = this.configService.get('CHAIN_ID');
-    return KEYS_API_PATHS[chainId];
+  async onModuleInit() {
+    this.basePath = await this.configService.getKeysApiBasePath();
   }
 
   public async getUsedKeys() {
-    const url = this.getBasePath() + this.endpoints.usedKeys;
+    const url = this.basePath + this.endpoints.usedKeys;
     const lidoKeysResponse = await fetch(url, {
       method: 'GET',
     });