@rosen-bridge/abstract-extractor 2.0.3 → 2.1.0

package/dist/lib/ergo/AbstractErgoExtractorAction.js

@@ -0,0 +1,222 @@
+import { In, Not, } from '@rosen-bridge/extended-typeorm';
+import { chunk, difference, pick } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { DB_CHUNK_SIZE } from '../constants';
+export class AbstractErgoExtractorAction {
+    datasource;
+    logger;
+    repository;
+    repo;
+    constructor(dataSource, repo, logger) {
+        this.datasource = dataSource;
+        this.logger = logger ? logger : new DummyLogger();
+        this.repository = this.datasource.getRepository(repo);
+        this.repo = repo;
+    }
+    /**
+     * create the database entity from extracted data and block information
+     */
+    createEntity = (data, // eslint-disable-line @typescript-eslint/no-unused-vars
+    block, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor) => {
+        throw Error('You must implement `createEntity` or override `insertEntities` and `updateEntities`');
+    };
+    /**
+     * convert the database entity back to raw data
+     */
+    convertEntityToData = (entities) => {
+        throw Error('You must implement `convertEntityToData` or override `deleteBlockEntities`');
+    };
+    /**
+     * insert entities extracted from a block to database
+     * @param queryRunner
+     * @param boxesToInsert
+     * @param block
+     * @param extractor
+     */
+    insertEntities = async (queryRunner, boxesToInsert, block, extractor) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        await repository.insert(this.createEntity(boxesToInsert, block, extractor));
+    };
+    /**
+     * update entities related to a box
+     * @param queryRunner
+     * @param updateBox
+     * @param block
+     * @param extractor
+     */
+    updateEntity = async (queryRunner, updateBox, // eslint-disable-line @typescript-eslint/no-unused-vars
+    block, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        const box = this.createEntity([updateBox], block, extractor)[0];
+        await repository.update({
+            boxId: box.boxId,
+            extractor: extractor,
+        }, box);
+    };
+    /**
+     * delete all data extracted from a block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    deleteBlockEntities = async (queryRunner, extractor, block) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        const deletedData = await repository.find({
+            where: {
+                extractor: extractor,
+                block: block,
+            },
+        });
+        await repository.delete({
+            extractor: extractor,
+            block: block,
+        });
+        return this.convertEntityToData(deletedData);
+    };
+    /**
+     * delete all data extracted from a block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    updateBlockEntities = async (queryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor, block) => {
+        const repository = this.datasource.getRepository(this.repo);
+        const updatedData = await repository.find({
+            where: {
+                extractor: extractor,
+                spendBlock: block,
+                block: Not(block),
+            },
+        });
+        await repository.update({
+            spendBlock: block,
+            extractor: extractor,
+        }, {
+            spendBlock: null,
+            spendHeight: 0,
+        });
+        return updatedData;
+    };
+    /**
+     * insert all extracted box data in an atomic transaction
+     * update the data if a box with the same id is already stored in db
+     * @param boxes
+     * @param block
+     * @param extractor
+     * @return inserted items and updated box ids
+     * returns undefined in case of any problem
+     */
+    storeBoxes = async (boxes, block, extractor) => {
+        let boxesToInsert = [], boxesToUpdate = [];
+        const queryRunner = this.datasource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const repository = queryRunner.manager.getRepository(this.repo);
+            const dbBoxIds = (await repository.findBy({
+                boxId: In(boxes.map((item) => item.boxId)),
+                extractor: extractor,
+            })).map((box) => box.boxId);
+            if (dbBoxIds.length > 0)
+                this.logger.debug(`Found stored boxes with same boxId`, dbBoxIds);
+            boxesToUpdate = boxes.filter((box) => dbBoxIds.includes(box.boxId));
+            boxesToInsert = difference(boxes, boxesToUpdate);
+            if (boxesToInsert.length > 0) {
+                this.logger.debug(`Inserting boxes`);
+                await this.insertEntities(queryRunner, boxesToInsert, block, extractor);
+            }
+            if (boxesToUpdate.length > 0)
+                this.logger.info(`Updating boxes with following Ids in the database: [${boxesToUpdate
+                    .map((col) => col.boxId)
+                    .join(', ')}]`);
+            for (const box of boxesToUpdate) {
+                this.logger.debug(`Updating boxes in database [${JsonBigInt.stringify(box)}]`);
+                await this.updateEntity(queryRunner, box, block, extractor);
+            }
+            await queryRunner.commitTransaction();
+            return true;
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store boxes action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            return false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    };
+    /**
+     * update spending information of stored boxes
+     * chunk spendInfos to prevent large database queries
+     * Note: It only updates the spendHeight and spendBlock fields. If updating
+     * anything else is required, override this implementation to include the
+     * additional fields.
+     * @param spendInfos
+     * @param block
+     * @param extractor
+     * @returns spent box ids
+     */
+    spendBoxes = async (spendInfos, block, extractor) => {
+        const spentData = [];
+        const spendInfoChunks = chunk(spendInfos, DB_CHUNK_SIZE);
+        for (const spendInfoChunk of spendInfoChunks) {
+            const boxIds = spendInfoChunk.map((info) => info.boxId);
+            const updateResult = await this.repository.update({
+                boxId: In(boxIds),
+                extractor: extractor,
+            }, {
+                spendBlock: block.hash,
+                spendHeight: block.height,
+            });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const spentRows = await this.repository.findBy({
+                    boxId: In(boxIds),
+                    spendBlock: block.hash,
+                });
+                spentData.push(...spentRows);
+                for (const row of spentRows) {
+                    this.logger.debug(`Spent box with boxId [${row.boxId}] at height ${block.height}`);
+                }
+            }
+        }
+        return spentData.map((data) => pick(data, 'boxId'));
+    };
+    /**
+     * delete extracted data from a specific block
+     * if a box is spend in this block mark it as unspent
+     * if a box is created in this block remove it from database
+     * @param block
+     * @param extractor
+     * @return deleted items and updated box ids
+     */
+    deleteBlockBoxes = async (block, extractor) => {
+        const queryRunner = this.datasource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            this.logger.info(`Deleting boxes in block ${block} and extractor ${extractor}`);
+            const updatedData = await this.updateBlockEntities(queryRunner, extractor, block);
+            const deletedData = await this.deleteBlockEntities(queryRunner, extractor, block);
+            await queryRunner.commitTransaction();
+            return {
+                deletedData,
+                updatedData: updatedData.map((data) => pick(data, 'boxId')),
+            };
+        }
+        catch (error) {
+            await queryRunner.rollbackTransaction();
+            this.logger.error(`An error occurred while deleting data extracted from block ${block}`, error);
+            throw error;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractErgoExtractorAction.js","sourceRoot":"","sources":["../../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DataSource,\n  In,\n  Repository,\n  Not,\n  EntityTarget,\n  FindOptionsWhere,\n  QueryRunner,\n} from '@rosen-bridge/extended-typeorm';\nimport { chunk, difference, pick } from 'lodash-es';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractBoxData, BoxInfo, SpendInfo } from './interfaces';\nimport { DB_CHUNK_SIZE } from '../constants';\nimport { AbstractErgoExtractorEntity } from './AbstractErgoExtractorEntity';\n\nexport abstract class AbstractErgoExtractorAction<\n  ExtractedData extends AbstractBoxData,\n  ExtractorEntity extends AbstractErgoExtractorEntity,\n> {\n  private readonly datasource: DataSource;\n  readonly logger: AbstractLogger;\n  protected readonly repository: Repository<ExtractorEntity>;\n  private repo: EntityTarget<ExtractorEntity>;\n\n  constructor(\n    dataSource: DataSource,\n    repo: EntityTarget<ExtractorEntity>,\n    logger?: AbstractLogger,\n  ) {\n    this.datasource = dataSource;\n    this.logger = logger ? logger : new DummyLogger();\n    this.repository = this.datasource.getRepository(repo);\n    this.repo = repo;\n  }\n\n  /**\n   * create the database entity from extracted data and block information\n   */\n  protected createEntity = (\n    data: ExtractedData[], // eslint-disable-line @typescript-eslint/no-unused-vars\n    block: BlockInfo, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string, // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): Array<Omit<ExtractorEntity, 'id'>> => {\n    throw Error(\n      'You must implement `createEntity` or override `insertEntities` and `updateEntities`',\n    );\n  };\n\n  /**\n   * convert the database entity back to raw data\n   */\n  protected convertEntityToData = (\n    entities: ExtractorEntity[], // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): ExtractedData[] => {\n    throw Error(\n      'You must implement `convertEntityToData` or override `deleteBlockEntities`',\n    );\n  };\n\n  /**\n   * insert entities extracted from a block to database\n   * @param queryRunner\n   * @param boxesToInsert\n   * @param block\n   * @param extractor\n   */\n  protected insertEntities = async (\n    queryRunner: QueryRunner,\n    boxesToInsert: Array<ExtractedData>,\n    block: BlockInfo,\n    extractor: string,\n  ) => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    await repository.insert(\n      this.createEntity(boxesToInsert, block, extractor) as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    );\n  };\n\n  /**\n   * update entities related to a box\n   * @param queryRunner\n   * @param updateBox\n   * @param block\n   * @param extractor\n   */\n  protected updateEntity = async (\n    queryRunner: QueryRunner,\n    updateBox: ExtractedData, // eslint-disable-line @typescript-eslint/no-unused-vars\n    block: BlockInfo, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string,\n  ) => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    const box = this.createEntity([updateBox], block, extractor)[0];\n    await repository.update(\n      {\n        boxId: box.boxId,\n        extractor: extractor,\n      } as FindOptionsWhere<ExtractorEntity>,\n      box as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    );\n  };\n\n  /**\n   * delete all data extracted from a block\n   * @param queryRunner\n   * @param extractor\n   * @param block\n   * @returns\n   */\n  protected deleteBlockEntities = async (\n    queryRunner: QueryRunner,\n    extractor: string,\n    block: string,\n  ): Promise<ExtractedData[]> => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    const deletedData = await repository.find({\n      where: {\n        extractor: extractor,\n        block: block,\n      } as FindOptionsWhere<ExtractorEntity>,\n    });\n    await repository.delete({\n      extractor: extractor,\n      block: block,\n    } as unknown as FindOptionsWhere<ExtractorEntity>);\n    return this.convertEntityToData(deletedData);\n  };\n\n  /**\n   * delete all data extracted from a block\n   * @param queryRunner\n   * @param extractor\n   * @param block\n   * @returns\n   */\n  protected updateBlockEntities = async (\n    queryRunner: QueryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string,\n    block: string,\n  ): Promise<ExtractorEntity[]> => {\n    const repository = this.datasource.getRepository(\n      this.repo as EntityTarget<new () => ExtractorEntity>,\n    );\n    const updatedData = await repository.find({\n      where: {\n        extractor: extractor,\n        spendBlock: block,\n        block: Not(block),\n      } as unknown as FindOptionsWhere<ExtractorEntity>,\n    });\n    await repository.update(\n      {\n        spendBlock: block,\n        extractor: extractor,\n      } as unknown as FindOptionsWhere<ExtractorEntity>,\n      {\n        spendBlock: null,\n        spendHeight: 0,\n      },\n    );\n    return updatedData as unknown as ExtractorEntity[];\n  };\n\n  /**\n   * insert all extracted box data in an atomic transaction\n   * update the data if a box with the same id is already stored in db\n   * @param boxes\n   * @param block\n   * @param extractor\n   * @return inserted items and updated box ids\n   * returns undefined in case of any problem\n   */\n  storeBoxes = async (\n    boxes: Array<ExtractedData>,\n    block: BlockInfo,\n    extractor: string,\n  ): Promise<boolean> => {\n    let boxesToInsert: ExtractedData[] = [],\n      boxesToUpdate: ExtractedData[] = [];\n    const queryRunner = this.datasource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    try {\n      const repository = queryRunner.manager.getRepository(this.repo);\n      const dbBoxIds = (\n        await repository.findBy({\n          boxId: In(boxes.map((item) => item.boxId)),\n          extractor: extractor,\n        } as FindOptionsWhere<ExtractorEntity>)\n      ).map((box) => box.boxId);\n      if (dbBoxIds.length > 0)\n        this.logger.debug(`Found stored boxes with same boxId`, dbBoxIds);\n\n      boxesToUpdate = boxes.filter((box) => dbBoxIds.includes(box.boxId));\n      boxesToInsert = difference(boxes, boxesToUpdate);\n\n      if (boxesToInsert.length > 0) {\n        this.logger.debug(`Inserting boxes`);\n        await this.insertEntities(queryRunner, boxesToInsert, block, extractor);\n      }\n      if (boxesToUpdate.length > 0)\n        this.logger.info(\n          `Updating boxes with following Ids in the database: [${boxesToUpdate\n            .map((col) => col.boxId)\n            .join(', ')}]`,\n        );\n      for (const box of boxesToUpdate) {\n        this.logger.debug(\n          `Updating boxes in database [${JsonBigInt.stringify(box)}]`,\n        );\n        await this.updateEntity(queryRunner, box, block, extractor);\n      }\n      await queryRunner.commitTransaction();\n      return true;\n    } catch (e) {\n      this.logger.error(`An error occurred during store boxes action: ${e}`);\n      await queryRunner.rollbackTransaction();\n      return false;\n    } finally {\n      await queryRunner.release();\n    }\n  };\n\n  /**\n   * update spending information of stored boxes\n   * chunk spendInfos to prevent large database queries\n   * Note: It only updates the spendHeight and spendBlock fields. If updating\n   * anything else is required, override this implementation to include the\n   * additional fields.\n   * @param spendInfos\n   * @param block\n   * @param extractor\n   * @returns spent box ids\n   */\n  spendBoxes = async (\n    spendInfos: Array<SpendInfo>,\n    block: BlockInfo,\n    extractor: string,\n  ): Promise<BoxInfo[]> => {\n    const spentData = [];\n    const spendInfoChunks = chunk(spendInfos, DB_CHUNK_SIZE);\n    for (const spendInfoChunk of spendInfoChunks) {\n      const boxIds = spendInfoChunk.map((info) => info.boxId);\n      const updateResult = await this.repository.update(\n        {\n          boxId: In(boxIds),\n          extractor: extractor,\n        } as FindOptionsWhere<ExtractorEntity>,\n        {\n          spendBlock: block.hash,\n          spendHeight: block.height,\n        } as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n      );\n\n      if (updateResult.affected && updateResult.affected > 0) {\n        const spentRows = await this.repository.findBy({\n          boxId: In(boxIds),\n          spendBlock: block.hash,\n        } as FindOptionsWhere<ExtractorEntity>);\n        spentData.push(...spentRows);\n        for (const row of spentRows) {\n          this.logger.debug(\n            `Spent box with boxId [${row.boxId}] at height ${block.height}`,\n          );\n        }\n      }\n    }\n    return spentData.map((data) => pick(data, 'boxId'));\n  };\n\n  /**\n   * delete extracted data from a specific block\n   * if a box is spend in this block mark it as unspent\n   * if a box is created in this block remove it from database\n   * @param block\n   * @param extractor\n   * @return deleted items and updated box ids\n   */\n  deleteBlockBoxes = async (\n    block: string,\n    extractor: string,\n  ): Promise<{ deletedData: ExtractedData[]; updatedData: BoxInfo[] }> => {\n    const queryRunner = this.datasource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    try {\n      this.logger.info(\n        `Deleting boxes in block ${block} and extractor ${extractor}`,\n      );\n      const updatedData = await this.updateBlockEntities(\n        queryRunner,\n        extractor,\n        block,\n      );\n      const deletedData = await this.deleteBlockEntities(\n        queryRunner,\n        extractor,\n        block,\n      );\n      await queryRunner.commitTransaction();\n      return {\n        deletedData,\n        updatedData: updatedData.map((data) => pick(data, 'boxId')),\n      };\n    } catch (error) {\n      await queryRunner.rollbackTransaction();\n      this.logger.error(\n        `An error occurred while deleting data extracted from block ${block}`,\n        error,\n      );\n      throw error;\n    } finally {\n      await queryRunner.release();\n    }\n  };\n}\n"]}

package/dist/lib/ergo/AbstractErgoExtractorEntity.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class AbstractErgoExtractorEntity {
+    id: number;
+    boxId: string;
+    block: string;
+    height: number;
+    spendBlock?: string | null;
+    spendHeight?: number | null;
+    extractor: string;
+    serialized: string;
+}
+//# sourceMappingURL=AbstractErgoExtractorEntity.d.ts.map

package/dist/lib/ergo/AbstractErgoExtractorEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractErgoExtractorEntity.d.ts","sourceRoot":"","sources":["../../../lib/ergo/AbstractErgoExtractorEntity.ts"],"names":[],"mappings":"AAMA,8BACsB,2BAA2B;IAE/C,EAAE,EAAE,MAAM,CAAC;IAGX,KAAK,EAAE,MAAM,CAAC;IAGd,KAAK,EAAE,MAAM,CAAC;IAGd,MAAM,EAAE,MAAM,CAAC;IAGf,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG5B,SAAS,EAAE,MAAM,CAAC;IAGlB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/lib/ergo/AbstractErgoExtractorEntity.js

@@ -0,0 +1,57 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Column, PrimaryGeneratedColumn, Unique, } from '@rosen-bridge/extended-typeorm';
+let AbstractErgoExtractorEntity = class AbstractErgoExtractorEntity {
+    id;
+    boxId;
+    block;
+    height;
+    spendBlock;
+    spendHeight;
+    extractor;
+    serialized;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], AbstractErgoExtractorEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "boxId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "block", void 0);
+__decorate([
+    Column({ type: 'int' }),
+    __metadata("design:type", Number)
+], AbstractErgoExtractorEntity.prototype, "height", void 0);
+__decorate([
+    Column({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], AbstractErgoExtractorEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true, type: 'int' }),
+    __metadata("design:type", Object)
+], AbstractErgoExtractorEntity.prototype, "spendHeight", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "extractor", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "serialized", void 0);
+AbstractErgoExtractorEntity = __decorate([
+    Unique(['boxId', 'extractor'])
+], AbstractErgoExtractorEntity);
+export { AbstractErgoExtractorEntity };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/ergo/index.d.ts

