@lido-nestjs/registry 1.0.0

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

@@ -0,0 +1,12 @@
+import { RegistryMeta } from './meta.entity';
+import { RegistryMetaRepository } from './meta.repository';
+export declare class RegistryMetaStorageService {
+    private readonly repository;
+    constructor(repository: RegistryMetaRepository);
+    /** returns meta */
+    get(): Promise<RegistryMeta | null>;
+    /** removes meta */
+    remove(): Promise<number>;
+    /** saves meta */
+    save(registryMeta: RegistryMeta): Promise<void>;
+}

package/dist/storage/meta.storage.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var core = require('@mikro-orm/core');
+var meta_entity = require('./meta.entity.js');
+var meta_repository = require('./meta.repository.js');
+
+exports.RegistryMetaStorageService = class RegistryMetaStorageService {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    /** returns meta */
+    async get() {
+        var _a;
+        const result = await this.repository.find({}, { orderBy: { blockNumber: core.QueryOrder.DESC }, limit: 1 });
+        return (_a = result[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    /** removes meta */
+    async remove() {
+        return await this.repository.nativeDelete({});
+    }
+    /** saves meta */
+    async save(registryMeta) {
+        const metaData = new meta_entity.RegistryMeta(registryMeta);
+        return await this.repository.persistAndFlush(metaData);
+    }
+};
+exports.RegistryMetaStorageService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [meta_repository.RegistryMetaRepository])
+], exports.RegistryMetaStorageService);

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

@@ -0,0 +1,14 @@
+import { EntityRepositoryType } from '@mikro-orm/core';
+import { RegistryOperatorRepository } from './operator.repository';
+export declare class RegistryOperator {
+    [EntityRepositoryType]?: RegistryOperatorRepository;
+    constructor(operator: RegistryOperator);
+    index: number;
+    active: boolean;
+    name: string;
+    rewardAddress: string;
+    stakingLimit: number;
+    stoppedValidators: number;
+    totalSigningKeys: number;
+    usedSigningKeys: number;
+}

package/dist/storage/operator.entity.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@mikro-orm/core');
+var operator_repository = require('./operator.repository.js');
+
+exports.RegistryOperator = class RegistryOperator {
+    constructor(operator) {
+        this.index = operator.index;
+        this.active = operator.active;
+        this.name = operator.name;
+        this.rewardAddress = operator.rewardAddress.toLocaleLowerCase();
+        this.stakingLimit = operator.stakingLimit;
+        this.stoppedValidators = operator.stoppedValidators;
+        this.totalSigningKeys = operator.totalSigningKeys;
+        this.usedSigningKeys = operator.usedSigningKeys;
+    }
+};
+tslib.__decorate([
+    core.PrimaryKey(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryOperator.prototype, "index", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Boolean)
+], exports.RegistryOperator.prototype, "active", void 0);
+tslib.__decorate([
+    core.Property({ length: 256 }),
+    tslib.__metadata("design:type", String)
+], exports.RegistryOperator.prototype, "name", void 0);
+tslib.__decorate([
+    core.Property({ length: 42 }),
+    tslib.__metadata("design:type", String)
+], exports.RegistryOperator.prototype, "rewardAddress", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryOperator.prototype, "stakingLimit", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryOperator.prototype, "stoppedValidators", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryOperator.prototype, "totalSigningKeys", void 0);
+tslib.__decorate([
+    core.Property(),
+    tslib.__metadata("design:type", Number)
+], exports.RegistryOperator.prototype, "usedSigningKeys", void 0);
+exports.RegistryOperator = tslib.__decorate([
+    core.Entity({ customRepository: () => operator_repository.RegistryOperatorRepository }),
+    tslib.__metadata("design:paramtypes", [exports.RegistryOperator])
+], exports.RegistryOperator);

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

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

package/dist/storage/operator.repository.js

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

package/dist/storage/operator.storage.d.ts

@@ -0,0 +1,18 @@
+import { RegistryOperator } from './operator.entity';
+import { RegistryOperatorRepository } from './operator.repository';
+export declare class RegistryOperatorStorageService {
+    private readonly repository;
+    constructor(repository: RegistryOperatorRepository);
+    /** find all operators */
+    findAll(): Promise<RegistryOperator[]>;
+    /** find operator by index */
+    findOneByIndex(operatorIndex: number): Promise<RegistryOperator | null>;
+    /** removes operator by index */
+    removeOneByIndex(operatorIndex: number): Promise<number>;
+    /** removes all operators */
+    removeAll(): Promise<number>;
+    /** saves operator to storage */
+    saveOne(operator: RegistryOperator): Promise<void>;
+    /** saves multiply operators to storage */
+    save(operators: RegistryOperator[]): Promise<import("@mikro-orm/core").EntityManager<import("@mikro-orm/core").IDatabaseDriver<import("@mikro-orm/core").Connection>>[]>;
+}

