@lido-nestjs/registry 1.0.0

package/dist/main/abstract-registry.js

@@ -0,0 +1,211 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var contracts = require('@lido-nestjs/contracts');
+var sqlite = require('@mikro-orm/sqlite');
+var logger = require('@lido-nestjs/logger');
+var decorators = require('@lido-nestjs/decorators');
+var EventEmitter = require('events');
+var cron = require('cron');
+var meta_fetch = require('../fetch/meta.fetch.js');
+var key_fetch = require('../fetch/key.fetch.js');
+var operator_fetch = require('../fetch/operator.fetch.js');
+var meta_storage = require('../storage/meta.storage.js');
+var key_storage = require('../storage/key.storage.js');
+var operator_storage = require('../storage/operator.storage.js');
+var meta_entity = require('../storage/meta.entity.js');
+var key_entity = require('../storage/key.entity.js');
+var operator_entity = require('../storage/operator.entity.js');
+var meta_utils = require('../utils/meta.utils.js');
+var operator_utils = require('../utils/operator.utils.js');
+var constants = require('./constants.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+exports.AbstractRegistryService = class AbstractRegistryService {
+    constructor(registryContract, logger, metaFetch, metaStorage, keyFetch, keyStorage, operatorFetch, operatorStorage, entityManager, options) {
+        this.registryContract = registryContract;
+        this.logger = logger;
+        this.metaFetch = metaFetch;
+        this.metaStorage = metaStorage;
+        this.keyFetch = keyFetch;
+        this.keyStorage = keyStorage;
+        this.operatorFetch = operatorFetch;
+        this.operatorStorage = operatorStorage;
+        this.entityManager = entityManager;
+        this.options = options;
+        this.eventEmitter = new EventEmitter__default["default"]();
+        this.cronJob = new cron.CronJob((options === null || options === void 0 ? void 0 : options.subscribeInterval) || '*/10 * * * * *', this.cronHandler);
+    }
+    async cronHandler() {
+        try {
+            const result = await this.update('latest');
+            if (!result)
+                return;
+            this.eventEmitter.emit('result', result);
+        }
+        catch (error) {
+            this.eventEmitter.emit('error', error);
+        }
+    }
+    collectListenerCount() {
+        return (this.eventEmitter.listenerCount('result') +
+            this.eventEmitter.listenerCount('error'));
+    }
+    subscribe(cb) {
+        this.cronJob.start();
+        const resultCb = (result) => cb(null, result);
+        this.eventEmitter.addListener('result', resultCb);
+        this.eventEmitter.addListener('error', cb);
+        return () => {
+            this.eventEmitter.off('result', resultCb);
+            this.eventEmitter.off('error', cb);
+            if (!this.collectListenerCount()) {
+                this.cronJob.stop();
+            }
+        };
+    }
+    /** collects changed data from the contract and store it to the db */
+    async update(blockHashOrBlockTag) {
+        var _a, _b, _c, _d, _e;
+        const prevMeta = await this.getMetaDataFromStorage();
+        const currMeta = await this.getMetaDataFromContract(blockHashOrBlockTag);
+        const isSameContractState = meta_utils.compareMeta(prevMeta, currMeta);
+        this.logger.log('Collected metadata', { prevMeta, currMeta });
+        const previousBlockNumber = (_a = prevMeta === null || prevMeta === void 0 ? void 0 : prevMeta.blockNumber) !== null && _a !== void 0 ? _a : -1;
+        const currentBlockNumber = currMeta.blockNumber;
+        if (previousBlockNumber > currentBlockNumber) {
+            this.logger.warn('Previous data is newer than current data');
+            return;
+        }
+        if (isSameContractState) {
+            (_c = (_b = this.logger).debug) === null || _c === void 0 ? void 0 : _c.call(_b, 'Same state, no data update required', { currMeta });
+            await this.metaStorage.save(currMeta);
+            (_e = (_d = this.logger).debug) === null || _e === void 0 ? void 0 : _e.call(_d, 'Updated metadata in the DB', { currMeta });
+            return;
+        }
+        const blockHash = currMeta.blockHash;
+        const previousOperators = await this.getOperatorsFromStorage();
+        const currentOperators = await this.getOperatorsFromContract(blockHash);
+        this.logger.log('Collected operators', {
+            previousOperators: previousOperators.length,
+            currentOperators: currentOperators.length,
+        });
+        const updatedKeys = await this.getUpdatedKeysFromContract(previousOperators, currentOperators, blockHash);
+        this.logger.log('Fetched updated keys', {
+            updatedKeys: updatedKeys.length,
+        });
+        // save all data in a transaction
+        await this.entityManager.transactional(async (entityManager) => {
+            updatedKeys.forEach(async (operatorKey) => {
+                const instance = new key_entity.RegistryKey(operatorKey);
+                entityManager.persist(instance);
+            });
+            currentOperators.forEach(async (operator) => {
+                const instance = new operator_entity.RegistryOperator(operator);
+                entityManager.persist(instance);
+            });
+            const meta = new meta_entity.RegistryMeta(currMeta);
+            entityManager.persist(meta);
+        });
+        this.logger.log('Saved data to the DB', {
+            operators: currentOperators.length,
+            updatedKeys: updatedKeys.length,
+            currMeta,
+        });
+        return updatedKeys;
+    }
+    /** contract */
+    /** returns the meta data from the contract */
+    async getMetaDataFromContract(blockHashOrBlockTag) {
+        const { provider } = this.registryContract;
+        const block = await provider.getBlock(blockHashOrBlockTag);
+        const blockHash = block.hash;
+        const blockTag = { blockHash };
+        const keysOpIndex = await this.metaFetch.fetchKeysOpIndex({ blockTag });
+        return {
+            blockNumber: block.number,
+            blockHash,
+            keysOpIndex,
+            timestamp: block.timestamp,
+        };
+    }
+    /** returns operators from the contract */
+    async getOperatorsFromContract(blockHash) {
+        const overrides = { blockTag: { blockHash } };
+        return await this.operatorFetch.fetch(0, -1, overrides);
+    }
+    /** returns updated keys from the contract */
+    async getUpdatedKeysFromContract(previousOperators, currentOperators, blockHash) {
+        /**
+         * TODO: optimize a number of queries
+         * it's possible to update keys faster by using different strategies depending on the reason for the update
+         */
+        const keysByOperator = await Promise.all(currentOperators.map(async (currOperator, currentIndex) => {
+            var _a;
+            // check if the operator in the registry has changed since the last update
+            const prevOperator = (_a = previousOperators[currentIndex]) !== null && _a !== void 0 ? _a : null;
+            const isSameOperator = operator_utils.compareOperators(prevOperator, currOperator);
+            // 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 fromIndex = unchangedKeysMaxIndex;
+            const toIndex = this.getToIndex(currOperator);
+            const operatorIndex = currOperator.index;
+            const overrides = { blockTag: { blockHash } };
+            const result = await this.keyFetch.fetch(operatorIndex, fromIndex, toIndex, overrides);
+            this.logger.log('Keys fetched', {
+                operatorIndex,
+                fromIndex,
+                toIndex,
+                fetchedKeys: result.length,
+            });
+            return result;
+        }));
+        return keysByOperator.flat();
+    }
+    /** storage */
+    /** returns the latest meta data from the db */
+    async getMetaDataFromStorage() {
+        return await this.metaStorage.get();
+    }
+    /** returns the latest operators data from the db */
+    async getOperatorsFromStorage() {
+        return await this.operatorStorage.findAll();
+    }
+    /** clears the db */
+    async clear() {
+        await this.entityManager.transactional(async (entityManager) => {
+            entityManager.nativeDelete(key_entity.RegistryKey, {});
+            entityManager.nativeDelete(operator_entity.RegistryOperator, {});
+            entityManager.nativeDelete(meta_entity.RegistryMeta, {});
+        });
+    }
+};
+tslib.__decorate([
+    decorators.OneAtTime(),
+    tslib.__metadata("design:type", Function),
+    tslib.__metadata("design:paramtypes", []),
+    tslib.__metadata("design:returntype", Promise)
+], exports.AbstractRegistryService.prototype, "cronHandler", null);
+exports.AbstractRegistryService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__param(0, common.Inject(contracts.REGISTRY_CONTRACT_TOKEN)),
+    tslib.__param(1, common.Inject(logger.LOGGER_PROVIDER)),
+    tslib.__param(9, common.Optional()),
+    tslib.__param(9, common.Inject(constants.REGISTRY_GLOBAL_OPTIONS_TOKEN)),
+    tslib.__metadata("design:paramtypes", [Object, Object, meta_fetch.RegistryMetaFetchService,
+        meta_storage.RegistryMetaStorageService,
+        key_fetch.RegistryKeyFetchService,
+        key_storage.RegistryKeyStorageService,
+        operator_fetch.RegistryOperatorFetchService,
+        operator_storage.RegistryOperatorStorageService,
+        sqlite.EntityManager, Object])
+], exports.AbstractRegistryService);

