@lido-nestjs/registry 1.0.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Lido
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# Registry Module
+
+NestJS Registry Module for Lido Finance projects.
+Part of [Lido NestJS Modules](https://github.com/lidofinance/lido-nestjs-modules/#readme)
+
+## Install
+
+```bash
+yarn add @lido-nestjs/registry
+```
+
+## Usage
+
+TODO

package/dist/fetch/interfaces/key.interface.d.ts

@@ -0,0 +1,7 @@
+export interface RegistryKey {
+    index: number;
+    operatorIndex: number;
+    depositSignature: string;
+    key: string;
+    used: boolean;
+}

package/dist/fetch/interfaces/module.interface.d.ts

@@ -0,0 +1,14 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { Signer } from 'ethers';
+import { Provider } from '@ethersproject/providers';
+export interface RegistryFetchOptions {
+    registryAddress?: string;
+    lidoAddress?: string;
+    provider?: Provider | Signer;
+}
+export interface RegistryFetchModuleSyncOptions extends Pick<ModuleMetadata, 'imports'>, RegistryFetchOptions {
+}
+export interface RegistryFetchModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory: (...args: any[]) => Promise<RegistryFetchOptions>;
+    inject?: any[];
+}

package/dist/fetch/interfaces/operator.interface.d.ts

@@ -0,0 +1,10 @@
+export interface RegistryOperator {
+    index: number;
+    active: boolean;
+    name: string;
+    rewardAddress: string;
+    stakingLimit: number;
+    stoppedValidators: number;
+    totalSigningKeys: number;
+    usedSigningKeys: number;
+}

package/dist/fetch/interfaces/overrides.interface.d.ts

@@ -0,0 +1,10 @@
+import { CallOverrides as CallOverridesSource } from '@ethersproject/contracts';
+export declare type BlockTagWith1898 = string | number | {
+    blockNumber: string;
+} | {
+    blockHash: string;
+    requireCanonical?: boolean;
+};
+export interface CallOverrides extends Omit<CallOverridesSource, 'blockTag'> {
+    blockTag?: BlockTagWith1898;
+}

package/dist/fetch/key.constants.d.ts

@@ -0,0 +1 @@
+export declare const REGISTRY_KEY_BATCH_SIZE = 200;

package/dist/fetch/key.constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const REGISTRY_KEY_BATCH_SIZE = 200;
+
+exports.REGISTRY_KEY_BATCH_SIZE = REGISTRY_KEY_BATCH_SIZE;

package/dist/fetch/key.fetch.d.ts

@@ -0,0 +1,13 @@
+import { Registry } from '@lido-nestjs/contracts';
+import { CallOverrides } from './interfaces/overrides.interface';
+import { RegistryKey } from './interfaces/key.interface';
+import { RegistryOperatorFetchService } from './operator.fetch';
+export declare class RegistryKeyFetchService {
+    private contract;
+    private operatorsService;
+    constructor(contract: Registry, operatorsService: RegistryOperatorFetchService);
+    /** fetches one key */
+    fetchOne(operatorIndex: number, keyIndex: number, overrides?: CallOverrides): Promise<RegistryKey>;
+    /** fetches operator's keys */
+    fetch(operatorIndex: number, fromIndex?: number, toIndex?: number, overrides?: CallOverrides): Promise<RegistryKey[]>;
+}

package/dist/fetch/key.fetch.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var utils = require('@lido-nestjs/utils');
+var contracts = require('@lido-nestjs/contracts');
+var operator_fetch = require('./operator.fetch.js');
+var key_constants = require('./key.constants.js');
+
+exports.RegistryKeyFetchService = class RegistryKeyFetchService {
+    constructor(contract, operatorsService) {
+        this.contract = contract;
+        this.operatorsService = operatorsService;
+    }
+    /** fetches one key */
+    async fetchOne(operatorIndex, keyIndex, overrides = {}) {
+        const keyData = await this.contract.getSigningKey(operatorIndex, keyIndex, overrides);
+        const { key, depositSignature, used } = keyData;
+        return {
+            operatorIndex,
+            index: keyIndex,
+            key,
+            depositSignature,
+            used,
+        };
+    }
+    /** fetches operator's keys */
+    async fetch(operatorIndex, fromIndex = 0, toIndex = -1, overrides = {}) {
+        if (fromIndex > toIndex && toIndex !== -1) {
+            throw new Error('fromIndex is greater than or equal to toIndex');
+        }
+        if (toIndex == null || toIndex === -1) {
+            const operator = await this.operatorsService.fetchOne(operatorIndex, overrides);
+            toIndex = operator.totalSigningKeys;
+        }
+        const fetcher = async (keyIndex) => {
+            return await this.fetchOne(operatorIndex, keyIndex, overrides);
+        };
+        const batchSize = key_constants.REGISTRY_KEY_BATCH_SIZE;
+        return await utils.rangePromise(fetcher, fromIndex, toIndex, batchSize);
+    }
+};
+exports.RegistryKeyFetchService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__param(0, common.Inject(contracts.REGISTRY_CONTRACT_TOKEN)),
+    tslib.__metadata("design:paramtypes", [Object, operator_fetch.RegistryOperatorFetchService])
+], exports.RegistryKeyFetchService);

