dev to main

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lido-keys-api",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Lido Node Operators keys service",
   "author": "Lido team",
   "private": true,
@@ -51,6 +51,7 @@
     "@lido-nestjs/execution": "^1.11.0",
     "@lido-nestjs/fetch": "^1.4.0",
     "@lido-nestjs/logger": "^1.3.2",
+    "@lido-nestjs/middleware": "^1.2.0",
     "@lido-nestjs/validators-registry": "^1.3.0",
     "@mikro-orm/cli": "^5.5.3",
     "@mikro-orm/core": "^5.5.3",

src/app/simple-dvt-deploy.e2e-chain.ts

@@ -9,7 +9,7 @@ import { RegistryKeyStorageService } from '../common/registry';
 import { ElMetaStorageService } from '../storage/el-meta.storage';
 import { SRModuleStorageService } from '../storage/sr-module.storage';
 import { KeysUpdateService } from '../jobs/keys-update';
-import { ExecutionProvider, ExecutionProviderService } from '../common/execution-provider';
+import { ExecutionProvider } from '../common/execution-provider';
 import { ConfigService } from '../common/config';
 import { PrometheusService } from '../common/prometheus';
 import { StakingRouterService } from '../staking-router-modules/staking-router.service';
@@ -64,8 +64,6 @@ describe('Simple DVT deploy', () => {
     });
 
     moduleRef = await Test.createTestingModule({ imports: [AppModule] })
-      .overrideProvider(ExecutionProviderService)
-      .useValue(session.provider)
       .overrideProvider(SimpleFallbackJsonRpcBatchProvider)
       .useValue(session.provider)
       .overrideProvider(ExecutionProvider)