package/dist/main/constants.d.ts

@@ -0,0 +1 @@
+export declare const REGISTRY_GLOBAL_OPTIONS_TOKEN: unique symbol;

package/dist/main/constants.js

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

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

@@ -0,0 +1,11 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { RegistryFetchOptions } from '../../fetch/interfaces/module.interface';
+export interface RegistryOptions extends RegistryFetchOptions {
+    subscribeInterval?: string;
+}
+export interface RegistryModuleSyncOptions extends Pick<ModuleMetadata, 'imports'>, RegistryOptions {
+}
+export interface RegistryModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory: (...args: any[]) => Promise<RegistryOptions>;
+    inject?: any[];
+}

package/dist/main/key-registry/key-registry.module.d.ts

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

package/dist/main/key-registry/key-registry.module.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var keyRegistry_service = require('./key-registry.service.js');
+var registryStorage_module = require('../../storage/registry-storage.module.js');
+var registryFetch_module = require('../../fetch/registry-fetch.module.js');
+var constants = require('../constants.js');
+
+var KeyRegistryModule_1;
+exports.KeyRegistryModule = KeyRegistryModule_1 = class KeyRegistryModule {
+    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: KeyRegistryModule_1,
+            imports: [
+                ...((options === null || options === void 0 ? void 0 : options.imports) || []),
+                registryFetch_module.RegistryFetchModule.forFeature(options),
+            ],
+            providers: [
+                {
+                    provide: constants.REGISTRY_GLOBAL_OPTIONS_TOKEN,
+                    useValue: options,
+                },
+            ],
+        };
+    }
+    static forFeatureAsync(options) {
+        return {
+            module: KeyRegistryModule_1,
+            imports: [
+                ...(options.imports || []),
+                registryFetch_module.RegistryFetchModule.forFeatureAsync(options),
+            ],
+            providers: [
+                {
+                    provide: constants.REGISTRY_GLOBAL_OPTIONS_TOKEN,
+                    useFactory: options.useFactory,
+                },
+            ],
+        };
+    }
+};
+exports.KeyRegistryModule = KeyRegistryModule_1 = tslib.__decorate([
+    common.Module({
+        imports: [registryStorage_module.RegistryStorageModule],
+        providers: [keyRegistry_service.KeyRegistryService],
+        exports: [keyRegistry_service.KeyRegistryService],
+    })
+], exports.KeyRegistryModule);