package/dist/fetch/meta.fetch.d.ts

@@ -0,0 +1,8 @@
+import { Registry } from '@lido-nestjs/contracts';
+import { CallOverrides } from './interfaces/overrides.interface';
+export declare class RegistryMetaFetchService {
+    private registryContract;
+    constructor(registryContract: Registry);
+    /** fetches keys operation index */
+    fetchKeysOpIndex(overrides?: CallOverrides): Promise<number>;
+}

package/dist/fetch/meta.fetch.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var contracts = require('@lido-nestjs/contracts');
+
+exports.RegistryMetaFetchService = class RegistryMetaFetchService {
+    constructor(registryContract) {
+        this.registryContract = registryContract;
+    }
+    /** fetches keys operation index */
+    async fetchKeysOpIndex(overrides = {}) {
+        const bigNumber = await this.registryContract.getKeysOpIndex(overrides);
+        return bigNumber.toNumber();
+    }
+};
+exports.RegistryMetaFetchService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__param(0, common.Inject(contracts.REGISTRY_CONTRACT_TOKEN)),
+    tslib.__metadata("design:paramtypes", [Object])
+], exports.RegistryMetaFetchService);

package/dist/fetch/operator.constants.d.ts

@@ -0,0 +1 @@
+export declare const REGISTRY_OPERATORS_BATCH_SIZE = 50;

package/dist/fetch/operator.constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const REGISTRY_OPERATORS_BATCH_SIZE = 50;
+
+exports.REGISTRY_OPERATORS_BATCH_SIZE = REGISTRY_OPERATORS_BATCH_SIZE;

package/dist/fetch/operator.fetch.d.ts

@@ -0,0 +1,13 @@
+import { Registry } from '@lido-nestjs/contracts';
+import { CallOverrides } from './interfaces/overrides.interface';
+import { RegistryOperator } from './interfaces/operator.interface';
+export declare class RegistryOperatorFetchService {
+    private contract;
+    constructor(contract: Registry);
+    /** fetches number of operators */
+    count(overrides?: CallOverrides): Promise<number>;
+    /** fetches one operator */
+    fetchOne(operatorIndex: number, overrides?: CallOverrides): Promise<RegistryOperator>;
+    /** fetches operators */
+    fetch(fromIndex?: number, toIndex?: number, overrides?: CallOverrides): Promise<RegistryOperator[]>;
+}

package/dist/fetch/operator.fetch.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var utils = require('@lido-nestjs/utils');
+var contracts = require('@lido-nestjs/contracts');
+var operator_constants = require('./operator.constants.js');
+
+exports.RegistryOperatorFetchService = class RegistryOperatorFetchService {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    /** fetches number of operators */
+    async count(overrides = {}) {
+        const bigNumber = await this.contract.getNodeOperatorsCount(overrides);
+        return bigNumber.toNumber();
+    }
+    /** fetches one operator */
+    async fetchOne(operatorIndex, overrides = {}) {
+        const fullInfo = true;
+        const operator = await this.contract.getNodeOperator(operatorIndex, fullInfo, overrides);
+        const { name, active, rewardAddress, stakingLimit, stoppedValidators, totalSigningKeys, usedSigningKeys, } = operator;
+        return {
+            index: operatorIndex,
+            active,
+            name,
+            rewardAddress,
+            stakingLimit: stakingLimit.toNumber(),
+            stoppedValidators: stoppedValidators.toNumber(),
+            totalSigningKeys: totalSigningKeys.toNumber(),
+            usedSigningKeys: usedSigningKeys.toNumber(),
+        };
+    }
+    /** fetches operators */
+    async fetch(fromIndex = 0, toIndex = -1, overrides = {}) {
+        if (fromIndex > toIndex && toIndex !== -1) {
+            throw new Error('fromIndex is greater than or equal to toIndex');
+        }
+        if (toIndex == null || toIndex === -1) {
+            toIndex = await this.count(overrides);
+        }
+        const fetcher = async (operatorIndex) => {
+            return await this.fetchOne(operatorIndex, overrides);
+        };
+        const batchSize = operator_constants.REGISTRY_OPERATORS_BATCH_SIZE;
+        return await utils.rangePromise(fetcher, fromIndex, toIndex, batchSize);
+    }
+};
+exports.RegistryOperatorFetchService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__param(0, common.Inject(contracts.REGISTRY_CONTRACT_TOKEN)),
+    tslib.__metadata("design:paramtypes", [Object])
+], exports.RegistryOperatorFetchService);

