@rosen-bridge/address-extractor 2.1.6 → 2.1.7

package/dist/actions/boxAction.d.ts

@@ -0,0 +1,63 @@
+import { DataSource } from 'typeorm';
+import { AbstractLogger } from '@rosen-bridge/logger-interface';
+import { BlockEntity } from '@rosen-bridge/scanner';
+import { ExtractedBox } from '../interfaces/types';
+export declare class BoxEntityAction {
+    private readonly datasource;
+    readonly logger: AbstractLogger;
+    private readonly repository;
+    constructor(dataSource: DataSource, logger: AbstractLogger);
+    /**
+     * insert new box into database
+     * @param box
+     * @param extractor
+     */
+    insertBox: (box: ExtractedBox, extractor: string) => Promise<import("typeorm").InsertResult>;
+    /**
+     * Update an unspent box information in the database
+     * @param box
+     * @param extractor
+     */
+    updateBox: (box: ExtractedBox, extractor: string) => Promise<import("typeorm").UpdateResult>;
+    /**
+     * It stores list of blocks in the dataSource with block id
+     * @param boxes
+     * @param spendBoxes
+     * @param block
+     * @param extractor
+     */
+    storeBox: (boxes: Array<ExtractedBox>, block: BlockEntity, extractor: string) => Promise<boolean>;
+    /**
+     * Update spendBlock and spendHeight of boxes spent on the block
+     * @param spendIds
+     * @param block
+     * @param extractor
+     */
+    spendBoxes: (spendIds: Array<string>, block: BlockEntity, extractor: string) => Promise<void>;
+    /**
+     * delete boxes in specific block from database. if box spend in this block marked as unspent
+     * and if created in this block remove it from database
+     * @param block
+     * @param extractor
+     */
+    deleteBlockBoxes: (block: string, extractor: string) => Promise<void>;
+    /**
+     *  Returns all stored box ids
+     */
+    getAllBoxIds: (extractor: string) => Promise<Array<string>>;
+    /**
+     * Removes specified box
+     * @param boxId
+     * @param extractor
+     */
+    removeBox: (boxId: string, extractor: string) => Promise<import("typeorm").DeleteResult>;
+    /**
+     * Update the box spending information
+     * @param boxId
+     * @param extractor
+     * @param blockId
+     * @param blockHeight
+     */
+    updateSpendBlock: (boxId: string, extractor: string, blockId: string, blockHeight: number) => Promise<import("typeorm").UpdateResult>;
+}
+//# sourceMappingURL=boxAction.d.ts.map

package/dist/actions/boxAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxAction.d.ts","sourceRoot":"","sources":["../../lib/actions/boxAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,SAAS,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;gBAEvC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc;IAM1D;;;;OAIG;IACH,SAAS,QAAe,YAAY,aAAa,MAAM,6CASrD;IAEF;;;;OAIG;IACH,SAAS,QAAe,YAAY,aAAa,MAAM,6CAYrD;IAEF;;;;;;OAMG;IACH,QAAQ,UACC,MAAM,YAAY,CAAC,SACnB,WAAW,aACP,MAAM,sBA6CjB;IAEF;;;;;OAKG;IACH,UAAU,aACE,MAAM,MAAM,CAAC,SAChB,WAAW,aACP,MAAM,KAChB,QAAQ,IAAI,CAAC,CAoBd;IAEF;;;;;OAKG;IACH,gBAAgB,UAAiB,MAAM,aAAa,MAAM,mBAYxD;IAEF;;OAEG;IACH,YAAY,cAAqB,MAAM,KAAG,QAAQ,MAAM,MAAM,CAAC,CAAC,CAU9D;IAEF;;;;OAIG;IACH,SAAS,UAAiB,MAAM,aAAa,MAAM,6CAEjD;IAEF;;;;;;OAMG;IACH,gBAAgB,UACP,MAAM,aACF,MAAM,WACR,MAAM,eACF,MAAM,6CAMnB;CACH"}

package/dist/actions/boxAction.js