package/dist/main/key-registry/key-registry.service.d.ts

@@ -0,0 +1,9 @@
+import { RegistryOperator } from '../../storage/operator.entity';
+import { AbstractRegistryService } from '../abstract-registry';
+export declare class KeyRegistryService extends AbstractRegistryService {
+    getToIndex(currOperator: RegistryOperator): number;
+    /** returns all operators keys from the db */
+    getAllKeysFromStorage(): Promise<import("../..").RegistryKey[]>;
+    /** returns used keys from the db */
+    getUsedKeysFromStorage(): Promise<import("../..").RegistryKey[]>;
+}

package/dist/main/key-registry/key-registry.service.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRegistry = require('../abstract-registry.js');
+
+class KeyRegistryService extends abstractRegistry.AbstractRegistryService {
+    getToIndex(currOperator) {
+        // the right border for updating range is all operator keys
+        return currOperator.totalSigningKeys;
+    }
+    /** returns all operators keys from the db */
+    async getAllKeysFromStorage() {
+        return await this.keyStorage.findAll();
+    }
+    /** returns used keys from the db */
+    async getUsedKeysFromStorage() {
+        return await this.keyStorage.findUsed();
+    }
+}
+
+exports.KeyRegistryService = KeyRegistryService;

package/dist/main/validator-registry/validator-registry.module.d.ts

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