package/dist/fetch/registry-fetch.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { RegistryFetchModuleSyncOptions, RegistryFetchModuleAsyncOptions } from './interfaces/module.interface';
+export declare class RegistryFetchModule {
+    static forRoot(options?: RegistryFetchModuleSyncOptions): DynamicModule;
+    static forRootAsync(options: RegistryFetchModuleAsyncOptions): DynamicModule;
+    static forFeature(options?: RegistryFetchModuleSyncOptions): DynamicModule;
+    static forFeatureAsync(options: RegistryFetchModuleAsyncOptions): DynamicModule;
+}

package/dist/fetch/registry-fetch.module.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var contracts = require('@lido-nestjs/contracts');
+var operator_fetch = require('./operator.fetch.js');
+var meta_fetch = require('./meta.fetch.js');
+var key_fetch = require('./key.fetch.js');
+var registryFetch_service = require('./registry-fetch.service.js');
+
+var RegistryFetchModule_1;
+exports.RegistryFetchModule = RegistryFetchModule_1 = class RegistryFetchModule {
+    static forRoot(options) {
+        return Object.assign({ global: true }, this.forFeature(options));
+    }
+    static forRootAsync(options) {
+        return Object.assign({ global: true }, this.forFeatureAsync(options));
+    }
+    static forFeature(options) {
+        return {
+            module: RegistryFetchModule_1,
+            imports: [
+                ...((options === null || options === void 0 ? void 0 : options.imports) || []),
+                contracts.LidoContractModule.forFeature({
+                    address: options === null || options === void 0 ? void 0 : options.lidoAddress,
+                    provider: options === null || options === void 0 ? void 0 : options.provider,
+                }),
+                contracts.RegistryContractModule.forFeature({
+                    address: options === null || options === void 0 ? void 0 : options.registryAddress,
+                    provider: options === null || options === void 0 ? void 0 : options.provider,
+                }),
+            ],
+            exports: [contracts.LidoContractModule, contracts.RegistryContractModule],
+        };
+    }
+    static forFeatureAsync(options) {
+        return {
+            module: RegistryFetchModule_1,
+            imports: [
+                ...(options.imports || []),
+                contracts.LidoContractModule.forFeatureAsync({
+                    async useFactory(...args) {
+                        const config = await options.useFactory(...args);
+                        const { provider, lidoAddress } = config;
+                        return { provider, address: lidoAddress };
+                    },
+                    inject: options.inject,
+                }),
+                contracts.RegistryContractModule.forFeatureAsync({
+                    async useFactory(...args) {
+                        const config = await options.useFactory(...args);
+                        const { provider, registryAddress } = config;
+                        return { provider, address: registryAddress };
+                    },
+                    inject: options.inject,
+                }),
+            ],
+            exports: [contracts.LidoContractModule, contracts.RegistryContractModule],
+        };
+    }
+};
+exports.RegistryFetchModule = RegistryFetchModule_1 = tslib.__decorate([
+    common.Module({
+        providers: [
+            registryFetch_service.RegistryFetchService,
+            operator_fetch.RegistryOperatorFetchService,
+            meta_fetch.RegistryMetaFetchService,
+            key_fetch.RegistryKeyFetchService,
+        ],
+        exports: [
+            registryFetch_service.RegistryFetchService,
+            operator_fetch.RegistryOperatorFetchService,
+            meta_fetch.RegistryMetaFetchService,
+            key_fetch.RegistryKeyFetchService,
+        ],
+    })
+], exports.RegistryFetchModule);

package/dist/fetch/registry-fetch.service.d.ts

@@ -0,0 +1,2 @@
+export declare class RegistryFetchService {
+}