@@ -0,0 +1,165 @@
+import { In } from 'typeorm';
+import { chunk } from 'lodash-es';
+import { BoxEntity } from '../entities/boxEntity';
+import { dbIdChunkSize } from '../constants';
+export class BoxEntityAction {
+    datasource;
+    logger;
+    repository;
+    constructor(dataSource, logger) {
+        this.datasource = dataSource;
+        this.logger = logger;
+        this.repository = dataSource.getRepository(BoxEntity);
+    }
+    /**
+     * insert new box into database
+     * @param box
+     * @param extractor
+     */
+    insertBox = async (box, extractor) => {
+        return this.repository.insert({
+            address: box.address,
+            boxId: box.boxId,
+            createBlock: box.blockId,
+            creationHeight: box.height,
+            serialized: box.serialized,
+            extractor: extractor,
+        });
+    };
+    /**
+     * Update an unspent box information in the database
+     * @param box
+     * @param extractor
+     */
+    updateBox = async (box, extractor) => {
+        return this.repository.update({ boxId: box.boxId, extractor: extractor }, {
+            address: box.address,
+            createBlock: box.blockId,
+            creationHeight: box.height,
+            serialized: box.serialized,
+            spendBlock: null,
+            spendHeight: 0,
+        });
+    };
+    /**
+     * It stores list of blocks in the dataSource with block id
+     * @param boxes
+     * @param spendBoxes
+     * @param block
+     * @param extractor
+     */
+    storeBox = async (boxes, block, extractor) => {
+        const boxIds = boxes.map((item) => item.boxId);
+        const dbBoxes = await this.datasource.getRepository(BoxEntity).findBy({
+            boxId: In(boxIds),
+            extractor: extractor,
+        });
+        let success = true;
+        const queryRunner = this.datasource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        const repository = await queryRunner.manager.getRepository(BoxEntity);
+        try {
+            for (const box of boxes) {
+                const entity = {
+                    address: box.address,
+                    boxId: box.boxId,
+                    createBlock: block.hash,
+                    creationHeight: block.height,
+                    spendBlock: undefined,
+                    serialized: box.serialized,
+                    extractor: extractor,
+                };
+                const dbBox = dbBoxes.filter((item) => item.boxId === box.boxId);
+                if (dbBox.length > 0) {
+                    this.logger.info(`Updating box ${box.boxId} and extractor ${extractor}`);
+                    this.logger.debug(`Entity: ${JSON.stringify(entity)}`);
+                    await repository.update({ id: dbBoxes[0].id }, entity);
+                }
+                else {
+                    this.logger.info(`Storing box ${box.boxId}`);
+                    this.logger.debug(JSON.stringify(entity));
+                    await repository.insert(entity);
+                }
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store boxes action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return success;
+    };
+    /**
+     * Update spendBlock and spendHeight of boxes spent on the block
+     * @param spendIds
+     * @param block
+     * @param extractor
+     */
+    spendBoxes = async (spendIds, block, extractor) => {
+        const spendIdChunks = chunk(spendIds, dbIdChunkSize);
+        for (const spendIdChunk of spendIdChunks) {
+            const updateResult = await this.repository.update({ boxId: In(spendIdChunk), extractor: extractor }, { spendBlock: block.hash, spendHeight: block.height });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const spentRows = await this.repository.findBy({
+                    boxId: In(spendIdChunk),
+                    spendBlock: block.hash,
+                });
+                for (const row of spentRows) {
+                    this.logger.debug(`Spent box with boxId [${row.boxId}] at height ${block.height}`);
+                }
+            }
+        }
+    };
+    /**
+     * delete boxes in specific block from database. if box spend in this block marked as unspent
+     * and if created in this block remove it from database
+     * @param block
+     * @param extractor
+     */
+    deleteBlockBoxes = async (block, extractor) => {
+        this.logger.info(`Deleting boxes in block ${block} and extractor ${extractor}`);
+        await this.repository.delete({
+            extractor: extractor,
+            createBlock: block,
+        });
+        await this.repository.update({ spendBlock: block, extractor: extractor }, { spendBlock: null, spendHeight: 0 });
+    };
+    /**
+     *  Returns all stored box ids
+     */
+    getAllBoxIds = async (extractor) => {
+        const boxIds = await this.repository.find({
+            select: {
+                boxId: true,
+            },
+            where: {
+                extractor: extractor,
+            },
+        });
+        return boxIds.map((item) => item.boxId);
+    };
+    /**
+     * Removes specified box
+     * @param boxId
+     * @param extractor
+     */
+    removeBox = async (boxId, extractor) => {
+        return await this.repository.delete({ boxId: boxId, extractor: extractor });
+    };
+    /**
+     * Update the box spending information
+     * @param boxId
+     * @param extractor
+     * @param blockId
+     * @param blockHeight
+     */
+    updateSpendBlock = async (boxId, extractor, blockId, blockHeight) => {
+        return await this.repository.update({ boxId: boxId, extractor: extractor }, { spendBlock: blockId, spendHeight: blockHeight });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"boxAction.js","sourceRoot":"","sources":["../../lib/actions/boxAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, In, Repository } from 'typeorm';\nimport { chunk } from 'lodash-es';\nimport { AbstractLogger } from '@rosen-bridge/logger-interface';\nimport { BlockEntity } from '@rosen-bridge/scanner';\n\nimport { BoxEntity } from '../entities/boxEntity';\nimport { ExtractedBox } from '../interfaces/types';\nimport { dbIdChunkSize } from '../constants';\n\nexport class BoxEntityAction {\n  private readonly datasource: DataSource;\n  readonly logger: AbstractLogger;\n  private readonly repository: Repository<BoxEntity>;\n\n  constructor(dataSource: DataSource, logger: AbstractLogger) {\n    this.datasource = dataSource;\n    this.logger = logger;\n    this.repository = dataSource.getRepository(BoxEntity);\n  }\n\n  /**\n   * insert new box into database\n   * @param box\n   * @param extractor\n   */\n  insertBox = async (box: ExtractedBox, extractor: string) => {\n    return this.repository.insert({\n      address: box.address,\n      boxId: box.boxId,\n      createBlock: box.blockId,\n      creationHeight: box.height,\n      serialized: box.serialized,\n      extractor: extractor,\n    });\n  };\n\n  /**\n   * Update an unspent box information in the database\n   * @param box\n   * @param extractor\n   */\n  updateBox = async (box: ExtractedBox, extractor: string) => {\n    return this.repository.update(\n      { boxId: box.boxId, extractor: extractor },\n      {\n        address: box.address,\n        createBlock: box.blockId,\n        creationHeight: box.height,\n        serialized: box.serialized,\n        spendBlock: null,\n        spendHeight: 0,\n      }\n    );\n  };\n\n  /**\n   * It stores list of blocks in the dataSource with block id\n   * @param boxes\n   * @param spendBoxes\n   * @param block\n   * @param extractor\n   */\n  storeBox = async (\n    boxes: Array<ExtractedBox>,\n    block: BlockEntity,\n    extractor: string\n  ) => {\n    const boxIds = boxes.map((item) => item.boxId);\n    const dbBoxes = await this.datasource.getRepository(BoxEntity).findBy({\n      boxId: In(boxIds),\n      extractor: extractor,\n    });\n    let success = true;\n    const queryRunner = this.datasource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    const repository = await queryRunner.manager.getRepository(BoxEntity);\n    try {\n      for (const box of boxes) {\n        const entity = {\n          address: box.address,\n          boxId: box.boxId,\n          createBlock: block.hash,\n          creationHeight: block.height,\n          spendBlock: undefined,\n          serialized: box.serialized,\n          extractor: extractor,\n        };\n        const dbBox = dbBoxes.filter((item) => item.boxId === box.boxId);\n        if (dbBox.length > 0) {\n          this.logger.info(\n            `Updating box ${box.boxId} and extractor ${extractor}`\n          );\n          this.logger.debug(`Entity: ${JSON.stringify(entity)}`);\n          await repository.update({ id: dbBoxes[0].id }, entity);\n        } else {\n          this.logger.info(`Storing box ${box.boxId}`);\n          this.logger.debug(JSON.stringify(entity));\n          await repository.insert(entity);\n        }\n      }\n      await queryRunner.commitTransaction();\n    } catch (e) {\n      this.logger.error(`An error occurred during store boxes action: ${e}`);\n      await queryRunner.rollbackTransaction();\n      success = false;\n    } finally {\n      await queryRunner.release();\n    }\n    return success;\n  };\n\n  /**\n   * Update spendBlock and spendHeight of boxes spent on the block\n   * @param spendIds\n   * @param block\n   * @param extractor\n   */\n  spendBoxes = async (\n    spendIds: Array<string>,\n    block: BlockEntity,\n    extractor: string\n  ): Promise<void> => {\n    const spendIdChunks = chunk(spendIds, dbIdChunkSize);\n    for (const spendIdChunk of spendIdChunks) {\n      const updateResult = await this.repository.update(\n        { boxId: In(spendIdChunk), extractor: extractor },\n        { spendBlock: block.hash, spendHeight: block.height }\n      );\n\n      if (updateResult.affected && updateResult.affected > 0) {\n        const spentRows = await this.repository.findBy({\n          boxId: In(spendIdChunk),\n          spendBlock: block.hash,\n        });\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  };\n\n  /**\n   * delete boxes in specific block from database. if box spend in this block marked as unspent\n   * and if created in this block remove it from database\n   * @param block\n   * @param extractor\n   */\n  deleteBlockBoxes = async (block: string, extractor: string) => {\n    this.logger.info(\n      `Deleting boxes in block ${block} and extractor ${extractor}`\n    );\n    await this.repository.delete({\n      extractor: extractor,\n      createBlock: block,\n    });\n    await this.repository.update(\n      { spendBlock: block, extractor: extractor },\n      { spendBlock: null, spendHeight: 0 }\n    );\n  };\n\n  /**\n   *  Returns all stored box ids\n   */\n  getAllBoxIds = async (extractor: string): Promise<Array<string>> => {\n    const boxIds = await this.repository.find({\n      select: {\n        boxId: true,\n      },\n      where: {\n        extractor: extractor,\n      },\n    });\n    return boxIds.map((item: { boxId: string }) => item.boxId);\n  };\n\n  /**\n   * Removes specified box\n   * @param boxId\n   * @param extractor\n   */\n  removeBox = async (boxId: string, extractor: string) => {\n    return await this.repository.delete({ boxId: boxId, extractor: extractor });\n  };\n\n  /**\n   * Update the box spending information\n   * @param boxId\n   * @param extractor\n   * @param blockId\n   * @param blockHeight\n   */\n  updateSpendBlock = async (\n    boxId: string,\n    extractor: string,\n    blockId: string,\n    blockHeight: number\n  ) => {\n    return await this.repository.update(\n      { boxId: boxId, extractor: extractor },\n      { spendBlock: blockId, spendHeight: blockHeight }\n    );\n  };\n}\n"]}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+declare const DefaultApiLimit = 100;
+declare const dbIdChunkSize = 100;
+export { DefaultApiLimit, dbIdChunkSize };
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../lib/constants.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,eAAe,MAAM,CAAC;AAC5B,QAAA,MAAM,aAAa,MAAM,CAAC;AAE1B,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,CAAC"}

package/dist/constants.js

@@ -0,0 +1,4 @@
+const DefaultApiLimit = 100;
+const dbIdChunkSize = 100;
+export { DefaultApiLimit, dbIdChunkSize };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLGVBQWUsR0FBRyxHQUFHLENBQUM7QUFDNUIsTUFBTSxhQUFhLEdBQUcsR0FBRyxDQUFDO0FBRTFCLE9BQU8sRUFBRSxlQUFlLEVBQUUsYUFBYSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBEZWZhdWx0QXBpTGltaXQgPSAxMDA7XG5jb25zdCBkYklkQ2h1bmtTaXplID0gMTAwO1xuXG5leHBvcnQgeyBEZWZhdWx0QXBpTGltaXQsIGRiSWRDaHVua1NpemUgfTtcbiJdfQ==

package/dist/entities/boxEntity.d.ts

@@ -0,0 +1,12 @@
+export declare class BoxEntity {
+    id: number;
+    address: string;
+    boxId: string;
+    createBlock: string;
+    creationHeight: number;
+    serialized: string;
+    spendBlock?: string | null;
+    spendHeight?: number;
+    extractor: string;
+}
+//# sourceMappingURL=boxEntity.d.ts.map

package/dist/entities/boxEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxEntity.d.ts","sourceRoot":"","sources":["../../lib/entities/boxEntity.ts"],"names":[],"mappings":"AAEA,qBACa,SAAS;IAEpB,EAAE,EAAE,MAAM,CAAC;IAGX,OAAO,EAAE,MAAM,CAAC;IAGhB,KAAK,EAAE,MAAM,CAAC;IAGd,WAAW,EAAE,MAAM,CAAC;IAGpB,cAAc,EAAE,MAAM,CAAC;IAGvB,UAAU,EAAE,MAAM,CAAC;IAGnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG3B,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/entities/boxEntity.js

@@ -0,0 +1,62 @@
+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, Entity, PrimaryGeneratedColumn } from 'typeorm';
+let BoxEntity = class BoxEntity {
+    id;
+    address;
+    boxId;
+    createBlock;
+    creationHeight;
+    serialized;
+    spendBlock;
+    spendHeight;
+    extractor;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], BoxEntity.prototype, "id", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], BoxEntity.prototype, "address", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], BoxEntity.prototype, "boxId", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], BoxEntity.prototype, "createBlock", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", Number)
+], BoxEntity.prototype, "creationHeight", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], BoxEntity.prototype, "serialized", void 0);
+__decorate([
+    Column({ nullable: true, type: 'text' }),
+    __metadata("design:type", Object)
+], BoxEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", Number)
+], BoxEntity.prototype, "spendHeight", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], BoxEntity.prototype, "extractor", void 0);
+BoxEntity = __decorate([
+    Entity()
+], BoxEntity);
+export { BoxEntity };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm94RW50aXR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2VudGl0aWVzL2JveEVudGl0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUcxRCxJQUFNLFNBQVMsR0FBZixNQUFNLFNBQVM7SUFFcEIsRUFBRSxDQUFTO0lBR1gsT0FBTyxDQUFTO0lBR2hCLEtBQUssQ0FBUztJQUdkLFdBQVcsQ0FBUztJQUdwQixjQUFjLENBQVM7SUFHdkIsVUFBVSxDQUFTO0lBR25CLFVBQVUsQ0FBaUI7SUFHM0IsV0FBVyxDQUFVO0lBR3JCLFNBQVMsQ0FBUztDQUNuQixDQUFBO0FBMUJDO0lBQUMsc0JBQXNCLEVBQUU7O3FDQUNkO0FBRVg7SUFBQyxNQUFNLEVBQUU7OzBDQUNPO0FBRWhCO0lBQUMsTUFBTSxFQUFFOzt3Q0FDSztBQUVkO0lBQUMsTUFBTSxFQUFFOzs4Q0FDVztBQUVwQjtJQUFDLE1BQU0sRUFBRTs7aURBQ2M7QUFFdkI7SUFBQyxNQUFNLEVBQUU7OzZDQUNVO0FBRW5CO0lBQUMsTUFBTSxDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLENBQUM7OzZDQUNkO0FBRTNCO0lBQUMsTUFBTSxDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDOzs4Q0FDTjtBQUVyQjtJQUFDLE1BQU0sRUFBRTs7NENBQ1M7QUExQlAsU0FBUztJQURyQixNQUFNLEVBQUU7R0FDSSxTQUFTLENBMkJyQjtTQTNCWSxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29sdW1uLCBFbnRpdHksIFByaW1hcnlHZW5lcmF0ZWRDb2x1bW4gfSBmcm9tICd0eXBlb3JtJztcblxuQEVudGl0eSgpXG5leHBvcnQgY2xhc3MgQm94RW50aXR5IHtcbiAgQFByaW1hcnlHZW5lcmF0ZWRDb2x1bW4oKVxuICBpZDogbnVtYmVyO1xuXG4gIEBDb2x1bW4oKVxuICBhZGRyZXNzOiBzdHJpbmc7XG5cbiAgQENvbHVtbigpXG4gIGJveElkOiBzdHJpbmc7XG5cbiAgQENvbHVtbigpXG4gIGNyZWF0ZUJsb2NrOiBzdHJpbmc7XG5cbiAgQENvbHVtbigpXG4gIGNyZWF0aW9uSGVpZ2h0OiBudW1iZXI7XG5cbiAgQENvbHVtbigpXG4gIHNlcmlhbGl6ZWQ6IHN0cmluZztcblxuICBAQ29sdW1uKHsgbnVsbGFibGU6IHRydWUsIHR5cGU6ICd0ZXh0JyB9KVxuICBzcGVuZEJsb2NrPzogc3RyaW5nIHwgbnVsbDtcblxuICBAQ29sdW1uKHsgbnVsbGFibGU6IHRydWUgfSlcbiAgc3BlbmRIZWlnaHQ/OiBudW1iZXI7XG5cbiAgQENvbHVtbigpXG4gIGV4dHJhY3Rvcjogc3RyaW5nO1xufVxuIl19