package/dist/main/validator-registry/validator-registry.module.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var validatorRegistry_service = require('./validator-registry.service.js');
+var registryStorage_module = require('../../storage/registry-storage.module.js');
+var registryFetch_module = require('../../fetch/registry-fetch.module.js');
+var constants = require('../constants.js');
+
+var ValidatorRegistryModule_1;
+exports.ValidatorRegistryModule = ValidatorRegistryModule_1 = class ValidatorRegistryModule {
+    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: ValidatorRegistryModule_1,
+            imports: [
+                ...((options === null || options === void 0 ? void 0 : options.imports) || []),
+                registryFetch_module.RegistryFetchModule.forFeature(options),
+            ],
+            providers: [
+                {
+                    provide: constants.REGISTRY_GLOBAL_OPTIONS_TOKEN,
+                    useValue: options,
+                },
+            ],
+        };
+    }
+    static forFeatureAsync(options) {
+        return {
+            module: ValidatorRegistryModule_1,
+            imports: [
+                ...(options.imports || []),
+                registryFetch_module.RegistryFetchModule.forFeatureAsync(options),
+            ],
+            providers: [
+                {
+                    provide: constants.REGISTRY_GLOBAL_OPTIONS_TOKEN,
+                    useFactory: options.useFactory,
+                },
+            ],
+        };
+    }
+};
+exports.ValidatorRegistryModule = ValidatorRegistryModule_1 = tslib.__decorate([
+    common.Module({
+        imports: [registryStorage_module.RegistryStorageModule],
+        providers: [validatorRegistry_service.ValidatorRegistryService],
+        exports: [validatorRegistry_service.ValidatorRegistryService],
+    })
+], exports.ValidatorRegistryModule);

package/dist/main/validator-registry/validator-registry.service.d.ts

@@ -0,0 +1,7 @@
+import { RegistryOperator } from '../../storage/operator.entity';
+import { AbstractRegistryService } from '../abstract-registry';
+export declare class ValidatorRegistryService extends AbstractRegistryService {
+    getToIndex(currOperator: RegistryOperator): number;
+    /** returns used keys from the db */
+    getValidatorsKeysFromStorage(): Promise<import("../..").RegistryKey[]>;
+}

package/dist/main/validator-registry/validator-registry.service.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRegistry = require('../abstract-registry.js');
+
+class ValidatorRegistryService extends abstractRegistry.AbstractRegistryService {
+    getToIndex(currOperator) {
+        // the right border for updating range is used keys
+        return currOperator.usedSigningKeys;
+    }
+    /** returns used keys from the db */
+    async getValidatorsKeysFromStorage() {
+        return await this.keyStorage.findUsed();
+    }
+}
+
+exports.ValidatorRegistryService = ValidatorRegistryService;

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