@@ -89,7 +87,9 @@ describe('Simple DVT deploy', () => {
       .overrideProvider(ConfigService)
       .useValue({
         get(path) {
-          const conf = { LIDO_LOCATOR_ADDRESS: '0xC1d0b3DE6792Bf6b4b37EccdcC24e45978Cfd2Eb' };
+          const conf = {
+            LIDO_LOCATOR_ADDRESS: '0xC1d0b3DE6792Bf6b4b37EccdcC24e45978Cfd2Eb',
+          };
           return conf[path];
         },
       })

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

@@ -46,4 +46,13 @@ export class ExecutionProviderService {
     const block = await this.provider.getBlock(blockHashOrBlockTag);
     return { number: block.number, hash: block.hash, timestamp: block.timestamp };
   }
+
+  /**
+   *
+   * Returns full block info
+   */
+  public async getFullBlock(blockHashOrBlockTag: number | string) {
+    const block = await this.provider.getBlock(blockHashOrBlockTag);
+    return block;
+  }
 }

src/common/registry/fetch/interfaces/operator.interface.ts

@@ -8,4 +8,5 @@ export interface RegistryOperator {
   totalSigningKeys: number;
   usedSigningKeys: number;
   moduleAddress: string;
+  finalizedUsedSigningKeys: number;
 }

src/common/registry/fetch/operator.fetch.ts

@@ -59,20 +59,37 @@ export class RegistryOperatorFetchService {
     return false;
   }
 
+  /** return blockTag for finalized block, it need for testing purposes */
+  public getFinalizedBlockTag() {
+    return 'finalized';
+  }
+
   /** fetches number of operators */
   public async count(moduleAddress: string, overrides: CallOverrides = {}): Promise<number> {
     const bigNumber = await this.getContract(moduleAddress).getNodeOperatorsCount(overrides as any);
     return bigNumber.toNumber();
   }
 
+  /** fetches finalized operator */
+  public async getFinalizedNodeOperator(moduleAddress: string, operatorIndex: number) {
+    const fullInfo = true;
+    const contract = this.getContract(moduleAddress);
+    const finalizedOperator = await contract.getNodeOperator(operatorIndex, fullInfo, {
+      blockTag: this.getFinalizedBlockTag(),
+    });
+    return finalizedOperator;
+  }
+
   /** fetches one operator */
   public async fetchOne(
     moduleAddress: string,
     operatorIndex: number,
     overrides: CallOverrides = {},
   ): Promise<RegistryOperator> {
     const fullInfo = true;
-    const operator = await this.getContract(moduleAddress).getNodeOperator(operatorIndex, fullInfo, overrides as any);
+    const contract = this.getContract(moduleAddress);
+
+    const operator = await contract.getNodeOperator(operatorIndex, fullInfo, overrides as any);
 
     const {
       name,
@@ -84,6 +101,11 @@ export class RegistryOperatorFetchService {
       totalDepositedValidators,
     } = operator;
 
+    const { totalDepositedValidators: finalizedUsedSigningKeys } = await this.getFinalizedNodeOperator(
+      moduleAddress,
+      operatorIndex,
+    );
+
     return {
       index: operatorIndex,
       active,
@@ -94,6 +116,7 @@ export class RegistryOperatorFetchService {
       totalSigningKeys: totalAddedValidators.toNumber(),
       usedSigningKeys: totalDepositedValidators.toNumber(),
       moduleAddress,
+      finalizedUsedSigningKeys: finalizedUsedSigningKeys.toNumber(),
     };
   }
 

src/common/registry/main/abstract-registry.ts

@@ -108,9 +108,10 @@ export abstract class AbstractRegistryService {
       const prevOperator = previousOperators[currentIndex] ?? null;
       const isSameOperator = compareOperators(prevOperator, currOperator);
 
+      const finalizedUsedSigningKeys = prevOperator ? prevOperator.finalizedUsedSigningKeys : null;
       // skip updating keys from 0 to `usedSigningKeys` of previous collected data
       // since the contract guarantees that these keys cannot be changed
-      const unchangedKeysMaxIndex = isSameOperator ? prevOperator.usedSigningKeys : 0;
+      const unchangedKeysMaxIndex = isSameOperator && finalizedUsedSigningKeys ? finalizedUsedSigningKeys : 0;
       // get the right border up to which the keys should be updated
       // it's different for different scenarios
       const toIndex = this.getToIndex(currOperator);
@@ -121,7 +122,7 @@ export abstract class AbstractRegistryService {
 
       const operatorIndex = currOperator.index;
       const overrides = { blockTag: { blockHash } };
-      // TODO: use feature flag
+
       const result = await this.keyBatchFetch.fetch(moduleAddress, operatorIndex, fromIndex, toIndex, overrides);
 
       const operatorKeys = result.filter((key) => key);
@@ -138,8 +139,6 @@ export abstract class AbstractRegistryService {
 
       this.logger.log('Keys saved', { operatorIndex });
     }
-
-    console.timeEnd('FETCH_OPERATORS');
   }
 
   /** storage */

src/common/registry/storage/operator.entity.ts

@@ -17,6 +17,7 @@ export class RegistryOperator {
     this.totalSigningKeys = operator.totalSigningKeys;
     this.usedSigningKeys = operator.usedSigningKeys;
     this.moduleAddress = operator.moduleAddress;
+    this.finalizedUsedSigningKeys = operator.finalizedUsedSigningKeys;
   }
 
   @PrimaryKey()
@@ -46,4 +47,7 @@ export class RegistryOperator {
   @PrimaryKey()
   @Property({ length: ADDRESS_LEN })
   moduleAddress!: string;
+
+  @Property()
+  finalizedUsedSigningKeys!: number;
 }

src/common/registry/test/fetch/key.fetch.spec.ts

@@ -76,7 +76,33 @@ describe('Keys', () => {
     const result = await fetchService.fetch(address, expected.operatorIndex);
 
     expect(result).toEqual([expected]);
-    expect(mockCall).toBeCalledTimes(2);
+    expect(mockCall).toBeCalledTimes(3);
+  });
+
+  test('fetch all operator keys with reorg', async () => {
+    const expected = { operatorIndex: 1, index: 0, moduleAddress: address, ...key };
+
+    mockCall
+      .mockImplementationOnce(async () => {
+        const iface = new Interface(Registry__factory.abi);
+        return iface.encodeFunctionResult(
+          'getNodeOperator',
+          operatorFields({
+            ...operator,
+            moduleAddress: address,
+            totalSigningKeys: 1,
+            usedSigningKeys: 2,
+            finalizedUsedSigningKeys: 1,
+          }),
+        );
+      })
+      .mockImplementation(async () => {
+        const iface = new Interface(Registry__factory.abi);
+        return iface.encodeFunctionResult('getSigningKey', keyFields);
+      });
+    const result = await fetchService.fetch(address, expected.operatorIndex);
+    expect(result).toEqual([expected]);
+    expect(mockCall).toBeCalledTimes(3);
   });
 
   test('fetch. fromIndex > toIndex', async () => {

src/common/registry/test/fetch/operator.fetch.spec.ts

@@ -48,7 +48,7 @@ describe('Operators', () => {
     const result = await fetchService.fetchOne(address, expected.index);
 
     expect(result).toEqual(expected);
-    expect(mockCall).toBeCalledTimes(1);
+    expect(mockCall).toBeCalledTimes(2);
   });
 
   test('fetch', async () => {
@@ -62,7 +62,7 @@ describe('Operators', () => {
     const result = await fetchService.fetch(address, expectedFirst.index, expectedSecond.index + 1);
 
     expect(result).toEqual([expectedFirst, expectedSecond]);
-    expect(mockCall).toBeCalledTimes(2);
+    expect(mockCall).toBeCalledTimes(4);
   });
 
   test('fetch all', async () => {
@@ -73,16 +73,15 @@ describe('Operators', () => {
         const iface = new Interface(Registry__factory.abi);
         return iface.encodeFunctionResult('getNodeOperatorsCount', [1]);
       })
-      .mockImplementationOnce(async () => {
+      .mockImplementation(async () => {
         const iface = new Interface(Registry__factory.abi);
         operator['moduleAddress'] = address;
-        // operatorFields(operator);
         return iface.encodeFunctionResult('getNodeOperator', operatorFields(operator));
       });
     const result = await fetchService.fetch(address);
 
     expect(result).toEqual([expected]);
-    expect(mockCall).toBeCalledTimes(2);
+    expect(mockCall).toBeCalledTimes(3);
   });
 
   test('fetch. fromIndex > toIndex', async () => {