package/dist/storage/operator.storage.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var operator_entity = require('./operator.entity.js');
+var operator_repository = require('./operator.repository.js');
+
+exports.RegistryOperatorStorageService = class RegistryOperatorStorageService {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    /** find all operators */
+    async findAll() {
+        return await this.repository.findAll();
+    }
+    /** find operator by index */
+    async findOneByIndex(operatorIndex) {
+        return await this.repository.findOne({ index: operatorIndex });
+    }
+    /** removes operator by index */
+    async removeOneByIndex(operatorIndex) {
+        return await this.repository.nativeDelete({ index: operatorIndex });
+    }
+    /** removes all operators */
+    async removeAll() {
+        return await this.repository.nativeDelete({});
+    }
+    /** saves operator to storage */
+    async saveOne(operator) {
+        const key = new operator_entity.RegistryOperator(operator);
+        return await this.repository.persistAndFlush(key);
+    }
+    /** saves multiply operators to storage */
+    async save(operators) {
+        const result = await Promise.all(operators.map(async (operator) => {
+            const instance = new operator_entity.RegistryOperator(operator);
+            return await this.repository.persist(instance);
+        }));
+        this.repository.flush();
+        return result;
+    }
+};
+exports.RegistryOperatorStorageService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [operator_repository.RegistryOperatorRepository])
+], exports.RegistryOperatorStorageService);

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

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

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

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var registryStorage_service = require('./registry-storage.service.js');
+var operator_storage = require('./operator.storage.js');
+var meta_storage = require('./meta.storage.js');
+var key_storage = require('./key.storage.js');
+var nestjs = require('@mikro-orm/nestjs');
+var key_entity = require('./key.entity.js');
+var operator_entity = require('./operator.entity.js');
+var meta_entity = require('./meta.entity.js');
+
+var RegistryStorageModule_1;
+exports.RegistryStorageModule = RegistryStorageModule_1 = class RegistryStorageModule {
+    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: RegistryStorageModule_1,
+            imports: options === null || options === void 0 ? void 0 : options.imports,
+        };
+    }
+    static forFeatureAsync(options) {
+        return {
+            module: RegistryStorageModule_1,
+            imports: options.imports,
+        };
+    }
+};
+exports.RegistryStorageModule = RegistryStorageModule_1 = tslib.__decorate([
+    common.Module({
+        imports: [
+            nestjs.MikroOrmModule.forFeature({
+                entities: [key_entity.RegistryKey, operator_entity.RegistryOperator, meta_entity.RegistryMeta],
+            }),
+        ],
+        providers: [
+            registryStorage_service.RegistryStorageService,
+            operator_storage.RegistryOperatorStorageService,
+            meta_storage.RegistryMetaStorageService,
+            key_storage.RegistryKeyStorageService,
+        ],
+        exports: [
+            registryStorage_service.RegistryStorageService,
+            operator_storage.RegistryOperatorStorageService,
+            meta_storage.RegistryMetaStorageService,
+            key_storage.RegistryKeyStorageService,
+        ],
+    })
+], exports.RegistryStorageModule);

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

@@ -0,0 +1,8 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { MikroORM } from '@mikro-orm/core';
+export declare class RegistryStorageService implements OnModuleInit, OnModuleDestroy {
+    private readonly orm;
+    constructor(orm: MikroORM);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var core = require('@mikro-orm/core');
+
+exports.RegistryStorageService = class RegistryStorageService {
+    constructor(orm) {
+        this.orm = orm;
+    }
+    async onModuleInit() {
+        // TODO: think about migrations
+        const generator = this.orm.getSchemaGenerator();
+        await generator.updateSchema();
+    }
+    async onModuleDestroy() {
+        await this.orm.close();
+    }
+};
+exports.RegistryStorageService = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [core.MikroORM])
+], exports.RegistryStorageService);

package/dist/utils/meta.utils.d.ts

@@ -0,0 +1,2 @@
+import { RegistryMeta } from '../storage/meta.entity';
+export declare const compareMeta: (metaOne: RegistryMeta | null, metaTwo: RegistryMeta | null) => boolean;

package/dist/utils/meta.utils.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const compareMeta = (metaOne, metaTwo) => {
+    if (metaOne == null)
+        return false;
+    if (metaTwo == null)
+        return false;
+    const keysOpIndexOne = metaOne.keysOpIndex;
+    const keysOpIndexTwo = metaTwo.keysOpIndex;
+    return keysOpIndexOne === keysOpIndexTwo;
+};
+
+exports.compareMeta = compareMeta;

package/dist/utils/operator.utils.d.ts

@@ -0,0 +1,2 @@
+import { RegistryOperator } from '../storage/operator.entity';
+export declare const compareOperators: (operatorOne: RegistryOperator | null, operatorTwo: RegistryOperator | null) => boolean;

package/dist/utils/operator.utils.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const compareOperators = (operatorOne, operatorTwo) => {
+    if (operatorOne == null)
+        return false;
+    if (operatorTwo == null)
+        return false;
+    const addressOne = operatorOne.rewardAddress.toLocaleLowerCase();
+    const addressTwo = operatorTwo.rewardAddress.toLocaleLowerCase();
+    if (addressOne !== addressTwo)
+        return false;
+    return true;
+};
+
+exports.compareOperators = compareOperators;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@lido-nestjs/registry",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "homepage": "https://github.com/lidofinance/lido-nestjs-modules",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lidofinance/lido-nestjs-modules.git",
+    "directory": "packages/registry"
+  },
+  "bugs": {
+    "url": "https://github.com/lidofinance/lido-nestjs-modules/issues"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "lido",
+    "lido-nestjs",
+    "lido-nestjs-modules",
+    "lidofinance"
+  ],
+  "files": [
+    "dist/*"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@lido-nestjs/contracts": "2.1.0",
+    "@lido-nestjs/decorators": "1.0.0",
+    "@lido-nestjs/logger": "1.1.0",
+    "@lido-nestjs/utils": "1.1.0",
+    "@mikro-orm/core": "^5.0.1",
+    "@mikro-orm/nestjs": "^4.3.1",
+    "@mikro-orm/sqlite": "^5.0.3",
+    "cron": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^8.2.5",
+    "@nestjs/core": "^8.2.5",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.5.2",
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "@lido-nestjs/execution": "1.7.0",
+    "@nestjs/common": "^8.2.5",
+    "@nestjs/core": "^8.2.5",
+    "@nestjs/testing": "^8.2.5",
+    "@types/cron": "^2",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.5.2"
+  }
+}