wip: locator spec

src/contracts/repository/locator/locator.service.ts

@@ -22,6 +22,7 @@ export class LocatorService {
    */
   public async getLidoAddress(blockTag: BlockTag): Promise<string> {
     const lidoLocator = await this.getLidoLocatorAbiContract();
+    console.log("???????")
     return await lidoLocator.lido({ blockTag: blockTag as any });
   }
   /**

src/contracts/repository/repository.service.spec.ts

@@ -7,6 +7,7 @@ import { MockProviderModule } from 'provider';
 import { RepositoryService } from 'contracts/repository';
 import { RepositoryModule } from './repository.module';
 import { LocatorService } from './locator/locator.service';
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
 
 const mockLocator = (locator: LocatorService) => {
   const lidoAddr = jest
@@ -56,6 +57,10 @@ describe('RepositoryService', () => {
 
     repositoryService = moduleRef.get(RepositoryService);
     locatorService = moduleRef.get(LocatorService);
+
+    jest
+      .spyOn(moduleRef.get(WINSTON_MODULE_NEST_PROVIDER), 'log')
+      .mockImplementation(() => undefined);
   });
 
   describe('lido contract', () => {

src/contracts/security/security.service.spec.ts

@@ -6,6 +6,7 @@ import { MockProviderModule, ProviderService } from 'provider';
 import { WalletService } from 'wallet';
 import { SecurityAbi__factory, StakingRouterAbi__factory } from 'generated';
 import { RepositoryModule, RepositoryService } from 'contracts/repository';
+import { LocatorService } from 'contracts/repository/locator/locator.service';
 import { Interface } from '@ethersproject/abi';
 import { BigNumber } from '@ethersproject/bignumber';
 import { hexZeroPad } from '@ethersproject/bytes';
@@ -17,15 +18,44 @@ import { SecurityModule } from './security.module';
 
 jest.mock('../../transport/stomp/stomp.client');
 
+const mockLocator = (locator: LocatorService) => {
+  const lidoAddr = jest
+    .spyOn(locator, 'getLidoAddress')
+    .mockImplementationOnce(async () => '0x' + '1'.repeat(40));
+
+  const DSMAddr = jest
+    .spyOn(locator, 'getDSMAddress')
+    .mockImplementationOnce(async () => '0x' + '2'.repeat(40));
+  const SRAddr = jest
+    .spyOn(locator, 'getStakingRouterAddress')
+    .mockImplementationOnce(async () => '0x' + '3'.repeat(40));
+  const locatorAddr = jest
+    .spyOn(locator, 'getLocatorAddress')
+    .mockImplementationOnce(async () => '0x' + '4'.repeat(40));
+
+  return { lidoAddr, locatorAddr, SRAddr, DSMAddr };
+};
+
+const mockRepository = async (repositoryService: RepositoryService) => {
+  const address1 = '0x' + '5'.repeat(40);
+
+  const depositAddr = jest
+    .spyOn(repositoryService, 'getDepositAddress')
+    .mockImplementationOnce(async () => address1);
+
+  await repositoryService.initCachedContracts({ blockHash: '111' });
+  jest.spyOn(repositoryService, 'getCachedLidoContract');
+
+  return { depositAddr };
+};
+
 const TEST_MODULE_ID = 1;
 
 describe('SecurityService', () => {
   const address1 = hexZeroPad('0x1', 20);
   const address2 = hexZeroPad('0x2', 20);
   const address3 = hexZeroPad('0x3', 20);
 
-  const securityAddress = '0x' + '1'.repeat(40);
-
   let securityService: SecurityService;
   let providerService: ProviderService;
   let repositoryService: RepositoryService;
@@ -51,9 +81,10 @@ describe('SecurityService', () => {
     loggerService = moduleRef.get(WINSTON_MODULE_NEST_PROVIDER);
 
     jest.spyOn(loggerService, 'warn').mockImplementation(() => undefined);
-    jest
-      .spyOn(repositoryService, 'getDepositSecurityAddress')
-      .mockImplementation(async () => securityAddress);
+    jest.spyOn(loggerService, 'log').mockImplementation(() => undefined);
+
+    mockLocator(moduleRef.get(LocatorService));
+    await mockRepository(repositoryService);
   });
 
   describe('getAttestMessagePrefix', () => {
@@ -254,7 +285,7 @@ describe('SecurityService', () => {
 
       const isPaused = await securityService.isDepositsPaused(TEST_MODULE_ID);
       expect(isPaused).toBe(!expected);
-      expect(mockProviderCalla).toBeCalledTimes(2);
+      expect(mockProviderCalla).toBeCalledTimes(1);
     });
   });
 

src/guardian/guardian.service.spec.ts

@@ -9,7 +9,7 @@ import { PrometheusModule } from 'common/prometheus';
 import { GuardianModule } from 'guardian';
 import { DepositModule } from 'contracts/deposit';
 import { SecurityModule } from 'contracts/security';
-import { RepositoryModule } from 'contracts/repository';
+import { RepositoryModule, RepositoryService } from 'contracts/repository';
 import { LidoModule } from 'contracts/lido';
 import { MessagesModule } from 'messages';
 import { StakingRouterModule, StakingRouterService } from 'staking-router';
@@ -18,6 +18,8 @@ import { GuardianMessageModule } from './guardian-message';
 import { StakingModuleGuardModule } from './staking-module-guard';
 import { BlockGuardModule, BlockGuardService } from './block-guard';
 import { ScheduleModule } from 'common/schedule';
+import { LocatorService } from 'contracts/repository/locator/locator.service';
+import { LocatorModule } from 'contracts/repository/locator/locator.module';
 
 jest.mock('../transport/stomp/stomp.client');
 
@@ -46,21 +48,54 @@ const stakingModuleResponse = {
   },
 };
 
+const mockLocator = (locator: LocatorService) => {
+  const lidoAddr = jest
+    .spyOn(locator, 'getLidoAddress')
+    .mockImplementationOnce(async () => '0x' + '1'.repeat(40));
+  const DSMAddr = jest
+    .spyOn(locator, 'getDSMAddress')
+    .mockImplementationOnce(async () => '0x' + '2'.repeat(40));
+  const SRAddr = jest
+    .spyOn(locator, 'getStakingRouterAddress')
+    .mockImplementationOnce(async () => '0x' + '3'.repeat(40));
+  const locatorAddr = jest
+    .spyOn(locator, 'getLocatorAddress')
+    .mockImplementationOnce(async () => '0x' + '4'.repeat(40));
+
+  return { lidoAddr, locatorAddr, SRAddr, DSMAddr };
+};
+
+const mockRepository = async (repositoryService: RepositoryService) => {
+  const address1 = '0x' + '5'.repeat(40);
+  const depositAddr = jest
+    .spyOn(repositoryService, 'getDepositAddress')
+    .mockImplementationOnce(async () => address1);
+
+  await repositoryService.initCachedContracts('latest');
+  jest.spyOn(repositoryService, 'getCachedLidoContract');
+
+  return { depositAddr };
+};
+
 describe('GuardianService', () => {
   let stakingRouterService: StakingRouterService;
   let blockGuardService: BlockGuardService;
 
   let guardianService: GuardianService;
   let loggerService: LoggerService;
 
+  let repositoryService: RepositoryService;
+  let locatorService: LocatorService;
+
   beforeEach(async () => {
     const moduleRef = await Test.createTestingModule({
       imports: [
         ConfigModule.forRoot(),
         MockProviderModule.forRoot(),
         LoggerModule,
         PrometheusModule,
-
+        // LocatorModule,
+        // RepositoryModule,
         GuardianModule,
         RepositoryModule,
         DepositModule,
@@ -74,37 +109,45 @@ describe('GuardianService', () => {
         GuardianMessageModule,
         GuardianMetricsModule,
       ],
-    }).compile();
+    })
+      // .overrideProvider(RepositoryService)
+      // .useClass(RepositoryService)
+      // .useValue(mockRepository(new RepositoryService(moduleRef.get(WINSTON_MODULE_NEST_PROVIDER), )))
+      .compile();
 
     stakingRouterService = moduleRef.get(StakingRouterService);
     blockGuardService = moduleRef.get(BlockGuardService);
 
+    repositoryService = moduleRef.get(RepositoryService);
+    locatorService = moduleRef.get(LocatorService);
+
     guardianService = moduleRef.get(GuardianService);
 
     loggerService = moduleRef.get(WINSTON_MODULE_NEST_PROVIDER);
 
     jest.spyOn(loggerService, 'log').mockImplementation(() => undefined);
     jest.spyOn(loggerService, 'warn').mockImplementation(() => undefined);
     jest.spyOn(loggerService, 'debug').mockImplementation(() => undefined);
+
+    mockLocator(locatorService);
+    await mockRepository(repositoryService);
   });
 
-  describe('handleNewBlock', () => {
-    it('should exit if the previous call is not completed', async () => {
-      const getStakingModulesMock = jest
-        .spyOn(stakingRouterService, 'getStakingModules')
-        .mockImplementation(async () => stakingModuleResponse);
+  it('should exit if the previous call is not completed', async () => {
+    const getStakingModulesMock = jest
+      .spyOn(stakingRouterService, 'getStakingModules')
+      .mockImplementation(async () => stakingModuleResponse);
 
-      const getBlockGuardServiceMock = jest
-        .spyOn(blockGuardService, 'isNeedToProcessNewState')
-        .mockImplementation(() => false);
+    const getBlockGuardServiceMock = jest
+      .spyOn(blockGuardService, 'isNeedToProcessNewState')
+      .mockImplementation(() => false);
 
-      await Promise.all([
-        guardianService.handleNewBlock(),
-        guardianService.handleNewBlock(),
-      ]);
+    await Promise.all([
+      guardianService.handleNewBlock(),
+      guardianService.handleNewBlock(),
+    ]);
 
-      expect(getStakingModulesMock).toBeCalledTimes(1);
-      expect(getBlockGuardServiceMock).toBeCalledTimes(1);
-    });
+    expect(getStakingModulesMock).toBeCalledTimes(1);
+    expect(getBlockGuardServiceMock).toBeCalledTimes(1);
   });
 });

src/guardian/guardian.service.ts

@@ -100,8 +100,12 @@ export class GuardianService implements OnModuleInit {
       elBlockSnapshot: { blockHash, blockNumber },
       data: stakingModules,
     } = await this.stakingRouterService.getStakingModules();
-
-    await this.repositoryService.initCachedContracts({ blockHash });
+    console.log(blockHash);
+    try {
+      await this.repositoryService.initCachedContracts({ blockHash });
+    } catch (error) {
+      console.log(error);
+    }
 
     if (
       !this.blockGuardService.isNeedToProcessNewState({