package/dist/fetch/registry-fetch.service.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+
+exports.RegistryFetchService = class RegistryFetchService {
+};
+exports.RegistryFetchService = tslib.__decorate([
+    common.Injectable()
+], exports.RegistryFetchService);

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from './fetch/registry-fetch.module';
+export * from './fetch/registry-fetch.service';
+export * from './fetch/key.constants';
+export * from './fetch/key.fetch';
+export * from './fetch/meta.fetch';
+export * from './fetch/operator.constants';
+export * from './fetch/operator.fetch';
+export * from './storage/registry-storage.module';
+export * from './storage/registry-storage.service';
+export * from './storage/key.entity';
+export * from './storage/key.repository';
+export * from './storage/key.storage';
+export * from './storage/meta.entity';
+export * from './storage/meta.repository';
+export * from './storage/meta.storage';
+export * from './storage/operator.entity';
+export * from './storage/operator.repository';
+export * from './storage/operator.storage';
+export * from './main/key-registry/key-registry.service';
+export * from './main/key-registry/key-registry.module';
+export * from './main/validator-registry/validator-registry.service';
+export * from './main/validator-registry/validator-registry.module';

package/dist/index.js

@@ -0,0 +1,96 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var registryFetch_module = require('./fetch/registry-fetch.module.js');
+var registryFetch_service = require('./fetch/registry-fetch.service.js');
+var key_constants = require('./fetch/key.constants.js');
+var key_fetch = require('./fetch/key.fetch.js');
+var meta_fetch = require('./fetch/meta.fetch.js');
+var operator_constants = require('./fetch/operator.constants.js');
+var operator_fetch = require('./fetch/operator.fetch.js');
+var registryStorage_module = require('./storage/registry-storage.module.js');
+var registryStorage_service = require('./storage/registry-storage.service.js');
+var key_entity = require('./storage/key.entity.js');
+var key_repository = require('./storage/key.repository.js');
+var key_storage = require('./storage/key.storage.js');
+var meta_entity = require('./storage/meta.entity.js');
+var meta_repository = require('./storage/meta.repository.js');
+var meta_storage = require('./storage/meta.storage.js');
+var operator_entity = require('./storage/operator.entity.js');
+var operator_repository = require('./storage/operator.repository.js');
+var operator_storage = require('./storage/operator.storage.js');
+var keyRegistry_service = require('./main/key-registry/key-registry.service.js');
+var keyRegistry_module = require('./main/key-registry/key-registry.module.js');
+var validatorRegistry_service = require('./main/validator-registry/validator-registry.service.js');
+var validatorRegistry_module = require('./main/validator-registry/validator-registry.module.js');
+
+
+
+Object.defineProperty(exports, 'RegistryFetchModule', {
+	enumerable: true,
+	get: function () { return registryFetch_module.RegistryFetchModule; }
+});
+Object.defineProperty(exports, 'RegistryFetchService', {
+	enumerable: true,
+	get: function () { return registryFetch_service.RegistryFetchService; }
+});
+exports.REGISTRY_KEY_BATCH_SIZE = key_constants.REGISTRY_KEY_BATCH_SIZE;
+Object.defineProperty(exports, 'RegistryKeyFetchService', {
+	enumerable: true,
+	get: function () { return key_fetch.RegistryKeyFetchService; }
+});
+Object.defineProperty(exports, 'RegistryMetaFetchService', {
+	enumerable: true,
+	get: function () { return meta_fetch.RegistryMetaFetchService; }
+});
+exports.REGISTRY_OPERATORS_BATCH_SIZE = operator_constants.REGISTRY_OPERATORS_BATCH_SIZE;
+Object.defineProperty(exports, 'RegistryOperatorFetchService', {
+	enumerable: true,
+	get: function () { return operator_fetch.RegistryOperatorFetchService; }
+});
+Object.defineProperty(exports, 'RegistryStorageModule', {
+	enumerable: true,
+	get: function () { return registryStorage_module.RegistryStorageModule; }
+});
+Object.defineProperty(exports, 'RegistryStorageService', {
+	enumerable: true,
+	get: function () { return registryStorage_service.RegistryStorageService; }
+});
+Object.defineProperty(exports, 'RegistryKey', {
+	enumerable: true,
+	get: function () { return key_entity.RegistryKey; }
+});
+exports.RegistryKeyRepository = key_repository.RegistryKeyRepository;
+Object.defineProperty(exports, 'RegistryKeyStorageService', {
+	enumerable: true,
+	get: function () { return key_storage.RegistryKeyStorageService; }
+});
+Object.defineProperty(exports, 'RegistryMeta', {
+	enumerable: true,
+	get: function () { return meta_entity.RegistryMeta; }
+});
+exports.RegistryMetaRepository = meta_repository.RegistryMetaRepository;
+Object.defineProperty(exports, 'RegistryMetaStorageService', {
+	enumerable: true,
+	get: function () { return meta_storage.RegistryMetaStorageService; }
+});
+Object.defineProperty(exports, 'RegistryOperator', {
+	enumerable: true,
+	get: function () { return operator_entity.RegistryOperator; }
+});
+exports.RegistryOperatorRepository = operator_repository.RegistryOperatorRepository;
+Object.defineProperty(exports, 'RegistryOperatorStorageService', {
+	enumerable: true,
+	get: function () { return operator_storage.RegistryOperatorStorageService; }
+});
+exports.KeyRegistryService = keyRegistry_service.KeyRegistryService;
+Object.defineProperty(exports, 'KeyRegistryModule', {
+	enumerable: true,
+	get: function () { return keyRegistry_module.KeyRegistryModule; }
+});
+exports.ValidatorRegistryService = validatorRegistry_service.ValidatorRegistryService;
+Object.defineProperty(exports, 'ValidatorRegistryModule', {
+	enumerable: true,
+	get: function () { return validatorRegistry_module.ValidatorRegistryModule; }
+});