@@ -0,0 +1,9 @@
+import { ModuleMetadata } from '@nestjs/common';
+export interface RegistryStorageOptions {
+}
+export interface RegistryStorageModuleSyncOptions extends Pick<ModuleMetadata, 'imports'>, RegistryStorageOptions {
+}
+export interface RegistryStorageModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory: (...args: any[]) => Promise<RegistryStorageOptions>;
+    inject?: any[];
+}

package/dist/storage/key.entity.d.ts

@@ -0,0 +1,12 @@
+import { EntityRepositoryType, PrimaryKeyType } from '@mikro-orm/core';
+import { RegistryKeyRepository } from './key.repository';
+export declare class RegistryKey {
+    [EntityRepositoryType]?: RegistryKeyRepository;
+    [PrimaryKeyType]?: [number, number];
+    constructor(operatorKey: RegistryKey);
+    index: number;
+    operatorIndex: number;
+    key: string;
+    depositSignature: string;
+    used: boolean;
+}

package/dist/storage/key.entity.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@mikro-orm/core');
+var key_repository = require('./key.repository.js');
+
+exports.RegistryKey = class RegistryKey {
+    constructor(operatorKey) {
+        this.index = operatorKey.index;
+        this.operatorIndex = operatorKey.operatorIndex;
+        this.key = operatorKey.key.toLocaleLowerCase();
+        this.depositSignature = operatorKey.depositSignature.toLocaleLowerCase();
+        this.used = operatorKey.used;
+    }
+};
+tslib.__decorate([
+    core.PrimaryKey(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryKey.prototype, "index", void 0);
+tslib.__decorate([
+    core.PrimaryKey(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryKey.prototype, "operatorIndex", void 0);
+tslib.__decorate([
+    core.Property({ length: 98 }),
+    tslib.__metadata("design:type", String)
+], exports.RegistryKey.prototype, "key", void 0);
+tslib.__decorate([
+    core.Property({ length: 194 }),
+    tslib.__metadata("design:type", String)
+], exports.RegistryKey.prototype, "depositSignature", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Boolean)
+], exports.RegistryKey.prototype, "used", void 0);
+exports.RegistryKey = tslib.__decorate([
+    core.Entity({ customRepository: () => key_repository.RegistryKeyRepository }),
+    tslib.__metadata("design:paramtypes", [exports.RegistryKey])
+], exports.RegistryKey);

package/dist/storage/key.repository.d.ts

@@ -0,0 +1,4 @@
+import { EntityRepository } from '@mikro-orm/sqlite';
+import { RegistryKey } from './key.entity';
+export declare class RegistryKeyRepository extends EntityRepository<RegistryKey> {
+}

package/dist/storage/key.repository.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sqlite = require('@mikro-orm/sqlite');
+
+class RegistryKeyRepository extends sqlite.EntityRepository {
+}
+
+exports.RegistryKeyRepository = RegistryKeyRepository;

package/dist/storage/key.storage.d.ts

@@ -0,0 +1,22 @@
+import { RegistryKey } from './key.entity';
+import { RegistryKeyRepository } from './key.repository';
+export declare class RegistryKeyStorageService {
+    private readonly repository;
+    constructor(repository: RegistryKeyRepository);
+    /** find all keys */
+    findAll(): Promise<RegistryKey[]>;
+    /** find used keys */
+    findUsed(): Promise<RegistryKey[]>;
+    /** find all keys by operator */
+    findByOperatorIndex(operatorIndex: number): Promise<RegistryKey[]>;
+    /** find key by index */
+    findOneByIndex(operatorIndex: number, keyIndex: number): Promise<RegistryKey | null>;
+    /** removes key by index */
+    removeOneByIndex(operatorIndex: number, keyIndex: number): Promise<number>;
+    /** removes all keys */
+    removeAll(): Promise<number>;
+    /** saves key to storage */
+    saveOne(operatorKey: RegistryKey): Promise<void>;
+    /** saves multiply keys to storage */
+    save(operatorKeys: RegistryKey[]): Promise<import("@mikro-orm/core").EntityManager<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>>[]>;
+}

package/dist/storage/key.storage.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var key_entity = require('./key.entity.js');
+var key_repository = require('./key.repository.js');
+
+exports.RegistryKeyStorageService = class RegistryKeyStorageService {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    /** find all keys */
+    async findAll() {
+        return await this.repository.findAll();
+    }
+    /** find used keys */
+    async findUsed() {
+        return await this.repository.find({ used: true });
+    }
+    /** find all keys by operator */
+    async findByOperatorIndex(operatorIndex) {
+        return await this.repository.find({ operatorIndex });
+    }
+    /** find key by index */
+    async findOneByIndex(operatorIndex, keyIndex) {
+        return await this.repository.findOne({ operatorIndex, index: keyIndex });
+    }
+    /** removes key by index */
+    async removeOneByIndex(operatorIndex, keyIndex) {
+        return await this.repository.nativeDelete({
+            operatorIndex,
+            index: keyIndex,
+        });
+    }
+    /** removes all keys */
+    async removeAll() {
+        return await this.repository.nativeDelete({});
+    }
+    /** saves key to storage */
+    async saveOne(operatorKey) {
+        const key = new key_entity.RegistryKey(operatorKey);
+        return await this.repository.persistAndFlush(key);
+    }
+    /** saves multiply keys to storage */
+    async save(operatorKeys) {
+        const result = await Promise.all(operatorKeys.map(async (operatorKey) => {
+            const instance = new key_entity.RegistryKey(operatorKey);
+            return await this.repository.persist(instance);
+        }));
+        this.repository.flush();
+        return result;
+    }
+};
+exports.RegistryKeyStorageService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [key_repository.RegistryKeyRepository])
+], exports.RegistryKeyStorageService);