package/dist/extractor/ergoUtxoExtractor.d.ts

@@ -0,0 +1,150 @@
+import { DataSource } from 'typeorm';
+import * as ergoLib from 'ergo-lib-wasm-nodejs';
+import { AbstractExtractor } from '@rosen-bridge/scanner';
+import { AbstractLogger } from '@rosen-bridge/logger-interface';
+import { BlockEntity } from '@rosen-bridge/scanner';
+import { Transaction } from '@rosen-bridge/scanner';
+import { ItemsOutputInfo, OutputInfo } from '@rosen-clients/ergo-explorer/dist/src/v1/types';
+import { BoxEntityAction } from '../actions/boxAction';
+import { ExtractedBox } from '../interfaces/types';
+export declare class ErgoUTXOExtractor implements AbstractExtractor<Transaction> {
+    readonly logger: AbstractLogger;
+    private readonly dataSource;
+    readonly actions: BoxEntityAction;
+    private readonly id;
+    private readonly networkType;
+    private readonly ergoTree?;
+    private readonly tokens;
+    readonly api: {
+        v0: {
+            getApiV0AddressesP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0AddressesP1Params | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").AddressInfo>;
+            getApiV0AddressesP1Transactions: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0AddressesP1TransactionsParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").ItemsTransactionInfo>;
+            getApiV0AddressesAssetholdersP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0AddressesAssetholdersP1Params | undefined) => Promise<string[]>;
+            getApiV0AddressesBalances: (params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0AddressesBalancesParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").ItemsBalanceInfo>;
+            getApiV0AssetsIssuingboxes: (params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0AssetsIssuingboxesParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").ItemsOutputInfo>;
+            getApiV0AssetsP1Issuingbox: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").OutputInfo[]>;
+            getApiV0Blocks: (params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0BlocksParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").ItemsBlockInfo>;
+            getApiV0BlocksP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").BlockSummary>;
+            getApiV0BlocksAtP1: (p1: number) => Promise<string[]>;
+            getApiV0DexTokensP1Unspentsellorders: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0DexTokensP1UnspentsellordersParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").DexSellOrderInfo[]>;
+            getApiV0DexTokensP1Unspentbuyorders: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0DexTokensP1UnspentbuyordersParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").DexBuyOrderInfo[]>;
+            getApiV0TransactionsP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").TransactionSummary>;
+            getApiV0TransactionsUnconfirmedP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").UTransactionSummary>;
+            getApiV0TransactionsUnconfirmedByaddressP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0TransactionsUnconfirmedByaddressP1Params | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").ItemsUTransactionInfo>;
+            getApiV0TransactionsUnconfirmed: (params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0TransactionsUnconfirmedParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").ItemsUTransactionInfo>;
+            getApiV0TransactionsSinceP1: (p1: number, params?: import("@rosen-clients/ergo-explorer/dist/src/v0/types").GetApiV0TransactionsSinceP1Params | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").TransactionInfo[]>;
+            postApiV0TransactionsSend: (postApiV0TransactionsSendBody: import("@rosen-clients/ergo-explorer/dist/src/v0/types").PostApiV0TransactionsSendBody) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").TxIdResponse>;
+            getApiV0TransactionsBoxesP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").OutputInfo>;
+            getApiV0TransactionsBoxesByergotreeP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").OutputInfo[]>;
+            getApiV0TransactionsBoxesByergotreeUnspentP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").OutputInfo[]>;
+            getApiV0TransactionsBoxesByaddressP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").OutputInfo[]>;
+            getApiV0TransactionsBoxesByaddressUnspentP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").OutputInfo[]>;
+            getApiV0Info: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").BlockChainInfo>;
+            getApiV0InfoSupply: () => Promise<string>;
+            getApiV0Stats: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v0/types").StatsSummary>;
+            getApiV0DocsOpenapi: () => Promise<string>;
+        };
+        v1: {
+            getApiV1TransactionsP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").TransactionInfo>;
+            getApiV1TransactionsByinputsscripttemplatehashP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1TransactionsByinputsscripttemplatehashP1Params | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsTransactionInfo>;
+            getApiV1TransactionsByglobalindexStream: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1TransactionsByglobalindexStreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListTransactionInfo>;
+            getApiV1BoxesUnspentBylastepochsStream: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentBylastepochsStreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            getApiV1BoxesUnspentByglobalindexStream: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentByglobalindexStreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            getApiV1BoxesUnspentStream: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentStreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            getApiV1BoxesByergotreetemplatehashP1Stream: (p1: string, params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesByergotreetemplatehashP1StreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            getApiV1BoxesUnspentByergotreetemplatehashP1Stream: (p1: string, params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentByergotreetemplatehashP1StreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            getApiV1BoxesUnspentBytokenidP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentBytokenidP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesBytokenidP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesBytokenidP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesP1: (p1: string) => Promise<OutputInfo>;
+            getApiV1BoxesByergotreeP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesByergotreeP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesByergotreetemplatehashP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesByergotreetemplatehashP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesUnspentByergotreeP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentByergotreeP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesUnspentByergotreetemplatehashP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentByergotreetemplatehashP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesByaddressP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesByaddressP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesUnspentByaddressP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesUnspentByaddressP1Params | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1BoxesByglobalindexStream: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BoxesByglobalindexStreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            postApiV1BoxesUnspentSearchUnion: (boxAssetsQuery: import("@rosen-clients/ergo-explorer/dist/src/v1/types").BoxAssetsQuery, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").PostApiV1BoxesUnspentSearchUnionParams | undefined) => Promise<ItemsOutputInfo>;
+            postApiV1BoxesUnspentSearch: (boxQuery: import("@rosen-clients/ergo-explorer/dist/src/v1/types").BoxQuery, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").PostApiV1BoxesUnspentSearchParams | undefined) => Promise<ItemsOutputInfo>;
+            postApiV1BoxesSearch: (boxQuery: import("@rosen-clients/ergo-explorer/dist/src/v1/types").BoxQuery, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").PostApiV1BoxesSearchParams | undefined) => Promise<ItemsOutputInfo>;
+            getApiV1Tokens: (params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1TokensParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsTokenInfo>;
+            getApiV1TokensSearch: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1TokensSearchParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsTokenInfo>;
+            getApiV1TokensBysymbolP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").TokenInfo[]>;
+            getApiV1TokensP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").TokenInfo>;
+            getApiV1Assets: (params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1AssetsParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsTokenInfo>;
+            getApiV1AssetsSearchBytokenid: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1AssetsSearchBytokenidParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsAssetInfo>;
+            getApiV1EpochsParams: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").EpochInfo>;
+            getApiV1AddressesP1Transactions: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1AddressesP1TransactionsParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsTransactionInfo>;
+            getApiV1AddressesP1BalanceConfirmed: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1AddressesP1BalanceConfirmedParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").Balance>;
+            getApiV1AddressesP1BalanceTotal: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").TotalBalance>;
+            getApiV1Blocks: (params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BlocksParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsBlockInfo>;
+            getApiV1BlocksP1: (p1: string) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").BlockSummary>;
+            getApiV1BlocksHeaders: (params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BlocksHeadersParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsBlockHeader>;
+            getApiV1BlocksByglobalindexStream: (params: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BlocksByglobalindexStreamParams) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListBlockInfo>;
+            getApiV1BlocksStreamSummary: (params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1BlocksStreamSummaryParams | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListBlockSummaryV1>;
+            postApiV1MempoolTransactionsSubmit: (postApiV1MempoolTransactionsSubmitBody: import("@rosen-clients/ergo-explorer/dist/src/v1/types").PostApiV1MempoolTransactionsSubmitBody) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").TxIdResponse>;
+            getApiV1MempoolTransactionsByaddressP1: (p1: string, params?: import("@rosen-clients/ergo-explorer/dist/src/v1/types").GetApiV1MempoolTransactionsByaddressP1Params | undefined) => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ItemsUTransactionInfo>;
+            getApiV1MempoolBoxesUnspent: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").ListOutputInfo>;
+            getApiV1Info: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").NetworkState>;
+            getApiV1Networkstate: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").NetworkState>;
+            getApiV1Networkstats: () => Promise<import("@rosen-clients/ergo-explorer/dist/src/v1/types").NetworkStats>;
+        };
+    };
+    constructor(dataSource: DataSource, id: string, networkType: ergoLib.NetworkPrefix, explorerUrl: string, address?: string, tokens?: Array<string>, logger?: AbstractLogger);
+    /**
+     * get Id for current extractor
+     */
+    getId: () => string;
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param txs
+     * @param block
+     */
+    processTransactions: (txs: Array<Transaction>, block: BlockEntity) => Promise<boolean>;
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash: block hash
+     */
+    forkBlock: (hash: string) => Promise<void>;
+    /**
+     * Initializes the database with older boxes related to the address
+     */
+    initializeBoxes: (initialHeight: number) => Promise<void>;
+    /**
+     * Validate all remaining boxes in the database
+     * update the correct ones and remove the invalid ones
+     * @param unchangedStoredBoxIds
+     * @param initialHeight
+     */
+    validateOldStoredBoxes: (unchangedStoredBoxIds: Array<string>, initialHeight: number) => Promise<void>;
+    /**
+     * Return extracted information of a box
+     * @param boxId
+     */
+    getBoxInfoWithBoxId: (boxId: string) => Promise<ExtractedBox | undefined>;
+    /**
+     * Get unspent boxes created bellow the initial height
+     * @param initialHeight
+     * @returns
+     */
+    getUnspentBoxes: (initialHeight: number) => Promise<Array<ExtractedBox>>;
+    /**
+     * Returns block information of tx
+     * @param txId
+     */
+    getTxBlock: (txId: string) => Promise<{
+        id: string;
+        height: number;
+    }>;
+    /**
+     * Extract needed information for storing in database from api json outputs
+     * @param boxes
+     */
+    extractBoxData: (boxes: Array<OutputInfo>) => Promise<ExtractedBox[]>;
+    /**
+     * Returns true if box has the required token and false otherwise
+     * @param box
+     */
+    boxHasToken: (box: OutputInfo) => boolean;
+}
+//# sourceMappingURL=ergoUtxoExtractor.d.ts.map

package/dist/extractor/ergoUtxoExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ergoUtxoExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/ergoUtxoExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAe,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EACL,eAAe,EACf,UAAU,EACX,MAAM,gDAAgD,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,qBAAa,iBAAkB,YAAW,iBAAiB,CAAC,WAAW,CAAC;IACtE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwB;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,QAAQ,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAC;gBAGX,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,OAAO,CAAC,aAAa,EAClC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EACtB,MAAM,CAAC,EAAE,cAAc;IAczB;;OAEG;IACH,KAAK,eAAsB;IAE3B;;;;;OAKG;IACH,mBAAmB,QACZ,MAAM,WAAW,CAAC,SAChB,WAAW,KACjB,QAAQ,OAAO,CAAC,CAkEjB;IAEF;;;OAGG;IACH,SAAS,SAAgB,MAAM,KAAG,QAAQ,IAAI,CAAC,CAE7C;IAEF;;OAEG;IACH,eAAe,kBAAyB,MAAM,mBA2B5C;IAEF;;;;;OAKG;IACH,sBAAsB,0BACG,MAAM,MAAM,CAAC,iBACrB,MAAM,mBAmBrB;IAEF;;;OAGG;IACH,mBAAmB,UACV,MAAM,KACZ,QAAQ,YAAY,GAAG,SAAS,CAAC,CAQlC;IAEF;;;;OAIG;IACH,eAAe,kBACE,MAAM,KACpB,QAAQ,MAAM,YAAY,CAAC,CAAC,CAmC7B;IAEF;;;OAGG;IACH,UAAU,SAAgB,MAAM;;;OAM9B;IAEF;;;OAGG;IACH,cAAc,UAAiB,MAAM,UAAU,CAAC,6BA2B9C;IAEF;;;OAGG;IACH,WAAW,QAAS,UAAU,aAM5B;CACH"}

package/dist/extractor/ergoUtxoExtractor.js

@@ -0,0 +1,242 @@
+import * as ergoLib from 'ergo-lib-wasm-nodejs';
+import { Buffer } from 'buffer';
+import { intersection, difference } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/logger-interface';
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+import { BoxEntityAction } from '../actions/boxAction';
+import { JsonBI } from '../utils';
+import { DefaultApiLimit } from '../constants';
+export class ErgoUTXOExtractor {
+    logger;
+    dataSource;
+    actions;
+    id;
+    networkType;
+    ergoTree;
+    tokens;
+    api;
+    constructor(dataSource, id, networkType, explorerUrl, address, tokens, logger) {
+        this.dataSource = dataSource;
+        this.id = id;
+        this.networkType = networkType;
+        this.ergoTree = address
+            ? ergoLib.Address.from_base58(address).to_ergo_tree().to_base16_bytes()
+            : undefined;
+        this.tokens = tokens ? tokens : [];
+        this.logger = logger ? logger : new DummyLogger();
+        this.actions = new BoxEntityAction(dataSource, this.logger);
+        this.api = ergoExplorerClientFactory(explorerUrl);
+    }
+    /**
+     * get Id for current extractor
+     */
+    getId = () => `${this.id}`;
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param txs
+     * @param block
+     */
+    processTransactions = (txs, block) => {
+        return new Promise((resolve, reject) => {
+            try {
+                const boxes = [];
+                const spendBoxes = [];
+                txs.forEach((transaction) => {
+                    for (const output of transaction.outputs) {
+                        if (this.ergoTree && output.ergoTree !== this.ergoTree) {
+                            continue;
+                        }
+                        const filteredTokens = this.tokens.filter((token) => {
+                            const outputTokens = output.assets ? output.assets : [];
+                            for (const outputToken of outputTokens) {
+                                if (outputToken.tokenId === token) {
+                                    return true;
+                                }
+                            }
+                            return false;
+                        });
+                        if (this.tokens.filter((token) => filteredTokens.indexOf(token) === -1).length > 0) {
+                            continue;
+                        }
+                        boxes.push({
+                            boxId: output.boxId,
+                            address: ergoLib.Address.recreate_from_ergo_tree(ergoLib.ErgoTree.from_base16_bytes(output.ergoTree)).to_base58(this.networkType),
+                            serialized: Buffer.from(ergoLib.ErgoBox.from_json(JsonBI.stringify(output)).sigma_serialize_bytes()).toString('base64'),
+                        });
+                    }
+                    for (const input of transaction.inputs) {
+                        spendBoxes.push(input.boxId);
+                    }
+                });
+                this.actions
+                    .storeBox(boxes, block, this.getId())
+                    .then(async (status) => {
+                    if (status)
+                        await this.actions
+                            .spendBoxes(spendBoxes, block, this.getId())
+                            .catch((e) => {
+                            this.logger.error(`An error occurred during spending ergo UTXOs for block at height [${block.height}] : ${e}`);
+                            reject(e);
+                        });
+                    resolve(status);
+                })
+                    .catch((e) => {
+                    this.logger.error(`An error occurred during storing ergo UTXOs for block at height [${block.height}] : ${e}`);
+                    reject(e);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    };
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash: block hash
+     */
+    forkBlock = async (hash) => {
+        await this.actions.deleteBlockBoxes(hash, this.getId());
+    };
+    /**
+     * Initializes the database with older boxes related to the address
+     */
+    initializeBoxes = async (initialHeight) => {
+        // Getting unspent boxes
+        const unspentBoxes = await this.getUnspentBoxes(initialHeight);
+        const unspentBoxIds = unspentBoxes.map((box) => box.boxId);
+        // Storing extracted boxes
+        let allStoredBoxIds = await this.actions.getAllBoxIds(this.getId());
+        for (const permit of unspentBoxes) {
+            if (allStoredBoxIds.includes(permit.boxId)) {
+                await this.actions.updateBox(permit, this.getId());
+                this.logger.info(`Updated the existing unspent box with boxId, [${permit.boxId}]`);
+                this.logger.debug(`Updated box [${JSON.stringify(permit)}]`);
+            }
+            else {
+                await this.actions.insertBox(permit, this.getId());
+                this.logger.info(`Inserted new unspent box with boxId, [${permit.boxId}]`);
+                this.logger.debug(`Inserted permit [${JSON.stringify(permit)}]`);
+            }
+        }
+        // Remove updated box ids from existing boxes in database
+        allStoredBoxIds = difference(allStoredBoxIds, unspentBoxIds);
+        // Validating remained boxes
+        await this.validateOldStoredBoxes(allStoredBoxIds, initialHeight);
+    };
+    /**
+     * Validate all remaining boxes in the database
+     * update the correct ones and remove the invalid ones
+     * @param unchangedStoredBoxIds
+     * @param initialHeight
+     */
+    validateOldStoredBoxes = async (unchangedStoredBoxIds, initialHeight) => {
+        for (const boxId of unchangedStoredBoxIds) {
+            const box = await this.getBoxInfoWithBoxId(boxId);
+            if (box && box.spendBlock && box.spendHeight) {
+                if (box.spendHeight < initialHeight)
+                    await this.actions.updateSpendBlock(boxId, this.getId(), box.spendBlock, box.spendHeight);
+            }
+            else {
+                await this.actions.removeBox(boxId, this.getId());
+                this.logger.info(`Removed invalid box [${boxId}] in initialization validation`);
+            }
+        }
+    };
+    /**
+     * Return extracted information of a box
+     * @param boxId
+     */
+    getBoxInfoWithBoxId = async (boxId) => {
+        try {
+            const box = await this.api.v1.getApiV1BoxesP1(boxId);
+            return (await this.extractBoxData([box]))[0];
+        }
+        catch {
+            this.logger.warn(`Box with id [${boxId}] does not exists`);
+            return undefined;
+        }
+    };
+    /**
+     * Get unspent boxes created bellow the initial height
+     * @param initialHeight
+     * @returns
+     */
+    getUnspentBoxes = async (initialHeight) => {
+        let allBoxes = [];
+        let offset = 0, total = DefaultApiLimit, boxes;
+        while (offset < total) {
+            if (this.ergoTree) {
+                boxes = await this.api.v1.getApiV1BoxesUnspentByergotreeP1(this.ergoTree, { offset: offset, limit: DefaultApiLimit });
+            }
+            else if (!this.ergoTree && this.tokens.length > 0) {
+                boxes = await this.api.v1.getApiV1BoxesUnspentBytokenidP1(this.tokens[0], { offset: offset, limit: DefaultApiLimit });
+            }
+            else
+                return [];
+            if (!boxes.items) {
+                this.logger.warn('Explorer api output items should not be undefined.');
+                throw new Error('Incorrect explorer api output');
+            }
+            allBoxes = [
+                ...allBoxes,
+                ...(await this.extractBoxData(boxes.items.filter((box) => box.creationHeight < initialHeight &&
+                    (this.tokens.length == 0 || this.boxHasToken(box))))),
+            ];
+            total = boxes.total;
+            offset += DefaultApiLimit;
+        }
+        return allBoxes;
+    };
+    /**
+     * Returns block information of tx
+     * @param txId
+     */
+    getTxBlock = async (txId) => {
+        const tx = await this.api.v1.getApiV1TransactionsP1(txId);
+        return {
+            id: tx.blockId,
+            height: tx.inclusionHeight,
+        };
+    };
+    /**
+     * Extract needed information for storing in database from api json outputs
+     * @param boxes
+     */
+    extractBoxData = async (boxes) => {
+        const extractedBoxes = [];
+        for (const box of boxes) {
+            let spendBlock, spendHeight;
+            if (box.spentTransactionId) {
+                const block = await this.getTxBlock(box.spentTransactionId);
+                spendBlock = block.id;
+                spendHeight = block.height;
+            }
+            const ergoBox = ergoLib.ErgoBox.from_json(JsonBI.stringify(box));
+            extractedBoxes.push({
+                boxId: ergoBox.box_id().to_str(),
+                address: ergoLib.Address.recreate_from_ergo_tree(ergoLib.ErgoTree.from_base16_bytes(ergoBox.ergo_tree().to_base16_bytes())).to_base58(this.networkType),
+                serialized: Buffer.from(ergoBox.sigma_serialize_bytes()).toString('base64'),
+                blockId: box.blockId,
+                height: box.settlementHeight,
+                spendBlock: spendBlock,
+                spendHeight: spendHeight,
+            });
+        }
+        return extractedBoxes;
+    };
+    /**
+     * Returns true if box has the required token and false otherwise
+     * @param box
+     */
+    boxHasToken = (box) => {
+        if (!box.assets)
+            return false;
+        const boxTokens = box.assets.map((token) => token.tokenId);
+        const requiredTokens = intersection(this.tokens, boxTokens);
+        if (requiredTokens.length == this.tokens.length)
+            return true;
+        return false;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ergoUtxoExtractor.js","sourceRoot":"","sources":["../../lib/extractor/ergoUtxoExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource } from 'typeorm';\nimport * as ergoLib from 'ergo-lib-wasm-nodejs';\nimport { Buffer } from 'buffer';\nimport { intersection, difference } from 'lodash-es';\nimport { AbstractExtractor } from '@rosen-bridge/scanner';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/logger-interface';\nimport { BlockEntity } from '@rosen-bridge/scanner';\nimport { Transaction } from '@rosen-bridge/scanner';\nimport ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';\nimport {\n  ItemsOutputInfo,\n  OutputInfo,\n} from '@rosen-clients/ergo-explorer/dist/src/v1/types';\n\nimport { BoxEntityAction } from '../actions/boxAction';\nimport { JsonBI } from '../utils';\nimport { DefaultApiLimit } from '../constants';\nimport { ExtractedBox } from '../interfaces/types';\n\nexport class ErgoUTXOExtractor implements AbstractExtractor<Transaction> {\n  readonly logger: AbstractLogger;\n  private readonly dataSource: DataSource;\n  readonly actions: BoxEntityAction;\n  private readonly id: string;\n  private readonly networkType: ergoLib.NetworkPrefix;\n  private readonly ergoTree?: string;\n  private readonly tokens: Array<string>;\n  readonly api;\n\n  constructor(\n    dataSource: DataSource,\n    id: string,\n    networkType: ergoLib.NetworkPrefix,\n    explorerUrl: string,\n    address?: string,\n    tokens?: Array<string>,\n    logger?: AbstractLogger\n  ) {\n    this.dataSource = dataSource;\n    this.id = id;\n    this.networkType = networkType;\n    this.ergoTree = address\n      ? ergoLib.Address.from_base58(address).to_ergo_tree().to_base16_bytes()\n      : undefined;\n    this.tokens = tokens ? tokens : [];\n    this.logger = logger ? logger : new DummyLogger();\n    this.actions = new BoxEntityAction(dataSource, this.logger);\n    this.api = ergoExplorerClientFactory(explorerUrl);\n  }\n\n  /**\n   * get Id for current extractor\n   */\n  getId = () => `${this.id}`;\n\n  /**\n   * gets block id and transactions corresponding to the block and saves if they are valid rosen\n   *  transactions and in case of success return true and in case of failure returns false\n   * @param txs\n   * @param block\n   */\n  processTransactions = (\n    txs: Array<Transaction>,\n    block: BlockEntity\n  ): Promise<boolean> => {\n    return new Promise((resolve, reject) => {\n      try {\n        const boxes: Array<ExtractedBox> = [];\n        const spendBoxes: Array<string> = [];\n        txs.forEach((transaction) => {\n          for (const output of transaction.outputs) {\n            if (this.ergoTree && output.ergoTree !== this.ergoTree) {\n              continue;\n            }\n            const filteredTokens = this.tokens.filter((token) => {\n              const outputTokens = output.assets ? output.assets : [];\n              for (const outputToken of outputTokens) {\n                if (outputToken.tokenId === token) {\n                  return true;\n                }\n              }\n              return false;\n            });\n            if (\n              this.tokens.filter(\n                (token) => filteredTokens.indexOf(token) === -1\n              ).length > 0\n            ) {\n              continue;\n            }\n            boxes.push({\n              boxId: output.boxId,\n              address: ergoLib.Address.recreate_from_ergo_tree(\n                ergoLib.ErgoTree.from_base16_bytes(output.ergoTree)\n              ).to_base58(this.networkType),\n              serialized: Buffer.from(\n                ergoLib.ErgoBox.from_json(\n                  JsonBI.stringify(output)\n                ).sigma_serialize_bytes()\n              ).toString('base64'),\n            });\n          }\n          for (const input of transaction.inputs) {\n            spendBoxes.push(input.boxId);\n          }\n        });\n        this.actions\n          .storeBox(boxes, block, this.getId())\n          .then(async (status) => {\n            if (status)\n              await this.actions\n                .spendBoxes(spendBoxes, block, this.getId())\n                .catch((e) => {\n                  this.logger.error(\n                    `An error occurred during spending ergo UTXOs for block at height [${block.height}] : ${e}`\n                  );\n                  reject(e);\n                });\n            resolve(status);\n          })\n          .catch((e) => {\n            this.logger.error(\n              `An error occurred during storing ergo UTXOs for block at height [${block.height}] : ${e}`\n            );\n            reject(e);\n          });\n      } catch (e) {\n        reject(e);\n      }\n    });\n  };\n\n  /**\n   * fork one block and remove all stored information for this block\n   * @param hash: block hash\n   */\n  forkBlock = async (hash: string): Promise<void> => {\n    await this.actions.deleteBlockBoxes(hash, this.getId());\n  };\n\n  /**\n   * Initializes the database with older boxes related to the address\n   */\n  initializeBoxes = async (initialHeight: number) => {\n    // Getting unspent boxes\n    const unspentBoxes = await this.getUnspentBoxes(initialHeight);\n    const unspentBoxIds = unspentBoxes.map((box) => box.boxId);\n\n    // Storing extracted boxes\n    let allStoredBoxIds = await this.actions.getAllBoxIds(this.getId());\n    for (const permit of unspentBoxes) {\n      if (allStoredBoxIds.includes(permit.boxId)) {\n        await this.actions.updateBox(permit, this.getId());\n        this.logger.info(\n          `Updated the existing unspent box with boxId, [${permit.boxId}]`\n        );\n        this.logger.debug(`Updated box [${JSON.stringify(permit)}]`);\n      } else {\n        await this.actions.insertBox(permit, this.getId());\n        this.logger.info(\n          `Inserted new unspent box with boxId, [${permit.boxId}]`\n        );\n        this.logger.debug(`Inserted permit [${JSON.stringify(permit)}]`);\n      }\n    }\n\n    // Remove updated box ids from existing boxes in database\n    allStoredBoxIds = difference(allStoredBoxIds, unspentBoxIds);\n    // Validating remained boxes\n    await this.validateOldStoredBoxes(allStoredBoxIds, initialHeight);\n  };\n\n  /**\n   * Validate all remaining boxes in the database\n   * update the correct ones and remove the invalid ones\n   * @param unchangedStoredBoxIds\n   * @param initialHeight\n   */\n  validateOldStoredBoxes = async (\n    unchangedStoredBoxIds: Array<string>,\n    initialHeight: number\n  ) => {\n    for (const boxId of unchangedStoredBoxIds) {\n      const box = await this.getBoxInfoWithBoxId(boxId);\n      if (box && box.spendBlock && box.spendHeight) {\n        if (box.spendHeight < initialHeight)\n          await this.actions.updateSpendBlock(\n            boxId,\n            this.getId(),\n            box.spendBlock,\n            box.spendHeight\n          );\n      } else {\n        await this.actions.removeBox(boxId, this.getId());\n        this.logger.info(\n          `Removed invalid box [${boxId}] in initialization validation`\n        );\n      }\n    }\n  };\n\n  /**\n   * Return extracted information of a box\n   * @param boxId\n   */\n  getBoxInfoWithBoxId = async (\n    boxId: string\n  ): Promise<ExtractedBox | undefined> => {\n    try {\n      const box = await this.api.v1.getApiV1BoxesP1(boxId);\n      return (await this.extractBoxData([box]))[0];\n    } catch {\n      this.logger.warn(`Box with id [${boxId}] does not exists`);\n      return undefined;\n    }\n  };\n\n  /**\n   * Get unspent boxes created bellow the initial height\n   * @param initialHeight\n   * @returns\n   */\n  getUnspentBoxes = async (\n    initialHeight: number\n  ): Promise<Array<ExtractedBox>> => {\n    let allBoxes: Array<ExtractedBox> = [];\n    let offset = 0,\n      total = DefaultApiLimit,\n      boxes: ItemsOutputInfo;\n    while (offset < total) {\n      if (this.ergoTree) {\n        boxes = await this.api.v1.getApiV1BoxesUnspentByergotreeP1(\n          this.ergoTree,\n          { offset: offset, limit: DefaultApiLimit }\n        );\n      } else if (!this.ergoTree && this.tokens.length > 0) {\n        boxes = await this.api.v1.getApiV1BoxesUnspentBytokenidP1(\n          this.tokens[0],\n          { offset: offset, limit: DefaultApiLimit }\n        );\n      } else return [];\n      if (!boxes.items) {\n        this.logger.warn('Explorer api output items should not be undefined.');\n        throw new Error('Incorrect explorer api output');\n      }\n      allBoxes = [\n        ...allBoxes,\n        ...(await this.extractBoxData(\n          boxes.items.filter(\n            (box) =>\n              box.creationHeight < initialHeight &&\n              (this.tokens.length == 0 || this.boxHasToken(box))\n          )\n        )),\n      ];\n      total = boxes.total;\n      offset += DefaultApiLimit;\n    }\n    return allBoxes;\n  };\n\n  /**\n   * Returns block information of tx\n   * @param txId\n   */\n  getTxBlock = async (txId: string) => {\n    const tx = await this.api.v1.getApiV1TransactionsP1(txId);\n    return {\n      id: tx.blockId,\n      height: tx.inclusionHeight,\n    };\n  };\n\n  /**\n   * Extract needed information for storing in database from api json outputs\n   * @param boxes\n   */\n  extractBoxData = async (boxes: Array<OutputInfo>) => {\n    const extractedBoxes: Array<ExtractedBox> = [];\n    for (const box of boxes) {\n      let spendBlock, spendHeight;\n      if (box.spentTransactionId) {\n        const block = await this.getTxBlock(box.spentTransactionId);\n        spendBlock = block.id;\n        spendHeight = block.height;\n      }\n      const ergoBox = ergoLib.ErgoBox.from_json(JsonBI.stringify(box));\n      extractedBoxes.push({\n        boxId: ergoBox.box_id().to_str(),\n        address: ergoLib.Address.recreate_from_ergo_tree(\n          ergoLib.ErgoTree.from_base16_bytes(\n            ergoBox.ergo_tree().to_base16_bytes()\n          )\n        ).to_base58(this.networkType),\n        serialized: Buffer.from(ergoBox.sigma_serialize_bytes()).toString(\n          'base64'\n        ),\n        blockId: box.blockId,\n        height: box.settlementHeight,\n        spendBlock: spendBlock,\n        spendHeight: spendHeight,\n      });\n    }\n    return extractedBoxes;\n  };\n\n  /**\n   * Returns true if box has the required token and false otherwise\n   * @param box\n   */\n  boxHasToken = (box: OutputInfo) => {\n    if (!box.assets) return false;\n    const boxTokens = box.assets.map((token) => token.tokenId);\n    const requiredTokens = intersection(this.tokens, boxTokens);\n    if (requiredTokens.length == this.tokens.length) return true;\n    return false;\n  };\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ErgoUTXOExtractor } from './extractor/ergoUtxoExtractor';
+export { BoxEntity } from './entities/boxEntity';
+export { migrations } from './migrations/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { ErgoUTXOExtractor } from './extractor/ergoUtxoExtractor';
+export { BoxEntity } from './entities/boxEntity';
+export { migrations } from './migrations/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDbEUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEVyZ29VVFhPRXh0cmFjdG9yIH0gZnJvbSAnLi9leHRyYWN0b3IvZXJnb1V0eG9FeHRyYWN0b3InO1xuZXhwb3J0IHsgQm94RW50aXR5IH0gZnJvbSAnLi9lbnRpdGllcy9ib3hFbnRpdHknO1xuZXhwb3J0IHsgbWlncmF0aW9ucyB9IGZyb20gJy4vbWlncmF0aW9ucy9pbmRleCc7XG4iXX0=

package/dist/interfaces/types.d.ts

@@ -0,0 +1,28 @@
+type Asset = {
+    tokenId: string;
+    index: number;
+    amount: bigint;
+};
+interface ErgoBoxJson {
+    boxId: string;
+    address: string;
+    value: bigint;
+    blockId: string;
+    settlementHeight: number;
+    assets: Array<Asset>;
+}
+interface Boxes {
+    items: Array<ErgoBoxJson>;
+    total: number;
+}
+interface ExtractedBox {
+    boxId: string;
+    address: string;
+    serialized: string;
+    blockId?: string;
+    height?: number;
+    spendBlock?: string;
+    spendHeight?: number;
+}
+export { ErgoBoxJson, Boxes, ExtractedBox };
+//# sourceMappingURL=types.d.ts.map

package/dist/interfaces/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../lib/interfaces/types.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,UAAU,WAAW;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;CACtB;AAED,UAAU,KAAK;IACb,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC"}

package/dist/interfaces/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvaW50ZXJmYWNlcy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsidHlwZSBBc3NldCA9IHtcbiAgdG9rZW5JZDogc3RyaW5nO1xuICBpbmRleDogbnVtYmVyO1xuICBhbW91bnQ6IGJpZ2ludDtcbn07XG5cbmludGVyZmFjZSBFcmdvQm94SnNvbiB7XG4gIGJveElkOiBzdHJpbmc7XG4gIGFkZHJlc3M6IHN0cmluZztcbiAgdmFsdWU6IGJpZ2ludDtcbiAgYmxvY2tJZDogc3RyaW5nO1xuICBzZXR0bGVtZW50SGVpZ2h0OiBudW1iZXI7XG4gIGFzc2V0czogQXJyYXk8QXNzZXQ+O1xufVxuXG5pbnRlcmZhY2UgQm94ZXMge1xuICBpdGVtczogQXJyYXk8RXJnb0JveEpzb24+O1xuICB0b3RhbDogbnVtYmVyO1xufVxuXG5pbnRlcmZhY2UgRXh0cmFjdGVkQm94IHtcbiAgYm94SWQ6IHN0cmluZztcbiAgYWRkcmVzczogc3RyaW5nO1xuICBzZXJpYWxpemVkOiBzdHJpbmc7XG4gIGJsb2NrSWQ/OiBzdHJpbmc7XG4gIGhlaWdodD86IG51bWJlcjtcbiAgc3BlbmRCbG9jaz86IHN0cmluZztcbiAgc3BlbmRIZWlnaHQ/OiBudW1iZXI7XG59XG5cbmV4cG9ydCB7IEVyZ29Cb3hKc29uLCBCb3hlcywgRXh0cmFjdGVkQm94IH07XG4iXX0=

package/dist/migrations/index.d.ts

@@ -0,0 +1,7 @@
+import { migration1688558553044 } from './postgres/1688558553044-migration';
+import { migration1688555566662 } from './sqlite/1688555566662-migration';
+export declare const migrations: {
+    sqlite: (typeof migration1688555566662)[];
+    postgres: (typeof migration1688558553044)[];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/migrations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAE5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAG1E,eAAO,MAAM,UAAU;;;CAGtB,CAAC"}

package/dist/migrations/index.js

@@ -0,0 +1,9 @@
+import { migration1688558553044 } from './postgres/1688558553044-migration';
+import { migration1689151869889 } from './postgres/1689151869889-migration';
+import { migration1688555566662 } from './sqlite/1688555566662-migration';
+import { migration1689143753142 } from './sqlite/1689143753142-migration';
+export const migrations = {
+    sqlite: [migration1688555566662, migration1689143753142],
+    postgres: [migration1688558553044, migration1689151869889],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvbWlncmF0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM1RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM1RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUMxRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUUxRSxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUc7SUFDeEIsTUFBTSxFQUFFLENBQUMsc0JBQXNCLEVBQUUsc0JBQXNCLENBQUM7SUFDeEQsUUFBUSxFQUFFLENBQUMsc0JBQXNCLEVBQUUsc0JBQXNCLENBQUM7Q0FDM0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG1pZ3JhdGlvbjE2ODg1NTg1NTMwNDQgfSBmcm9tICcuL3Bvc3RncmVzLzE2ODg1NTg1NTMwNDQtbWlncmF0aW9uJztcbmltcG9ydCB7IG1pZ3JhdGlvbjE2ODkxNTE4Njk4ODkgfSBmcm9tICcuL3Bvc3RncmVzLzE2ODkxNTE4Njk4ODktbWlncmF0aW9uJztcbmltcG9ydCB7IG1pZ3JhdGlvbjE2ODg1NTU1NjY2NjIgfSBmcm9tICcuL3NxbGl0ZS8xNjg4NTU1NTY2NjYyLW1pZ3JhdGlvbic7XG5pbXBvcnQgeyBtaWdyYXRpb24xNjg5MTQzNzUzMTQyIH0gZnJvbSAnLi9zcWxpdGUvMTY4OTE0Mzc1MzE0Mi1taWdyYXRpb24nO1xuXG5leHBvcnQgY29uc3QgbWlncmF0aW9ucyA9IHtcbiAgc3FsaXRlOiBbbWlncmF0aW9uMTY4ODU1NTU2NjY2MiwgbWlncmF0aW9uMTY4OTE0Mzc1MzE0Ml0sXG4gIHBvc3RncmVzOiBbbWlncmF0aW9uMTY4ODU1ODU1MzA0NCwgbWlncmF0aW9uMTY4OTE1MTg2OTg4OV0sXG59O1xuIl19

package/dist/migrations/postgres/1688558553044-migration.d.ts

@@ -0,0 +1,7 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class migration1688558553044 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+//# sourceMappingURL=1688558553044-migration.d.ts.map

package/dist/migrations/postgres/1688558553044-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1688558553044-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/postgres/1688558553044-migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D,qBAAa,sBAAuB,YAAW,kBAAkB;IAC/D,IAAI,SAA4B;IAEnB,EAAE,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3D"}

package/dist/migrations/postgres/1688558553044-migration.js

@@ -0,0 +1,24 @@
+export class migration1688558553044 {
+    name = 'migration1688558553044';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "box_entity" (
+                "id" SERIAL NOT NULL,
+                "address" character varying NOT NULL,
+                "boxId" character varying NOT NULL,
+                "createBlock" character varying NOT NULL,
+                "creationHeight" integer NOT NULL,
+                "serialized" character varying NOT NULL,
+                "spendBlock" text,
+                "extractor" character varying NOT NULL,
+                CONSTRAINT "PK_b3b74bea44218399800c0136bb6" PRIMARY KEY ("id")
+            )
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            DROP TABLE "box_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTY4ODU1ODU1MzA0NC1taWdyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvbWlncmF0aW9ucy9wb3N0Z3Jlcy8xNjg4NTU4NTUzMDQ0LW1pZ3JhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLElBQUksR0FBRyx3QkFBd0IsQ0FBQztJQUV6QixLQUFLLENBQUMsRUFBRSxDQUFDLFdBQXdCO1FBQ3RDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7Ozs7Ozs7Ozs7O1NBWW5CLENBQUMsQ0FBQztJQUNULENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSSxDQUFDLFdBQXdCO1FBQ3hDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7U0FFbkIsQ0FBQyxDQUFDO0lBQ1QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTWlncmF0aW9uSW50ZXJmYWNlLCBRdWVyeVJ1bm5lciB9IGZyb20gJ3R5cGVvcm0nO1xuXG5leHBvcnQgY2xhc3MgbWlncmF0aW9uMTY4ODU1ODU1MzA0NCBpbXBsZW1lbnRzIE1pZ3JhdGlvbkludGVyZmFjZSB7XG4gIG5hbWUgPSAnbWlncmF0aW9uMTY4ODU1ODU1MzA0NCc7XG5cbiAgcHVibGljIGFzeW5jIHVwKHF1ZXJ5UnVubmVyOiBRdWVyeVJ1bm5lcik6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHF1ZXJ5UnVubmVyLnF1ZXJ5KGBcbiAgICAgICAgICAgIENSRUFURSBUQUJMRSBcImJveF9lbnRpdHlcIiAoXG4gICAgICAgICAgICAgICAgXCJpZFwiIFNFUklBTCBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcImFkZHJlc3NcIiBjaGFyYWN0ZXIgdmFyeWluZyBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcImJveElkXCIgY2hhcmFjdGVyIHZhcnlpbmcgTk9UIE5VTEwsXG4gICAgICAgICAgICAgICAgXCJjcmVhdGVCbG9ja1wiIGNoYXJhY3RlciB2YXJ5aW5nIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwiY3JlYXRpb25IZWlnaHRcIiBpbnRlZ2VyIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwic2VyaWFsaXplZFwiIGNoYXJhY3RlciB2YXJ5aW5nIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwic3BlbmRCbG9ja1wiIHRleHQsXG4gICAgICAgICAgICAgICAgXCJleHRyYWN0b3JcIiBjaGFyYWN0ZXIgdmFyeWluZyBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBDT05TVFJBSU5UIFwiUEtfYjNiNzRiZWE0NDIxODM5OTgwMGMwMTM2YmI2XCIgUFJJTUFSWSBLRVkgKFwiaWRcIilcbiAgICAgICAgICAgIClcbiAgICAgICAgYCk7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgZG93bihxdWVyeVJ1bm5lcjogUXVlcnlSdW5uZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBxdWVyeVJ1bm5lci5xdWVyeShgXG4gICAgICAgICAgICBEUk9QIFRBQkxFIFwiYm94X2VudGl0eVwiXG4gICAgICAgIGApO1xuICB9XG59XG4iXX0=

package/dist/migrations/postgres/1689151869889-migration.d.ts

@@ -0,0 +1,7 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class migration1689151869889 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+//# sourceMappingURL=1689151869889-migration.d.ts.map

package/dist/migrations/postgres/1689151869889-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1689151869889-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/postgres/1689151869889-migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D,qBAAa,sBAAuB,YAAW,kBAAkB;IAC/D,IAAI,SAA4B;IAEnB,EAAE,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3D"}

package/dist/migrations/postgres/1689151869889-migration.js

@@ -0,0 +1,15 @@
+export class migration1689151869889 {
+    name = 'migration1689151869889';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            ALTER TABLE "box_entity"
+            ADD "spendHeight" integer
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            ALTER TABLE "box_entity" DROP COLUMN "spendHeight"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTY4OTE1MTg2OTg4OS1taWdyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvbWlncmF0aW9ucy9wb3N0Z3Jlcy8xNjg5MTUxODY5ODg5LW1pZ3JhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLElBQUksR0FBRyx3QkFBd0IsQ0FBQztJQUV6QixLQUFLLENBQUMsRUFBRSxDQUFDLFdBQXdCO1FBQ3RDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7O1NBR25CLENBQUMsQ0FBQztJQUNULENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSSxDQUFDLFdBQXdCO1FBQ3hDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7U0FFbkIsQ0FBQyxDQUFDO0lBQ1QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTWlncmF0aW9uSW50ZXJmYWNlLCBRdWVyeVJ1bm5lciB9IGZyb20gJ3R5cGVvcm0nO1xuXG5leHBvcnQgY2xhc3MgbWlncmF0aW9uMTY4OTE1MTg2OTg4OSBpbXBsZW1lbnRzIE1pZ3JhdGlvbkludGVyZmFjZSB7XG4gIG5hbWUgPSAnbWlncmF0aW9uMTY4OTE1MTg2OTg4OSc7XG5cbiAgcHVibGljIGFzeW5jIHVwKHF1ZXJ5UnVubmVyOiBRdWVyeVJ1bm5lcik6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHF1ZXJ5UnVubmVyLnF1ZXJ5KGBcbiAgICAgICAgICAgIEFMVEVSIFRBQkxFIFwiYm94X2VudGl0eVwiXG4gICAgICAgICAgICBBREQgXCJzcGVuZEhlaWdodFwiIGludGVnZXJcbiAgICAgICAgYCk7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgZG93bihxdWVyeVJ1bm5lcjogUXVlcnlSdW5uZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBxdWVyeVJ1bm5lci5xdWVyeShgXG4gICAgICAgICAgICBBTFRFUiBUQUJMRSBcImJveF9lbnRpdHlcIiBEUk9QIENPTFVNTiBcInNwZW5kSGVpZ2h0XCJcbiAgICAgICAgYCk7XG4gIH1cbn1cbiJdfQ==

package/dist/migrations/sqlite/1688555566662-migration.d.ts

@@ -0,0 +1,7 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class migration1688555566662 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+//# sourceMappingURL=1688555566662-migration.d.ts.map

package/dist/migrations/sqlite/1688555566662-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1688555566662-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/sqlite/1688555566662-migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D,qBAAa,sBAAuB,YAAW,kBAAkB;IAC/D,IAAI,SAA4B;IAEnB,EAAE,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAe3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3D"}

package/dist/migrations/sqlite/1688555566662-migration.js

@@ -0,0 +1,23 @@
+export class migration1688555566662 {
+    name = 'migration1688555566662';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "box_entity" (
+                "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+                "address" varchar NOT NULL,
+                "boxId" varchar NOT NULL,
+                "createBlock" varchar NOT NULL,
+                "creationHeight" integer NOT NULL,
+                "serialized" varchar NOT NULL,
+                "spendBlock" text,
+                "extractor" varchar NOT NULL
+            )
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            DROP TABLE "box_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTY4ODU1NTU2NjY2Mi1taWdyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvbWlncmF0aW9ucy9zcWxpdGUvMTY4ODU1NTU2NjY2Mi1taWdyYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLHNCQUFzQjtJQUNqQyxJQUFJLEdBQUcsd0JBQXdCLENBQUM7SUFFekIsS0FBSyxDQUFDLEVBQUUsQ0FBQyxXQUF3QjtRQUN0QyxNQUFNLFdBQVcsQ0FBQyxLQUFLLENBQUM7Ozs7Ozs7Ozs7O1NBV25CLENBQUMsQ0FBQztJQUNULENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSSxDQUFDLFdBQXdCO1FBQ3hDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7U0FFbkIsQ0FBQyxDQUFDO0lBQ1QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTWlncmF0aW9uSW50ZXJmYWNlLCBRdWVyeVJ1bm5lciB9IGZyb20gJ3R5cGVvcm0nO1xuXG5leHBvcnQgY2xhc3MgbWlncmF0aW9uMTY4ODU1NTU2NjY2MiBpbXBsZW1lbnRzIE1pZ3JhdGlvbkludGVyZmFjZSB7XG4gIG5hbWUgPSAnbWlncmF0aW9uMTY4ODU1NTU2NjY2Mic7XG5cbiAgcHVibGljIGFzeW5jIHVwKHF1ZXJ5UnVubmVyOiBRdWVyeVJ1bm5lcik6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHF1ZXJ5UnVubmVyLnF1ZXJ5KGBcbiAgICAgICAgICAgIENSRUFURSBUQUJMRSBcImJveF9lbnRpdHlcIiAoXG4gICAgICAgICAgICAgICAgXCJpZFwiIGludGVnZXIgUFJJTUFSWSBLRVkgQVVUT0lOQ1JFTUVOVCBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcImFkZHJlc3NcIiB2YXJjaGFyIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwiYm94SWRcIiB2YXJjaGFyIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwiY3JlYXRlQmxvY2tcIiB2YXJjaGFyIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwiY3JlYXRpb25IZWlnaHRcIiBpbnRlZ2VyIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwic2VyaWFsaXplZFwiIHZhcmNoYXIgTk9UIE5VTEwsXG4gICAgICAgICAgICAgICAgXCJzcGVuZEJsb2NrXCIgdGV4dCxcbiAgICAgICAgICAgICAgICBcImV4dHJhY3RvclwiIHZhcmNoYXIgTk9UIE5VTExcbiAgICAgICAgICAgIClcbiAgICAgICAgYCk7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgZG93bihxdWVyeVJ1bm5lcjogUXVlcnlSdW5uZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBxdWVyeVJ1bm5lci5xdWVyeShgXG4gICAgICAgICAgICBEUk9QIFRBQkxFIFwiYm94X2VudGl0eVwiXG4gICAgICAgIGApO1xuICB9XG59XG4iXX0=

package/dist/migrations/sqlite/1689143753142-migration.d.ts

@@ -0,0 +1,7 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class migration1689143753142 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+//# sourceMappingURL=1689143753142-migration.d.ts.map

package/dist/migrations/sqlite/1689143753142-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1689143753142-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/sqlite/1689143753142-migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1D,qBAAa,sBAAuB,YAAW,kBAAkB;IAC/D,IAAI,SAA4B;IAEnB,EAAE,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA4C3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAsC3D"}

package/dist/migrations/sqlite/1689143753142-migration.js

@@ -0,0 +1,85 @@
+export class migration1689143753142 {
+    name = 'migration1689143753142';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "temporary_box_entity" (
+                "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+                "address" varchar NOT NULL,
+                "boxId" varchar NOT NULL,
+                "createBlock" varchar NOT NULL,
+                "creationHeight" integer NOT NULL,
+                "serialized" varchar NOT NULL,
+                "spendBlock" text,
+                "extractor" varchar NOT NULL,
+                "spendHeight" integer
+            )
+        `);
+        await queryRunner.query(`
+            INSERT INTO "temporary_box_entity"(
+                    "id",
+                    "address",
+                    "boxId",
+                    "createBlock",
+                    "creationHeight",
+                    "serialized",
+                    "spendBlock",
+                    "extractor"
+                )
+            SELECT "id",
+                "address",
+                "boxId",
+                "createBlock",
+                "creationHeight",
+                "serialized",
+                "spendBlock",
+                "extractor"
+            FROM "box_entity"
+        `);
+        await queryRunner.query(`
+            DROP TABLE "box_entity"
+        `);
+        await queryRunner.query(`
+            ALTER TABLE "temporary_box_entity"
+                RENAME TO "box_entity"
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "box_entity" (
+                "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+                "address" varchar NOT NULL,
+                "boxId" varchar NOT NULL,
+                "createBlock" varchar NOT NULL,
+                "creationHeight" integer NOT NULL,
+                "serialized" varchar NOT NULL,
+                "spendBlock" text,
+                "extractor" varchar NOT NULL
+            )
+        `);
+        await queryRunner.query(`
+            INSERT INTO "box_entity"(
+                    "id",
+                    "address",
+                    "boxId",
+                    "createBlock",
+                    "creationHeight",
+                    "serialized",
+                    "spendBlock",
+                    "extractor"
+                )
+            SELECT "id",
+                "address",
+                "boxId",
+                "createBlock",
+                "creationHeight",
+                "serialized",
+                "spendBlock",
+                "extractor"
+            FROM "temporary_box_entity"
+        `);
+        await queryRunner.query(`
+            DROP TABLE "temporary_box_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+declare const JsonBI: {
+    parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+    stringify: {
+        (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+        (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+    };
+};
+export { JsonBI };
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../lib/utils.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,MAAM;;;;;;CAEV,CAAC;AAEH,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/utils.js

@@ -0,0 +1,6 @@
+import JSONBigInt from 'json-bigint';
+const JsonBI = JSONBigInt({
+    useNativeBigInt: true,
+});
+export { JsonBI };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxVQUFVLE1BQU0sYUFBYSxDQUFDO0FBRXJDLE1BQU0sTUFBTSxHQUFHLFVBQVUsQ0FBQztJQUN4QixlQUFlLEVBQUUsSUFBSTtDQUN0QixDQUFDLENBQUM7QUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgSlNPTkJpZ0ludCBmcm9tICdqc29uLWJpZ2ludCc7XG5cbmNvbnN0IEpzb25CSSA9IEpTT05CaWdJbnQoe1xuICB1c2VOYXRpdmVCaWdJbnQ6IHRydWUsXG59KTtcblxuZXhwb3J0IHsgSnNvbkJJIH07XG4iXX0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/address-extractor",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "UTXO box extractor for any address or token.",
   "author": "Rosen Team",
   "license": "GPL-3.0",