package/dist/main/abstract-registry.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+import { LoggerService } from '@nestjs/common';
+import { Registry } from '@lido-nestjs/contracts';
+import { EntityManager } from '@mikro-orm/sqlite';
+import EventEmitter from 'events';
+import { CronJob } from 'cron';
+import { RegistryMetaFetchService } from '../fetch/meta.fetch';
+import { RegistryKeyFetchService } from '../fetch/key.fetch';
+import { RegistryOperatorFetchService } from '../fetch/operator.fetch';
+import { RegistryMetaStorageService } from '../storage/meta.storage';
+import { RegistryKeyStorageService } from '../storage/key.storage';
+import { RegistryOperatorStorageService } from '../storage/operator.storage';
+import { RegistryMeta } from '../storage/meta.entity';
+import { RegistryKey } from '../storage/key.entity';
+import { RegistryOperator } from '../storage/operator.entity';
+import { RegistryOptions } from './interfaces/module.interface';
+export declare abstract class AbstractRegistryService {
+    protected registryContract: Registry;
+    protected logger: LoggerService;
+    protected readonly metaFetch: RegistryMetaFetchService;
+    protected readonly metaStorage: RegistryMetaStorageService;
+    protected readonly keyFetch: RegistryKeyFetchService;
+    protected readonly keyStorage: RegistryKeyStorageService;
+    protected readonly operatorFetch: RegistryOperatorFetchService;
+    protected readonly operatorStorage: RegistryOperatorStorageService;
+    protected readonly entityManager: EntityManager;
+    options?: RegistryOptions | undefined;
+    constructor(registryContract: Registry, logger: LoggerService, metaFetch: RegistryMetaFetchService, metaStorage: RegistryMetaStorageService, keyFetch: RegistryKeyFetchService, keyStorage: RegistryKeyStorageService, operatorFetch: RegistryOperatorFetchService, operatorStorage: RegistryOperatorStorageService, entityManager: EntityManager, options?: RegistryOptions | undefined);
+    eventEmitter: EventEmitter;
+    cronJob: CronJob;
+    protected cronHandler(): Promise<void>;
+    protected collectListenerCount(): number;
+    subscribe(cb: (error: null | Error, payload: RegistryKey[]) => void): () => void;
+    /** collects changed data from the contract and store it to the db */
+    update(blockHashOrBlockTag: string | number): Promise<import("../fetch/interfaces/key.interface").RegistryKey[] | undefined>;
+    /** contract */
+    /** returns the meta data from the contract */
+    getMetaDataFromContract(blockHashOrBlockTag: string | number): Promise<RegistryMeta>;
+    /** returns operators from the contract */
+    getOperatorsFromContract(blockHash: string): Promise<import("../fetch/interfaces/operator.interface").RegistryOperator[]>;
+    /** returns the right border of the update keys range */
+    abstract getToIndex(currOperator: RegistryOperator): number;
+    /** returns updated keys from the contract */
+    getUpdatedKeysFromContract(previousOperators: RegistryOperator[], currentOperators: RegistryOperator[], blockHash: string): Promise<import("../fetch/interfaces/key.interface").RegistryKey[]>;
+    /** storage */
+    /** returns the latest meta data from the db */
+    getMetaDataFromStorage(): Promise<RegistryMeta | null>;
+    /** returns the latest operators data from the db */
+    getOperatorsFromStorage(): Promise<RegistryOperator[]>;
+    /** clears the db */
+    clear(): Promise<void>;
+}