package/dist/storage/meta.entity.d.ts

@@ -0,0 +1,10 @@
+import { EntityRepositoryType } from '@mikro-orm/core';
+import { RegistryMetaRepository } from './meta.repository';
+export declare class RegistryMeta {
+    [EntityRepositoryType]?: RegistryMetaRepository;
+    constructor(meta: RegistryMeta);
+    blockNumber: number;
+    blockHash: string;
+    keysOpIndex: number;
+    timestamp: number;
+}

package/dist/storage/meta.entity.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@mikro-orm/core');
+var meta_repository = require('./meta.repository.js');
+
+exports.RegistryMeta = class RegistryMeta {
+    constructor(meta) {
+        this.blockNumber = meta.blockNumber;
+        this.blockHash = meta.blockHash.toLocaleLowerCase();
+        this.keysOpIndex = meta.keysOpIndex;
+        this.timestamp = meta.timestamp;
+    }
+};
+tslib.__decorate([
+    core.PrimaryKey(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryMeta.prototype, "blockNumber", void 0);
+tslib.__decorate([
+    core.Property({ length: 66 }),
+    tslib.__metadata("design:type", String)
+], exports.RegistryMeta.prototype, "blockHash", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryMeta.prototype, "keysOpIndex", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryMeta.prototype, "timestamp", void 0);
+exports.RegistryMeta = tslib.__decorate([
+    core.Entity({ customRepository: () => meta_repository.RegistryMetaRepository }),
+    tslib.__metadata("design:paramtypes", [exports.RegistryMeta])
+], exports.RegistryMeta);

package/dist/storage/meta.repository.d.ts

@@ -0,0 +1,4 @@
+import { EntityRepository } from '@mikro-orm/sqlite';
+import { RegistryMeta } from './meta.entity';
+export declare class RegistryMetaRepository extends EntityRepository<RegistryMeta> {
+}

package/dist/storage/meta.repository.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sqlite = require('@mikro-orm/sqlite');
+
+class RegistryMetaRepository extends sqlite.EntityRepository {
+}
+
+exports.RegistryMetaRepository = RegistryMetaRepository;