@@ -0,0 +1,10 @@
+export * from './AbstractErgoExtractor';
+export * from './AbstractErgoExtractorAction';
+export * from './interfaces';
+export * from './network/ExplorerNetwork';
+export * from './network/NodeNetwork';
+export * from './network/AbstractNetwork';
+export * from './initializable';
+export * from './utils';
+export * from './AbstractErgoExtractorEntity';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/ergo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,+BAA+B,CAAC"}

package/dist/lib/ergo/index.js

@@ -0,0 +1,10 @@
+export * from './AbstractErgoExtractor';
+export * from './AbstractErgoExtractorAction';
+export * from './interfaces';
+export * from './network/ExplorerNetwork';
+export * from './network/NodeNetwork';
+export * from './network/AbstractNetwork';
+export * from './initializable';
+export * from './utils';
+export * from './AbstractErgoExtractorEntity';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3JBY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9FeHBsb3Jlck5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrL05vZGVOZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9BYnN0cmFjdE5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9pbml0aWFsaXphYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3JFbnRpdHknO1xuIl19

package/dist/lib/ergo/initializable/AbstractInitializable.d.ts

@@ -0,0 +1,48 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo, ErgoNetworkType } from '@rosen-bridge/scanner-interfaces';
+import { AbstractBoxData } from '../interfaces';
+import { AbstractErgoExtractor } from '../AbstractErgoExtractor';
+import { AbstractInitializableErgoExtractorAction } from './AbstractInitializableAction';
+import { AbstractErgoExtractorEntity } from '../AbstractErgoExtractorEntity';
+export declare abstract class AbstractInitializableErgoExtractor<ExtractedData extends AbstractBoxData, ExtractorEntity extends AbstractErgoExtractorEntity> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {
+    protected initialize: boolean;
+    private address;
+    protected abstract actions: AbstractInitializableErgoExtractorAction<ExtractedData, ExtractorEntity>;
+    private network;
+    constructor(type: ErgoNetworkType, url: string, address: string, logger?: AbstractLogger, initialize?: boolean);
+    /**
+     * Initialize extractor using Explorer network
+     * @param initialBlock
+     */
+    private initializeWithExplorer;
+    /**
+     * Get the total tx count from Node network
+     * @returns total tx count of the address
+     */
+    private getTotalTxCount;
+    /**
+     * Initialize extractor using Node network
+     * @param initialBlock
+     */
+    private initializeWithNode;
+    /**
+     * Process a batch of transactions
+     * group txs into blocks and process them using `processTransactions`
+     * @param txs
+     */
+    private processTransactionBatch;
+    /**
+     * Initialize the extractor with retrial on any unexpected problem
+     * its the common part of initialize with Node and Explorer network
+     * @param job
+     */
+    private initWithRetrial;
+    /**
+     * initialize extractor database with data created below the initial height
+     * ignore initialization if this feature is off
+     * try to get data multiple times to pass accidental network problems
+     * @param initialBlock
+     */
+    initializeBoxes: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=AbstractInitializable.d.ts.map

package/dist/lib/ergo/initializable/AbstractInitializable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractInitializable.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAE9E,OAAO,EAAE,eAAe,EAAuB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AAGzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAE7E,8BAAsB,kCAAkC,CACtD,aAAa,SAAS,eAAe,EACrC,eAAe,SAAS,2BAA2B,CACnD,SAAQ,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;IAC7D,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wCAAwC,CAClE,aAAa,EACb,eAAe,CAChB,CAAC;IAEF,OAAO,CAAC,OAAO,CAAgC;gBAG7C,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,UAAO;IAkBnB;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CA6C5B;IAEF;;;OAGG;IACH,OAAO,CAAC,eAAe,CAKrB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAuCxB;IAEF;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CAoB7B;IAEF;;;;OAIG;IACH,OAAO,CAAC,eAAe,CA+BrB;IAEF;;;;;OAKG;IACH,eAAe,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D"}

package/dist/lib/ergo/initializable/AbstractInitializable.js

@@ -0,0 +1,163 @@
+import { groupBy, sortBy } from 'lodash-es';
+import { ErgoNetworkType } from '@rosen-bridge/scanner-interfaces';
+import { API_LIMIT, RETRIAL_COUNT } from '../../constants';
+import { AbstractErgoExtractor } from '../AbstractErgoExtractor';
+import { ExplorerNetwork } from '../network/ExplorerNetwork';
+import { NodeNetwork } from '../network/NodeNetwork';
+export class AbstractInitializableErgoExtractor extends AbstractErgoExtractor {
+    initialize;
+    address;
+    network;
+    constructor(type, url, address, logger, initialize = true) {
+        super(logger);
+        this.address = address;
+        this.initialize = initialize;
+        if (type == ErgoNetworkType.Explorer) {
+            this.network = new ExplorerNetwork(url);
+            this.initializeBoxes = (initialBlock) => {
+                return this.initializeWithExplorer(initialBlock);
+            };
+        }
+        else if (type == ErgoNetworkType.Node) {
+            this.network = new NodeNetwork(url);
+            this.initializeBoxes = (initialBlock) => {
+                return this.initializeWithNode(initialBlock);
+            };
+        }
+        else
+            throw new Error(`Network type ${type} is not supported`);
+    }
+    /**
+     * Initialize extractor using Explorer network
+     * @param initialBlock
+     */
+    initializeWithExplorer = async (initialBlock) => {
+        const explorerNetwork = this.network;
+        let fromHeight = 0, toHeight = initialBlock.height;
+        await this.initWithRetrial(async () => {
+            while (fromHeight < toHeight) {
+                let txs;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    txs = await explorerNetwork.getAddressTransactionsWithHeight(this.address, fromHeight, toHeight);
+                    this.logger.debug(`Found ${txs.length} transactions for the address from height ${fromHeight} to height ${toHeight}`);
+                    if (txs.length < API_LIMIT || fromHeight === toHeight) {
+                        break; // Exit loop if we have fewer transactions than the limit or if the range is reduced to a single height
+                    }
+                    toHeight = Math.floor((toHeight - fromHeight) / 2) + fromHeight;
+                    this.logger.debug(`Limiting the query height range to [${fromHeight}, ${toHeight}]`);
+                }
+                if (txs.length < API_LIMIT) {
+                    if (txs.length > 0)
+                        await this.processTransactionBatch(txs);
+                }
+                else {
+                    this.logger.debug(`Block at height ${fromHeight} has more than (or equal) ${API_LIMIT} relevant txs, processing all txs in the block`);
+                    const blockId = await explorerNetwork.getBlockIdAtHeight(fromHeight);
+                    const blockTxs = await explorerNetwork.getBlockTxs(blockId);
+                    this.logger.debug(`Found ${blockTxs.length} transactions at height ${fromHeight}`);
+                    await this.processTransactions(blockTxs, {
+                        hash: blockId,
+                        height: fromHeight,
+                    });
+                }
+                fromHeight = toHeight + 1;
+                toHeight = initialBlock.height;
+            }
+        });
+    };
+    /**
+     * Get the total tx count from Node network
+     * @returns total tx count of the address
+     */
+    getTotalTxCount = async () => {
+        const response = await this.network.getAddressTransactionsWithOffsetLimit(this.address, 0, 0);
+        return response.total;
+    };
+    /**
+     * Initialize extractor using Node network
+     * @param initialBlock
+     */
+    initializeWithNode = async (initialBlock) => {
+        const txCountBeforeInit = await this.getTotalTxCount();
+        let offset = 0, total = 1, round = 1;
+        await this.initWithRetrial(async () => {
+            // Repeat the whole process twice to cover all spent boxes
+            // After round 1 all boxes have been saved and processed once
+            // After round 2 spending information of all stored boxes are updated successfully
+            while (round <= 2) {
+                this.logger.debug(`Starting round ${round} of initialization`);
+                while (offset < total) {
+                    const response = await this.network.getAddressTransactionsWithOffsetLimit(this.address, offset, API_LIMIT);
+                    total = response.total;
+                    const txs = response.items.filter((tx) => tx.inclusionHeight <= initialBlock.height);
+                    this.logger.debug(`Found ${txs.length} transactions below the initial height with offset ${offset} and total number of transactions ${total}`);
+                    if (txs.length > 0)
+                        await this.processTransactionBatch(txs);
+                    offset += API_LIMIT;
+                }
+                round++;
+                offset = 0; // next round initial offset
+            }
+        });
+        const txCountAfterInit = await this.getTotalTxCount();
+        if (txCountAfterInit != txCountBeforeInit) {
+            throw Error('Total transaction count changed during initialization phase, the stored data is not valid');
+        }
+    };
+    /**
+     * Process a batch of transactions
+     * group txs into blocks and process them using `processTransactions`
+     * @param txs
+     */
+    processTransactionBatch = async (txs) => {
+        txs = sortBy(txs, (tx) => tx.inclusionHeight);
+        const groupedTxs = groupBy(txs, (tx) => tx.blockId);
+        this.logger.debug(`The transaction batch grouped to ${Object.keys(groupedTxs).length} blocks`);
+        for (const blockId in groupedTxs) {
+            const blockTxs = groupedTxs[blockId];
+            const block = { hash: blockId, height: blockTxs[0].inclusionHeight };
+            this.logger.debug(`Processing transactions at height ${blockTxs[0].inclusionHeight}`);
+            const success = await this.processTransactions(blockTxs, block);
+            if (!success)
+                throw Error(`Processing transactions failed at height ${blockTxs[0].inclusionHeight}`);
+        }
+    };
+    /**
+     * Initialize the extractor with retrial on any unexpected problem
+     * its the common part of initialize with Node and Explorer network
+     * @param job
+     */
+    initWithRetrial = async (job) => {
+        let trial = 1;
+        if (this.initialize) {
+            this.logger.debug(`Initializing ${this.getId()} started, removing all existing data`);
+            await this.actions.removeAllData(this.getId());
+            while (trial <= RETRIAL_COUNT) {
+                try {
+                    await job();
+                    break;
+                }
+                catch (e) {
+                    this.logger.warn(`Initialization for ${this.getId()} failed with error :${e}`);
+                    if (trial == RETRIAL_COUNT)
+                        throw Error(`Initialization for ${this.getId()} failed after ${RETRIAL_COUNT} retrial`);
+                    trial += 1;
+                    this.logger.info(`Trying again to initialize ${this.getId()} with trial step ${trial}`);
+                }
+            }
+            this.logger.info(`Initialization completed successfully for ${this.getId()}`);
+        }
+        else {
+            this.logger.info(`Initialization for ${this.getId()} is turned off`);
+        }
+    };
+    /**
+     * initialize extractor database with data created below the initial height
+     * ignore initialization if this feature is off
+     * try to get data multiple times to pass accidental network problems
+     * @param initialBlock
+     */
+    initializeBoxes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractInitializable.js","sourceRoot":"","sources":["../../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { groupBy, sortBy } from 'lodash-es';\nimport { BlockInfo, ErgoNetworkType } from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractBoxData, ExtendedTransaction } from '../interfaces';\nimport { API_LIMIT, RETRIAL_COUNT } from '../../constants';\nimport { AbstractErgoExtractor } from '../AbstractErgoExtractor';\nimport { AbstractInitializableErgoExtractorAction } from './AbstractInitializableAction';\nimport { ExplorerNetwork } from '../network/ExplorerNetwork';\nimport { NodeNetwork } from '../network/NodeNetwork';\nimport { AbstractErgoExtractorEntity } from '../AbstractErgoExtractorEntity';\n\nexport abstract class AbstractInitializableErgoExtractor<\n  ExtractedData extends AbstractBoxData,\n  ExtractorEntity extends AbstractErgoExtractorEntity,\n> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {\n  protected initialize: boolean;\n  private address: string;\n  protected abstract actions: AbstractInitializableErgoExtractorAction<\n    ExtractedData,\n    ExtractorEntity\n  >;\n\n  private network: ExplorerNetwork | NodeNetwork;\n\n  constructor(\n    type: ErgoNetworkType,\n    url: string,\n    address: string,\n    logger?: AbstractLogger,\n    initialize = true,\n  ) {\n    super(logger);\n    this.address = address;\n    this.initialize = initialize;\n    if (type == ErgoNetworkType.Explorer) {\n      this.network = new ExplorerNetwork(url);\n      this.initializeBoxes = (initialBlock: BlockInfo) => {\n        return this.initializeWithExplorer(initialBlock);\n      };\n    } else if (type == ErgoNetworkType.Node) {\n      this.network = new NodeNetwork(url);\n      this.initializeBoxes = (initialBlock: BlockInfo) => {\n        return this.initializeWithNode(initialBlock);\n      };\n    } else throw new Error(`Network type ${type} is not supported`);\n  }\n\n  /**\n   * Initialize extractor using Explorer network\n   * @param initialBlock\n   */\n  private initializeWithExplorer = async (initialBlock: BlockInfo) => {\n    const explorerNetwork = this.network as ExplorerNetwork;\n    let fromHeight = 0,\n      toHeight = initialBlock.height;\n    await this.initWithRetrial(async () => {\n      while (fromHeight < toHeight) {\n        let txs: Array<ExtendedTransaction>;\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n          txs = await explorerNetwork.getAddressTransactionsWithHeight(\n            this.address,\n            fromHeight,\n            toHeight,\n          );\n          this.logger.debug(\n            `Found ${txs.length} transactions for the address from height ${fromHeight} to height ${toHeight}`,\n          );\n          if (txs.length < API_LIMIT || fromHeight === toHeight) {\n            break; // Exit loop if we have fewer transactions than the limit or if the range is reduced to a single height\n          }\n          toHeight = Math.floor((toHeight - fromHeight) / 2) + fromHeight;\n          this.logger.debug(\n            `Limiting the query height range to [${fromHeight}, ${toHeight}]`,\n          );\n        }\n        if (txs.length < API_LIMIT) {\n          if (txs.length > 0) await this.processTransactionBatch(txs);\n        } else {\n          this.logger.debug(\n            `Block at height ${fromHeight} has more than (or equal) ${API_LIMIT} relevant txs, processing all txs in the block`,\n          );\n          const blockId = await explorerNetwork.getBlockIdAtHeight(fromHeight);\n          const blockTxs = await explorerNetwork.getBlockTxs(blockId);\n          this.logger.debug(\n            `Found ${blockTxs.length} transactions at height ${fromHeight}`,\n          );\n          await this.processTransactions(blockTxs, {\n            hash: blockId,\n            height: fromHeight,\n          });\n        }\n        fromHeight = toHeight + 1;\n        toHeight = initialBlock.height;\n      }\n    });\n  };\n\n  /**\n   * Get the total tx count from Node network\n   * @returns total tx count of the address\n   */\n  private getTotalTxCount = async () => {\n    const response = await (\n      this.network as NodeNetwork\n    ).getAddressTransactionsWithOffsetLimit(this.address, 0, 0);\n    return response.total;\n  };\n\n  /**\n   * Initialize extractor using Node network\n   * @param initialBlock\n   */\n  private initializeWithNode = async (initialBlock: BlockInfo) => {\n    const txCountBeforeInit = await this.getTotalTxCount();\n    let offset = 0,\n      total = 1,\n      round = 1;\n    await this.initWithRetrial(async () => {\n      // Repeat the whole process twice to cover all spent boxes\n      // After round 1 all boxes have been saved and processed once\n      // After round 2 spending information of all stored boxes are updated successfully\n      while (round <= 2) {\n        this.logger.debug(`Starting round ${round} of initialization`);\n        while (offset < total) {\n          const response = await (\n            this.network as NodeNetwork\n          ).getAddressTransactionsWithOffsetLimit(\n            this.address,\n            offset,\n            API_LIMIT,\n          );\n          total = response.total;\n          const txs = response.items.filter(\n            (tx) => tx.inclusionHeight <= initialBlock.height,\n          );\n          this.logger.debug(\n            `Found ${txs.length} transactions below the initial height with offset ${offset} and total number of transactions ${total}`,\n          );\n          if (txs.length > 0) await this.processTransactionBatch(txs);\n          offset += API_LIMIT;\n        }\n        round++;\n        offset = 0; // next round initial offset\n      }\n    });\n    const txCountAfterInit = await this.getTotalTxCount();\n    if (txCountAfterInit != txCountBeforeInit) {\n      throw Error(\n        'Total transaction count changed during initialization phase, the stored data is not valid',\n      );\n    }\n  };\n\n  /**\n   * Process a batch of transactions\n   * group txs into blocks and process them using `processTransactions`\n   * @param txs\n   */\n  private processTransactionBatch = async (txs: Array<ExtendedTransaction>) => {\n    txs = sortBy(txs, (tx) => tx.inclusionHeight);\n    const groupedTxs = groupBy(txs, (tx) => tx.blockId);\n    this.logger.debug(\n      `The transaction batch grouped to ${\n        Object.keys(groupedTxs).length\n      } blocks`,\n    );\n    for (const blockId in groupedTxs) {\n      const blockTxs = groupedTxs[blockId];\n      const block = { hash: blockId, height: blockTxs[0].inclusionHeight };\n      this.logger.debug(\n        `Processing transactions at height ${blockTxs[0].inclusionHeight}`,\n      );\n      const success = await this.processTransactions(blockTxs, block);\n      if (!success)\n        throw Error(\n          `Processing transactions failed at height ${blockTxs[0].inclusionHeight}`,\n        );\n    }\n  };\n\n  /**\n   * Initialize the extractor with retrial on any unexpected problem\n   * its the common part of initialize with Node and Explorer network\n   * @param job\n   */\n  private initWithRetrial = async (job: () => Promise<void>) => {\n    let trial = 1;\n    if (this.initialize) {\n      this.logger.debug(\n        `Initializing ${this.getId()} started, removing all existing data`,\n      );\n      await this.actions.removeAllData(this.getId());\n      while (trial <= RETRIAL_COUNT) {\n        try {\n          await job();\n          break;\n        } catch (e) {\n          this.logger.warn(\n            `Initialization for ${this.getId()} failed with error :${e}`,\n          );\n          if (trial == RETRIAL_COUNT)\n            throw Error(\n              `Initialization for ${this.getId()} failed after ${RETRIAL_COUNT} retrial`,\n            );\n          trial += 1;\n          this.logger.info(\n            `Trying again to initialize ${this.getId()} with trial step ${trial}`,\n          );\n        }\n      }\n      this.logger.info(\n        `Initialization completed successfully for ${this.getId()}`,\n      );\n    } else {\n      this.logger.info(`Initialization for ${this.getId()} is turned off`);\n    }\n  };\n\n  /**\n   * initialize extractor database with data created below the initial height\n   * ignore initialization if this feature is off\n   * try to get data multiple times to pass accidental network problems\n   * @param initialBlock\n   */\n  initializeBoxes: (initialBlock: BlockInfo) => Promise<void>;\n}\n"]}

package/dist/lib/ergo/initializable/AbstractInitializableAction.d.ts

@@ -0,0 +1,14 @@
+import { DataSource, EntityTarget } from '@rosen-bridge/extended-typeorm';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractErgoExtractorAction } from '../AbstractErgoExtractorAction';
+import { AbstractBoxData } from '../interfaces';
+import { AbstractErgoExtractorEntity } from '../AbstractErgoExtractorEntity';
+export declare abstract class AbstractInitializableErgoExtractorAction<ExtractedData extends AbstractBoxData, ExtractorEntity extends AbstractErgoExtractorEntity> extends AbstractErgoExtractorAction<ExtractedData, ExtractorEntity> {
+    constructor(dataSource: DataSource, repo: EntityTarget<ExtractorEntity>, logger?: AbstractLogger);
+    /**
+     * remove all existing data for the extractor
+     * @param extractorId
+     */
+    removeAllData: (extractorId: string) => Promise<void>;
+}
+//# sourceMappingURL=AbstractInitializableAction.d.ts.map

package/dist/lib/ergo/initializable/AbstractInitializableAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractInitializableAction.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializable/AbstractInitializableAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,YAAY,EAEb,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAE7E,8BAAsB,wCAAwC,CAC5D,aAAa,SAAS,eAAe,EACrC,eAAe,SAAS,2BAA2B,CACnD,SAAQ,2BAA2B,CAAC,aAAa,EAAE,eAAe,CAAC;gBAEjE,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,YAAY,CAAC,eAAe,CAAC,EACnC,MAAM,CAAC,EAAE,cAAc;IAKzB;;;OAGG;IACH,aAAa,GAAU,aAAa,MAAM,mBAIxC;CACH"}