@rosen-bridge/watcher-data-extractor 5.0.0 → 5.0.1

package/dist/actions/collateralAction.d.ts

@@ -0,0 +1,70 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockEntity } from '@rosen-bridge/scanner';
+import { DataSource, DeleteResult } from 'typeorm';
+import CollateralEntity from '../entities/CollateralEntity';
+import { ExtractedCollateral } from '../interfaces/extractedCollateral';
+declare class CollateralAction {
+    private readonly dataSource;
+    readonly logger: AbstractLogger;
+    private readonly collateralRepository;
+    constructor(dataSource: DataSource, logger?: AbstractLogger);
+    /**
+     * saves (upserts) a collateral into the database
+     *
+     * @param {ExtractedCollateral} collateral
+     * @param {string} extractor
+     * @memberof CollateralAction
+     */
+    saveCollateral: (collateral: Partial<ExtractedCollateral> & Pick<ExtractedCollateral, 'boxId'>, extractor: string) => Promise<{
+        extractor: string;
+        boxId: string;
+        boxSerialized: string | undefined;
+        wId: string | undefined;
+        rwtCount: bigint | undefined;
+        txId: string | undefined;
+        block: string | undefined;
+        height: number | undefined;
+        spendBlock: string | undefined;
+        spendHeight: number | undefined;
+        id?: number | undefined;
+    } & CollateralEntity>;
+    /**
+     * stores list of collaterals
+     *
+     * @param {Array<ExtractedCollateral>} collaterals
+     * @param {BlockEntity} block
+     * @param {string} extractor
+     * @return {Promise<boolean>}
+     * @memberof CollateralAction
+     */
+    storeCollaterals: (collaterals: Array<ExtractedCollateral>, block: BlockEntity, extractor: string) => Promise<boolean>;
+    /**
+     * Update spendBlock and spendHeight of collaterals spent in the block
+     *
+     * @param {Array<string>} spentBoxIds
+     * @param {BlockEntity} block
+     * @param {string} extractor
+     * @return {Promise<void>}
+     * @memberof CollateralAction
+     */
+    spendCollaterals: (spentBoxIds: Array<string>, block: BlockEntity, extractor: string) => Promise<void>;
+    /**
+     * Returns all stored unspent collateral box IDs
+     *
+     * @param {string} extractor
+     * @return {Promise<Array<string>>}
+     * @memberof CollateralAction
+     */
+    getUnspentCollateralBoxIds: (extractor: string) => Promise<Array<string>>;
+    /**
+     * deletes the specified collateral box from database
+     *
+     * @param {string} boxId
+     * @param {string} extractor
+     * @return {Promise<DeleteResult>}
+     * @memberof CollateralAction
+     */
+    deleteCollateral: (boxId: string, extractor: string) => Promise<DeleteResult>;
+}
+export default CollateralAction;
+//# sourceMappingURL=collateralAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collateralAction.d.ts","sourceRoot":"","sources":["../../lib/actions/collateralAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,UAAU,EAAE,YAAY,EAA0B,MAAM,SAAS,CAAC;AAE3E,OAAO,gBAAgB,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAGxE,cAAM,gBAAgB;IAIlB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,MAAM,EAAE,cAAc;IAJjC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA+B;gBAGjD,UAAU,EAAE,UAAU,EAC9B,MAAM,GAAE,cAAkC;IAKrD;;;;;;OAMG;IACH,cAAc,eACA,QAAQ,mBAAmB,CAAC,GACtC,KAAK,mBAAmB,EAAE,OAAO,CAAC,aACzB,MAAM;;;;;;;;;;;;0BA6BjB;IAEF;;;;;;;;OAQG;IACH,gBAAgB,gBACD,MAAM,mBAAmB,CAAC,SAChC,WAAW,aACP,MAAM,KAChB,QAAQ,OAAO,CAAC,CAmEjB;IAEF;;;;;;;;OAQG;IACH,gBAAgB,gBACD,MAAM,MAAM,CAAC,SACnB,WAAW,aACP,MAAM,KAChB,QAAQ,IAAI,CAAC,CAoBd;IAEF;;;;;;OAMG;IACH,0BAA0B,cACb,MAAM,KAChB,QAAQ,MAAM,MAAM,CAAC,CAAC,CAWvB;IAEF;;;;;;;OAOG;IACH,gBAAgB,UACP,MAAM,aACF,MAAM,KAChB,QAAQ,YAAY,CAAC,CAKtB;CACH;AAED,eAAe,gBAAgB,CAAC"}

package/dist/actions/collateralAction.js

@@ -0,0 +1,168 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { chunk } from 'lodash-es';
+import { In, IsNull } from 'typeorm';
+import { dbIdChunkSize } from '../constants';
+import CollateralEntity from '../entities/CollateralEntity';
+class CollateralAction {
+    dataSource;
+    logger;
+    collateralRepository;
+    constructor(dataSource, logger = new DummyLogger()) {
+        this.dataSource = dataSource;
+        this.logger = logger;
+        this.collateralRepository = this.dataSource.getRepository(CollateralEntity);
+    }
+    /**
+     * saves (upserts) a collateral into the database
+     *
+     * @param {ExtractedCollateral} collateral
+     * @param {string} extractor
+     * @memberof CollateralAction
+     */
+    saveCollateral = async (collateral, extractor) => {
+        const id = (await this.collateralRepository.findOne({
+            where: {
+                boxId: collateral.boxId,
+                extractor,
+            },
+            select: {
+                id: true,
+            },
+        }))?.id;
+        const collateralEntity = {
+            ...(id != undefined && { id }),
+            extractor,
+            boxId: collateral.boxId,
+            boxSerialized: collateral.boxSerialized,
+            wId: collateral.wId,
+            rwtCount: collateral.rwtCount,
+            txId: collateral.txId,
+            block: collateral.block,
+            height: collateral.height,
+            spendBlock: collateral.spendBlock,
+            spendHeight: collateral.spendHeight,
+        };
+        return await this.collateralRepository.save(collateralEntity);
+    };
+    /**
+     * stores list of collaterals
+     *
+     * @param {Array<ExtractedCollateral>} collaterals
+     * @param {BlockEntity} block
+     * @param {string} extractor
+     * @return {Promise<boolean>}
+     * @memberof CollateralAction
+     */
+    storeCollaterals = async (collaterals, block, extractor) => {
+        const collateralEntities = collaterals.map((col) => ({
+            extractor: extractor,
+            boxId: col.boxId,
+            boxSerialized: col.boxSerialized,
+            wId: col.wId,
+            rwtCount: col.rwtCount,
+            txId: col.txId,
+            block: block.hash,
+            height: col.height != undefined ? col.height : block.height,
+        }));
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const repository = await queryRunner.manager.getRepository(CollateralEntity);
+            const boxIdToId = new Map();
+            (await repository.find({
+                where: {
+                    boxId: In(collateralEntities.map((box) => box.boxId)),
+                    extractor: extractor,
+                },
+                select: {
+                    id: true,
+                    boxId: true,
+                },
+            })).forEach((col) => boxIdToId.set(col.boxId, col.id));
+            const collateralsToUpdate = collateralEntities
+                .filter((col) => boxIdToId.has(col.boxId))
+                .map((col) => ({ ...col, id: boxIdToId.get(col.boxId) }));
+            const collateralsToInsert = collateralEntities.filter((col) => !boxIdToId.has(col.boxId));
+            this.logger.info(`Saving boxes with following IDs into the database: [${collateralEntities
+                .map((col) => col.boxId)
+                .join(', ')}]`);
+            const savedCollaterals = await repository.save([
+                ...collateralsToInsert,
+                ...collateralsToUpdate,
+            ]);
+            await queryRunner.commitTransaction();
+            this.logger.debug(`Saved boxes with following IDs into the database: [${savedCollaterals
+                .map((col) => col.boxId)
+                .join(', ')}]`);
+        }
+        catch (e) {
+            await queryRunner.rollbackTransaction();
+            this.logger.error(`An error occurred during storeCollaterals action: ${e}`);
+            return false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return true;
+    };
+    /**
+     * Update spendBlock and spendHeight of collaterals spent in the block
+     *
+     * @param {Array<string>} spentBoxIds
+     * @param {BlockEntity} block
+     * @param {string} extractor
+     * @return {Promise<void>}
+     * @memberof CollateralAction
+     */
+    spendCollaterals = async (spentBoxIds, block, extractor) => {
+        const spentBoxIdChunks = chunk(spentBoxIds, dbIdChunkSize);
+        for (const spendIdChunk of spentBoxIdChunks) {
+            const updateResult = await this.collateralRepository.update({ boxId: In(spendIdChunk), extractor: extractor }, { spendBlock: block.hash, spendHeight: block.height });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const updatedRows = await this.collateralRepository.findBy({
+                    boxId: In(spendIdChunk),
+                    spendBlock: block.hash,
+                });
+                for (const row of updatedRows) {
+                    this.logger.debug(`Spent collateral with boxId [${row.boxId}] belonging to watcher with WID [${row.wId}] at height ${block.height}`);
+                }
+            }
+        }
+    };
+    /**
+     * Returns all stored unspent collateral box IDs
+     *
+     * @param {string} extractor
+     * @return {Promise<Array<string>>}
+     * @memberof CollateralAction
+     */
+    getUnspentCollateralBoxIds = async (extractor) => {
+        const boxIds = await this.collateralRepository.find({
+            where: {
+                extractor: extractor,
+                spendBlock: IsNull(),
+            },
+            select: {
+                boxId: true,
+            },
+        });
+        return boxIds.map((box) => box.boxId);
+    };
+    /**
+     * deletes the specified collateral box from database
+     *
+     * @param {string} boxId
+     * @param {string} extractor
+     * @return {Promise<DeleteResult>}
+     * @memberof CollateralAction
+     */
+    deleteCollateral = async (boxId, extractor) => {
+        return await this.collateralRepository.delete({
+            boxId: boxId,
+            extractor: extractor,
+        });
+    };
+}
+export default CollateralAction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collateralAction.js","sourceRoot":"","sources":["../../lib/actions/collateralAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { BlockEntity } from '@rosen-bridge/scanner';\nimport { chunk } from 'lodash-es';\nimport { DataSource, DeleteResult, In, IsNull, Repository } from 'typeorm';\nimport { dbIdChunkSize } from '../constants';\nimport CollateralEntity from '../entities/CollateralEntity';\nimport { ExtractedCollateral } from '../interfaces/extractedCollateral';\nimport { JsonBI } from '../utils';\n\nclass CollateralAction {\n  private readonly collateralRepository: Repository<CollateralEntity>;\n\n  constructor(\n    private readonly dataSource: DataSource,\n    readonly logger: AbstractLogger = new DummyLogger()\n  ) {\n    this.collateralRepository = this.dataSource.getRepository(CollateralEntity);\n  }\n\n  /**\n   * saves (upserts) a collateral into the database\n   *\n   * @param {ExtractedCollateral} collateral\n   * @param {string} extractor\n   * @memberof CollateralAction\n   */\n  saveCollateral = async (\n    collateral: Partial<ExtractedCollateral> &\n      Pick<ExtractedCollateral, 'boxId'>,\n    extractor: string\n  ) => {\n    const id = (\n      await this.collateralRepository.findOne({\n        where: {\n          boxId: collateral.boxId,\n          extractor,\n        },\n        select: {\n          id: true,\n        },\n      })\n    )?.id;\n\n    const collateralEntity = {\n      ...(id != undefined && { id }),\n      extractor,\n      boxId: collateral.boxId,\n      boxSerialized: collateral.boxSerialized,\n      wId: collateral.wId,\n      rwtCount: collateral.rwtCount,\n      txId: collateral.txId,\n      block: collateral.block,\n      height: collateral.height,\n      spendBlock: collateral.spendBlock,\n      spendHeight: collateral.spendHeight,\n    };\n\n    return await this.collateralRepository.save(collateralEntity);\n  };\n\n  /**\n   * stores list of collaterals\n   *\n   * @param {Array<ExtractedCollateral>} collaterals\n   * @param {BlockEntity} block\n   * @param {string} extractor\n   * @return {Promise<boolean>}\n   * @memberof CollateralAction\n   */\n  storeCollaterals = async (\n    collaterals: Array<ExtractedCollateral>,\n    block: BlockEntity,\n    extractor: string\n  ): Promise<boolean> => {\n    const collateralEntities = collaterals.map((col) => ({\n      extractor: extractor,\n      boxId: col.boxId,\n      boxSerialized: col.boxSerialized,\n      wId: col.wId,\n      rwtCount: col.rwtCount,\n      txId: col.txId,\n      block: block.hash,\n      height: col.height != undefined ? col.height : block.height,\n    }));\n\n    const queryRunner = this.dataSource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    try {\n      const repository = await queryRunner.manager.getRepository(\n        CollateralEntity\n      );\n      const boxIdToId = new Map<string, number>();\n      (\n        await repository.find({\n          where: {\n            boxId: In(collateralEntities.map((box) => box.boxId)),\n            extractor: extractor,\n          },\n          select: {\n            id: true,\n            boxId: true,\n          },\n        })\n      ).forEach((col) => boxIdToId.set(col.boxId, col.id));\n\n      const collateralsToUpdate = collateralEntities\n        .filter((col) => boxIdToId.has(col.boxId))\n        .map((col) => ({ ...col, id: boxIdToId.get(col.boxId) }));\n\n      const collateralsToInsert = collateralEntities.filter(\n        (col) => !boxIdToId.has(col.boxId)\n      );\n\n      this.logger.info(\n        `Saving boxes with following IDs into the database: [${collateralEntities\n          .map((col) => col.boxId)\n          .join(', ')}]`\n      );\n      const savedCollaterals = await repository.save([\n        ...collateralsToInsert,\n        ...collateralsToUpdate,\n      ]);\n      await queryRunner.commitTransaction();\n      this.logger.debug(\n        `Saved boxes with following IDs into the database: [${savedCollaterals\n          .map((col) => col.boxId)\n          .join(', ')}]`\n      );\n    } catch (e) {\n      await queryRunner.rollbackTransaction();\n      this.logger.error(\n        `An error occurred during storeCollaterals action: ${e}`\n      );\n      return false;\n    } finally {\n      await queryRunner.release();\n    }\n\n    return true;\n  };\n\n  /**\n   * Update spendBlock and spendHeight of collaterals spent in the block\n   *\n   * @param {Array<string>} spentBoxIds\n   * @param {BlockEntity} block\n   * @param {string} extractor\n   * @return {Promise<void>}\n   * @memberof CollateralAction\n   */\n  spendCollaterals = async (\n    spentBoxIds: Array<string>,\n    block: BlockEntity,\n    extractor: string\n  ): Promise<void> => {\n    const spentBoxIdChunks = chunk(spentBoxIds, dbIdChunkSize);\n    for (const spendIdChunk of spentBoxIdChunks) {\n      const updateResult = await this.collateralRepository.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 updatedRows = await this.collateralRepository.findBy({\n          boxId: In(spendIdChunk),\n          spendBlock: block.hash,\n        });\n        for (const row of updatedRows) {\n          this.logger.debug(\n            `Spent collateral with boxId [${row.boxId}] belonging to watcher with WID [${row.wId}] at height ${block.height}`\n          );\n        }\n      }\n    }\n  };\n\n  /**\n   * Returns all stored unspent collateral box IDs\n   *\n   * @param {string} extractor\n   * @return {Promise<Array<string>>}\n   * @memberof CollateralAction\n   */\n  getUnspentCollateralBoxIds = async (\n    extractor: string\n  ): Promise<Array<string>> => {\n    const boxIds = await this.collateralRepository.find({\n      where: {\n        extractor: extractor,\n        spendBlock: IsNull(),\n      },\n      select: {\n        boxId: true,\n      },\n    });\n    return boxIds.map((box) => box.boxId);\n  };\n\n  /**\n   * deletes the specified collateral box from database\n   *\n   * @param {string} boxId\n   * @param {string} extractor\n   * @return {Promise<DeleteResult>}\n   * @memberof CollateralAction\n   */\n  deleteCollateral = async (\n    boxId: string,\n    extractor: string\n  ): Promise<DeleteResult> => {\n    return await this.collateralRepository.delete({\n      boxId: boxId,\n      extractor: extractor,\n    });\n  };\n}\n\nexport default CollateralAction;\n"]}

package/dist/entities/CollateralEntity.d.ts

@@ -0,0 +1,15 @@
+declare class CollateralEntity {
+    id: number;
+    extractor: string;
+    boxId: string;
+    boxSerialized: string;
+    wId: string;
+    rwtCount: bigint;
+    txId: string;
+    block?: string;
+    height?: number;
+    spendBlock?: string;
+    spendHeight?: number;
+}
+export default CollateralEntity;
+//# sourceMappingURL=CollateralEntity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CollateralEntity.d.ts","sourceRoot":"","sources":["../../lib/entities/CollateralEntity.ts"],"names":[],"mappings":"AAGA,cAEM,gBAAgB;IAEpB,EAAE,EAAE,MAAM,CAAC;IAGX,SAAS,EAAE,MAAM,CAAC;IAGlB,KAAK,EAAE,MAAM,CAAC;IAGd,aAAa,EAAE,MAAM,CAAC;IAGtB,GAAG,EAAE,MAAM,CAAC;IAGZ,QAAQ,EAAE,MAAM,CAAC;IAGjB,IAAI,EAAE,MAAM,CAAC;IAGb,KAAK,CAAC,EAAE,MAAM,CAAC;IAGf,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAe,gBAAgB,CAAC"}

package/dist/entities/CollateralEntity.js

@@ -0,0 +1,74 @@
+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, Unique } from 'typeorm';
+import { bigintTransformer } from '../transformers';
+let CollateralEntity = class CollateralEntity {
+    id;
+    extractor;
+    boxId;
+    boxSerialized;
+    wId;
+    rwtCount;
+    txId;
+    block;
+    height;
+    spendBlock;
+    spendHeight;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], CollateralEntity.prototype, "id", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "extractor", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "boxId", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "boxSerialized", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "wId", void 0);
+__decorate([
+    Column({ type: 'bigint', transformer: bigintTransformer }),
+    __metadata("design:type", BigInt)
+], CollateralEntity.prototype, "rwtCount", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "txId", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "block", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", Number)
+], CollateralEntity.prototype, "height", void 0);
+__decorate([
+    Column({ nullable: true, type: 'text' }),
+    __metadata("design:type", String)
+], CollateralEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", Number)
+], CollateralEntity.prototype, "spendHeight", void 0);
+CollateralEntity = __decorate([
+    Entity('collateral_entity'),
+    Unique(['boxId', 'extractor'])
+], CollateralEntity);
+export default CollateralEntity;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/extractor/collateralExtractor.d.ts

@@ -0,0 +1,69 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractExtractor, BlockEntity, Transaction } from '@rosen-bridge/scanner';
+import { DataSource } from 'typeorm';
+import CollateralAction from '../actions/collateralAction';
+export declare class CollateralExtractor extends AbstractExtractor<Transaction> {
+    private readonly id;
+    private readonly awcNft;
+    private readonly address;
+    private readonly dataSource;
+    private readonly logger;
+    private readonly ergoTree;
+    readonly action: CollateralAction;
+    private explorerApi;
+    constructor(id: string, awcNft: string, address: string, dataSource: DataSource, explorerUrl: string, logger?: AbstractLogger);
+    /**
+     * get id for extractor. This id must be unique over all extractors.
+     *
+     * @return {string}
+     */
+    getId: () => string;
+    /**
+     * process a list of transactions and store collateral box details
+     *
+     * @param {Transaction[]} txs list of transaction for block
+     * @param {BlockEntity} block block id for transactions as hex encoded
+     * @return {Promise<boolean>} Promise<boolean> if no error occurred return
+     * true. otherwise, return false
+     */
+    processTransactions: (txs: Transaction[], block: BlockEntity) => Promise<boolean>;
+    private isCollateralBox;
+    forkBlock: (hash: string) => Promise<void>;
+    /**
+     * Initializes the database with older collaterals
+     *
+     * @param {number} initialHeight
+     * @return {Promise<void>}
+     * @memberof CollateralExtractor
+     */
+    initializeBoxes: (initialHeight: number) => Promise<void>;
+    /**
+     * removes or updates stored collateral boxes before initializing boxes
+     *
+     * @private
+     * @param {number} initialHeight
+     * @param {string[]} collateralBoxIds
+     * @return {Promise<void>}
+     * @memberof CollateralExtractor
+     */
+    private tidyUpStoredCollaterals;
+    /**
+     * gets all unspent collaterals from Ergo explorer api
+     *
+     * @private
+     * @param {number} initialHeight
+     * @return {Promise<Array<ExtractedCollateral>>}
+     * @memberof CollateralExtractor
+     */
+    private getAllUnspentCollaterals;
+    /**
+     * converts output box information to an ExtractedCollateral object
+     *
+     * @private
+     * @param {(OutputInfo | OutputBox)} box
+     * @return {ExtractedCollateral}
+     * @memberof CollateralExtractor
+     */
+    private toExtractedCollateral;
+}
+//# sourceMappingURL=collateralExtractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collateralExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/collateralExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,iBAAiB,EACjB,WAAW,EAEX,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,gBAAgB,MAAM,6BAA6B,CAAC;AAK3D,qBAAa,mBAAoB,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IAMnE,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAE3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,OAAO,CAAC,WAAW,CAAC;gBAGD,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,UAAU,EACvC,WAAW,EAAE,MAAM,EACF,MAAM,GAAE,cAAkC;IAU7D;;;;OAIG;IACH,KAAK,QAAO,MAAM,CAAY;IAE9B;;;;;;;OAOG;IACH,mBAAmB,QACZ,WAAW,EAAE,SACX,WAAW,KACjB,QAAQ,OAAO,CAAC,CAyBjB;IAEF,OAAO,CAAC,eAAe;IASvB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;OAMG;IACH,eAAe,kBAAyB,MAAM,KAAG,QAAQ,IAAI,CAAC,CA+B5D;IAEF;;;;;;;;OAQG;YACW,uBAAuB;IA6CrC;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB,CA8B9B;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB,CAwD3B;CACH"}

package/dist/extractor/collateralExtractor.js

@@ -0,0 +1,215 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractExtractor, } from '@rosen-bridge/scanner';
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+import * as ergoLib from 'ergo-lib-wasm-nodejs';
+import CollateralAction from '../actions/collateralAction';
+import { DefaultApiLimit } from '../constants';
+import { JsonBI, uint8ArrayToHex } from '../utils';
+export class CollateralExtractor extends AbstractExtractor {
+    id;
+    awcNft;
+    address;
+    dataSource;
+    logger;
+    ergoTree;
+    action;
+    explorerApi;
+    constructor(id, awcNft, address, dataSource, explorerUrl, logger = new DummyLogger()) {
+        super();
+        this.id = id;
+        this.awcNft = awcNft;
+        this.address = address;
+        this.dataSource = dataSource;
+        this.logger = logger;
+        this.ergoTree = ergoLib.Address.from_base58(this.address)
+            .to_ergo_tree()
+            .to_base16_bytes();
+        this.action = new CollateralAction(this.dataSource, this.logger);
+        this.explorerApi = ergoExplorerClientFactory(explorerUrl);
+    }
+    /**
+     * get id for extractor. This id must be unique over all extractors.
+     *
+     * @return {string}
+     */
+    getId = () => this.id;
+    /**
+     * process a list of transactions and store collateral box details
+     *
+     * @param {Transaction[]} txs list of transaction for block
+     * @param {BlockEntity} block block id for transactions as hex encoded
+     * @return {Promise<boolean>} Promise<boolean> if no error occurred return
+     * true. otherwise, return false
+     */
+    processTransactions = async (txs, block) => {
+        const boxes = [];
+        const spendBoxIds = [];
+        for (const tx of txs) {
+            for (const outputBox of tx.outputs) {
+                if (!this.isCollateralBox(outputBox)) {
+                    continue;
+                }
+                boxes.push(this.toExtractedCollateral(outputBox));
+            }
+            spendBoxIds.push(...tx.inputs.map((box) => box.boxId));
+        }
+        try {
+            await this.action.storeCollaterals(boxes, block, this.getId());
+            await this.action.spendCollaterals(spendBoxIds, block, this.getId());
+        }
+        catch (e) {
+            this.logger.error(`Error in storing collaterals of the block ${block}: ${e}`);
+            return false;
+        }
+        return true;
+    };
+    isCollateralBox(outputBox) {
+        const awcNft = outputBox.assets?.at(0)?.tokenId;
+        return (awcNft != undefined &&
+            awcNft === this.awcNft &&
+            outputBox.ergoTree === this.ergoTree);
+    }
+    forkBlock;
+    /**
+     * Initializes the database with older collaterals
+     *
+     * @param {number} initialHeight
+     * @return {Promise<void>}
+     * @memberof CollateralExtractor
+     */
+    initializeBoxes = async (initialHeight) => {
+        const unspentCollaterals = await this.getAllUnspentCollaterals(initialHeight);
+        this.logger.debug(`unspent collateral box info with following IDs gotten form Ergo network: [${unspentCollaterals
+            .map((box) => box.boxId)
+            .join(', ')}]`);
+        const storedUnspentCollateralBoxIds = await this.action.getUnspentCollateralBoxIds(this.getId());
+        const unspentCollateralBoxIds = new Set(unspentCollaterals.map((box) => box.boxId));
+        await this.tidyUpStoredCollaterals(initialHeight, storedUnspentCollateralBoxIds.filter((boxId) => !unspentCollateralBoxIds.has(boxId)));
+        for (const collateral of unspentCollaterals) {
+            this.logger.debug(`saving unspent collateral with boxId=[${collateral.boxId}] to database for initialization`);
+            await this.action.saveCollateral(collateral, this.getId());
+            this.logger.debug(`saved unspent collateral with boxId=[${collateral.boxId}] to database for initialization`);
+        }
+    };
+    /**
+     * removes or updates stored collateral boxes before initializing boxes
+     *
+     * @private
+     * @param {number} initialHeight
+     * @param {string[]} collateralBoxIds
+     * @return {Promise<void>}
+     * @memberof CollateralExtractor
+     */
+    async tidyUpStoredCollaterals(initialHeight, collateralBoxIds) {
+        for (const boxId of collateralBoxIds) {
+            let boxInfo;
+            try {
+                boxInfo = await this.explorerApi.v1.getApiV1BoxesP1(boxId);
+            }
+            catch (e) {
+                if (e?.response?.status === 404) {
+                    this.action.deleteCollateral(boxId, this.getId());
+                }
+                else {
+                    throw new Error(`something went wrong when trying to get box=[${boxId}] from Ergo network: ${e?.message}`);
+                }
+                return;
+            }
+            if (boxInfo?.spentTransactionId != null) {
+                try {
+                    const transactionInfo = await this.explorerApi.v1.getApiV1TransactionsP1(boxInfo.spentTransactionId);
+                    if (transactionInfo.inclusionHeight < initialHeight) {
+                        this.action.saveCollateral({
+                            boxId: boxId,
+                            spendHeight: transactionInfo.inclusionHeight,
+                            spendBlock: transactionInfo.blockId,
+                        }, this.getId());
+                    }
+                }
+                catch (e) {
+                    throw new Error(`something went wrong when trying to get transaction=[${boxInfo.spentTransactionId}] from Ergo network: ${e?.message}`);
+                }
+            }
+        }
+    }
+    /**
+     * gets all unspent collaterals from Ergo explorer api
+     *
+     * @private
+     * @param {number} initialHeight
+     * @return {Promise<Array<ExtractedCollateral>>}
+     * @memberof CollateralExtractor
+     */
+    getAllUnspentCollaterals = async (initialHeight) => {
+        const extractedBoxes = [];
+        let offset = 0;
+        let total = 1;
+        while (offset < total) {
+            const boxes = await this.explorerApi.v1.getApiV1BoxesUnspentByergotreeP1(this.ergoTree, { offset: offset, limit: DefaultApiLimit });
+            if (!boxes.items) {
+                throw new Error('Explorer api output items should not be undefined.');
+            }
+            extractedBoxes.push(...boxes.items
+                .filter((box) => box.creationHeight &&
+                box.creationHeight < initialHeight &&
+                this.isCollateralBox(box))
+                .map((box) => this.toExtractedCollateral(box)));
+            total = boxes.total;
+            offset += DefaultApiLimit;
+        }
+        return extractedBoxes;
+    };
+    /**
+     * converts output box information to an ExtractedCollateral object
+     *
+     * @private
+     * @param {(OutputInfo | OutputBox)} box
+     * @return {ExtractedCollateral}
+     * @memberof CollateralExtractor
+     */
+    toExtractedCollateral = (box) => {
+        const ergoOutputBox = ergoLib.ErgoBox.from_json(JsonBI.stringify(box));
+        let r4;
+        try {
+            r4 = ergoOutputBox
+                .register_value(ergoLib.NonMandatoryRegisterId.R4)
+                ?.to_byte_array();
+        }
+        catch (e) {
+            throw new Error(`collateral box with boxId=${box.boxId} skipped: ${e}`);
+        }
+        if (r4 == undefined) {
+            throw new Error(`collateral box with boxId=${box.boxId} skipped, because of an invalid R4 register`);
+        }
+        const wId = uint8ArrayToHex(r4);
+        this.logger.debug(`Extracted WID=[${wId}] from R4 register of box=${ergoOutputBox
+            .box_id()
+            .to_str()}`);
+        let r5;
+        try {
+            r5 = ergoOutputBox
+                .register_value(ergoLib.NonMandatoryRegisterId.R5)
+                ?.to_i64()
+                .to_str();
+        }
+        catch (e) {
+            throw new Error(`collateral box with boxId=${box.boxId} skipped: ${e}`);
+        }
+        if (r5 == undefined) {
+            throw new Error(`collateral box with boxId=${box.boxId} skipped, because of an invalid R5 register`);
+        }
+        const rwtCount = BigInt(r5);
+        this.logger.debug(`Extracted rwtCount=[${rwtCount}] from R5 register of box=${ergoOutputBox
+            .box_id()
+            .to_str()}`);
+        return {
+            boxId: box.boxId,
+            boxSerialized: Buffer.from(ergoOutputBox.sigma_serialize_bytes()).toString('base64'),
+            wId: wId,
+            rwtCount: rwtCount,
+            txId: box.transactionId,
+            height: Number(box.creationHeight),
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collateralExtractor.js","sourceRoot":"","sources":["../../lib/extractor/collateralExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  AbstractExtractor,\n  BlockEntity,\n  OutputBox,\n  Transaction,\n} from '@rosen-bridge/scanner';\nimport ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';\nimport { TransactionInfo } from '@rosen-clients/ergo-explorer/dist/src/v1/types';\nimport { OutputInfo } from '@rosen-clients/ergo-explorer/dist/src/v1/types/outputInfo';\nimport * as ergoLib from 'ergo-lib-wasm-nodejs';\nimport { DataSource } from 'typeorm';\nimport CollateralAction from '../actions/collateralAction';\nimport { DefaultApiLimit } from '../constants';\nimport { ExtractedCollateral } from '../interfaces/extractedCollateral';\nimport { JsonBI, uint8ArrayToHex } from '../utils';\n\nexport class CollateralExtractor extends AbstractExtractor<Transaction> {\n  private readonly ergoTree: string;\n  readonly action: CollateralAction;\n  private explorerApi;\n\n  constructor(\n    private readonly id: string,\n    private readonly awcNft: string,\n    private readonly address: string,\n    private readonly dataSource: DataSource,\n    explorerUrl: string,\n    private readonly logger: AbstractLogger = new DummyLogger()\n  ) {\n    super();\n    this.ergoTree = ergoLib.Address.from_base58(this.address)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.action = new CollateralAction(this.dataSource, this.logger);\n    this.explorerApi = ergoExplorerClientFactory(explorerUrl);\n  }\n\n  /**\n   * get id for extractor. This id must be unique over all extractors.\n   *\n   * @return {string}\n   */\n  getId = (): string => this.id;\n\n  /**\n   * process a list of transactions and store collateral box details\n   *\n   * @param {Transaction[]} txs list of transaction for block\n   * @param {BlockEntity} block block id for transactions as hex encoded\n   * @return {Promise<boolean>} Promise<boolean> if no error occurred return\n   * true. otherwise, return false\n   */\n  processTransactions = async (\n    txs: Transaction[],\n    block: BlockEntity\n  ): Promise<boolean> => {\n    const boxes: Array<ExtractedCollateral> = [];\n    const spendBoxIds: Array<string> = [];\n    for (const tx of txs) {\n      for (const outputBox of tx.outputs) {\n        if (!this.isCollateralBox(outputBox)) {\n          continue;\n        }\n        boxes.push(this.toExtractedCollateral(outputBox));\n      }\n\n      spendBoxIds.push(...tx.inputs.map((box) => box.boxId));\n    }\n\n    try {\n      await this.action.storeCollaterals(boxes, block, this.getId());\n      await this.action.spendCollaterals(spendBoxIds, block, this.getId());\n    } catch (e) {\n      this.logger.error(\n        `Error in storing collaterals of the block ${block}: ${e}`\n      );\n      return false;\n    }\n\n    return true;\n  };\n\n  private isCollateralBox(outputBox: OutputBox): boolean {\n    const awcNft = outputBox.assets?.at(0)?.tokenId;\n    return (\n      awcNft != undefined &&\n      awcNft === this.awcNft &&\n      outputBox.ergoTree === this.ergoTree\n    );\n  }\n\n  forkBlock: (hash: string) => Promise<void>;\n\n  /**\n   * Initializes the database with older collaterals\n   *\n   * @param {number} initialHeight\n   * @return {Promise<void>}\n   * @memberof CollateralExtractor\n   */\n  initializeBoxes = async (initialHeight: number): Promise<void> => {\n    const unspentCollaterals = await this.getAllUnspentCollaterals(\n      initialHeight\n    );\n    this.logger.debug(\n      `unspent collateral box info with following IDs gotten form Ergo network: [${unspentCollaterals\n        .map((box) => box.boxId)\n        .join(', ')}]`\n    );\n\n    const storedUnspentCollateralBoxIds =\n      await this.action.getUnspentCollateralBoxIds(this.getId());\n    const unspentCollateralBoxIds = new Set(\n      unspentCollaterals.map((box) => box.boxId)\n    );\n    await this.tidyUpStoredCollaterals(\n      initialHeight,\n      storedUnspentCollateralBoxIds.filter(\n        (boxId) => !unspentCollateralBoxIds.has(boxId)\n      )\n    );\n\n    for (const collateral of unspentCollaterals) {\n      this.logger.debug(\n        `saving unspent collateral with boxId=[${collateral.boxId}] to database for initialization`\n      );\n      await this.action.saveCollateral(collateral, this.getId());\n      this.logger.debug(\n        `saved unspent collateral with boxId=[${collateral.boxId}] to database for initialization`\n      );\n    }\n  };\n\n  /**\n   * removes or updates stored collateral boxes before initializing boxes\n   *\n   * @private\n   * @param {number} initialHeight\n   * @param {string[]} collateralBoxIds\n   * @return {Promise<void>}\n   * @memberof CollateralExtractor\n   */\n  private async tidyUpStoredCollaterals(\n    initialHeight: number,\n    collateralBoxIds: string[]\n  ) {\n    for (const boxId of collateralBoxIds) {\n      let boxInfo: OutputInfo;\n      try {\n        boxInfo = await this.explorerApi.v1.getApiV1BoxesP1(boxId);\n      } catch (e: any) {\n        if (e?.response?.status === 404) {\n          this.action.deleteCollateral(boxId, this.getId());\n        } else {\n          throw new Error(\n            `something went wrong when trying to get box=[${boxId}] from Ergo network: ${e?.message}`\n          );\n        }\n        return;\n      }\n\n      if (boxInfo?.spentTransactionId != null) {\n        try {\n          const transactionInfo: TransactionInfo =\n            await this.explorerApi.v1.getApiV1TransactionsP1(\n              boxInfo.spentTransactionId\n            );\n\n          if (transactionInfo.inclusionHeight < initialHeight) {\n            this.action.saveCollateral(\n              {\n                boxId: boxId,\n                spendHeight: transactionInfo.inclusionHeight,\n                spendBlock: transactionInfo.blockId,\n              },\n              this.getId()\n            );\n          }\n        } catch (e: any) {\n          throw new Error(\n            `something went wrong when trying to get transaction=[${boxInfo.spentTransactionId}] from Ergo network: ${e?.message}`\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * gets all unspent collaterals from Ergo explorer api\n   *\n   * @private\n   * @param {number} initialHeight\n   * @return {Promise<Array<ExtractedCollateral>>}\n   * @memberof CollateralExtractor\n   */\n  private getAllUnspentCollaterals = async (\n    initialHeight: number\n  ): Promise<Array<ExtractedCollateral>> => {\n    const extractedBoxes: Array<ExtractedCollateral> = [];\n    let offset = 0;\n    let total = 1;\n    while (offset < total) {\n      const boxes = await this.explorerApi.v1.getApiV1BoxesUnspentByergotreeP1(\n        this.ergoTree,\n        { offset: offset, limit: DefaultApiLimit }\n      );\n\n      if (!boxes.items) {\n        throw new Error('Explorer api output items should not be undefined.');\n      }\n\n      extractedBoxes.push(\n        ...boxes.items\n          .filter(\n            (box) =>\n              box.creationHeight &&\n              box.creationHeight < initialHeight &&\n              this.isCollateralBox(box)\n          )\n          .map((box) => this.toExtractedCollateral(box))\n      );\n      total = boxes.total;\n      offset += DefaultApiLimit;\n    }\n    return extractedBoxes;\n  };\n\n  /**\n   * converts output box information to an ExtractedCollateral object\n   *\n   * @private\n   * @param {(OutputInfo | OutputBox)} box\n   * @return {ExtractedCollateral}\n   * @memberof CollateralExtractor\n   */\n  private toExtractedCollateral = (\n    box: OutputInfo | OutputBox\n  ): ExtractedCollateral => {\n    const ergoOutputBox = ergoLib.ErgoBox.from_json(JsonBI.stringify(box));\n\n    let r4: Uint8Array | undefined;\n    try {\n      r4 = ergoOutputBox\n        .register_value(ergoLib.NonMandatoryRegisterId.R4)\n        ?.to_byte_array();\n    } catch (e) {\n      throw new Error(`collateral box with boxId=${box.boxId} skipped: ${e}`);\n    }\n    if (r4 == undefined) {\n      throw new Error(\n        `collateral box with boxId=${box.boxId} skipped, because of an invalid R4 register`\n      );\n    }\n    const wId = uint8ArrayToHex(r4);\n    this.logger.debug(\n      `Extracted WID=[${wId}] from R4 register of box=${ergoOutputBox\n        .box_id()\n        .to_str()}`\n    );\n\n    let r5: string | undefined;\n    try {\n      r5 = ergoOutputBox\n        .register_value(ergoLib.NonMandatoryRegisterId.R5)\n        ?.to_i64()\n        .to_str();\n    } catch (e) {\n      throw new Error(`collateral box with boxId=${box.boxId} skipped: ${e}`);\n    }\n    if (r5 == undefined) {\n      throw new Error(\n        `collateral box with boxId=${box.boxId} skipped, because of an invalid R5 register`\n      );\n    }\n    const rwtCount = BigInt(r5);\n    this.logger.debug(\n      `Extracted rwtCount=[${rwtCount}] from R5 register of box=${ergoOutputBox\n        .box_id()\n        .to_str()}`\n    );\n\n    return {\n      boxId: box.boxId,\n      boxSerialized: Buffer.from(\n        ergoOutputBox.sigma_serialize_bytes()\n      ).toString('base64'),\n      wId: wId,\n      rwtCount: rwtCount,\n      txId: box.transactionId,\n      height: Number(box.creationHeight),\n    };\n  };\n}\n"]}

package/dist/interfaces/extractedCollateral.d.ts

@@ -0,0 +1,12 @@
+export interface ExtractedCollateral {
+    boxId: string;
+    boxSerialized: string;
+    wId: string;
+    rwtCount: bigint;
+    txId: string;
+    block?: string;
+    height?: number;
+    spendBlock?: string;
+    spendHeight?: number;
+}
+//# sourceMappingURL=extractedCollateral.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractedCollateral.d.ts","sourceRoot":"","sources":["../../lib/interfaces/extractedCollateral.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/interfaces/extractedCollateral.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmFjdGVkQ29sbGF0ZXJhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9pbnRlcmZhY2VzL2V4dHJhY3RlZENvbGxhdGVyYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRXh0cmFjdGVkQ29sbGF0ZXJhbCB7XG4gIGJveElkOiBzdHJpbmc7XG4gIGJveFNlcmlhbGl6ZWQ6IHN0cmluZztcbiAgd0lkOiBzdHJpbmc7XG4gIHJ3dENvdW50OiBiaWdpbnQ7XG4gIHR4SWQ6IHN0cmluZztcbiAgYmxvY2s/OiBzdHJpbmc7XG4gIGhlaWdodD86IG51bWJlcjtcbiAgc3BlbmRCbG9jaz86IHN0cmluZztcbiAgc3BlbmRIZWlnaHQ/OiBudW1iZXI7XG59XG4iXX0=

package/dist/migrations/index.d.ts

@@ -1,7 +1,7 @@
-import { migration1688554842087 } from './postgres/1688554842087-migration';
+import { migration1706610773315 } from './postgres/1706610773315-migration';
 import { migration1706610773176 } from './sqlite/1706610773176-migration';
 export declare const migrations: {
     sqlite: (typeof migration1706610773176)[];
-    postgres: (typeof migration1688554842087)[];
+    postgres: (typeof migration1706610773315)[];
 };
 //# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"1708189757400-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/postgres/1708189757400-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;IAoB3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3D"}

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

@@ -0,0 +1,28 @@
+export class Migration1708189757400 {
+    name = 'Migration1708189757400';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "collateral_entity" (
+                "id" SERIAL NOT NULL,
+                "extractor" character varying NOT NULL,
+                "boxId" character varying NOT NULL,
+                "boxSerialized" character varying NOT NULL,
+                "wId" character varying NOT NULL,
+                "rwtCount" bigint NOT NULL,
+                "txId" character varying NOT NULL,
+                "block" character varying,
+                "height" integer,
+                "spendBlock" text,
+                "spendHeight" integer,
+                CONSTRAINT "UQ_2d4abc2071df9a2300a5e1b4616" UNIQUE ("boxId", "extractor"),
+                CONSTRAINT "PK_e8506252c52632f4741c8415c3f" PRIMARY KEY ("id")
+            )
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            DROP TABLE "collateral_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"1708175020320-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/sqlite/1708175020320-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;IAmB3C,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAK3D"}

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

@@ -0,0 +1,27 @@
+export class Migration1708175020320 {
+    name = 'Migration1708175020320';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "collateral_entity" (
+                "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+                "extractor" varchar NOT NULL,
+                "boxId" varchar NOT NULL,
+                "boxSerialized" varchar NOT NULL,
+                "wId" varchar NOT NULL,
+                "rwtCount" bigint NOT NULL,
+                "txId" varchar NOT NULL,
+                "block" varchar,
+                "height" integer,
+                "spendBlock" text,
+                "spendHeight" integer,
+                CONSTRAINT "UQ_2d4abc2071df9a2300a5e1b4616" UNIQUE ("boxId", "extractor")
+            )
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            DROP TABLE "collateral_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/transformers.d.ts

@@ -0,0 +1,17 @@
+export declare const bigintTransformer: {
+    /**
+     * converts data from string in database to bigint in code
+     *
+     * @param {string} value
+     * @return {bigint}
+     */
+    from(value: string): bigint;
+    /**
+     * converts data from bigint in code to string in database
+     *
+     * @param {bigint} value
+     * @return {string}
+     */
+    to(value: bigint): string;
+};
+//# sourceMappingURL=transformers.d.ts.map

package/dist/transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../lib/transformers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;IAC5B;;;;;OAKG;gBACS,MAAM;IAGlB;;;;;OAKG;cACO,MAAM;CAGjB,CAAC"}

package/dist/transformers.js

@@ -0,0 +1,21 @@
+export const bigintTransformer = {
+    /**
+     * converts data from string in database to bigint in code
+     *
+     * @param {string} value
+     * @return {bigint}
+     */
+    from(value) {
+        return BigInt(value);
+    },
+    /**
+     * converts data from bigint in code to string in database
+     *
+     * @param {bigint} value
+     * @return {string}
+     */
+    to(value) {
+        return value.toString();
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmb3JtZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL3RyYW5zZm9ybWVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRztJQUMvQjs7Ozs7T0FLRztJQUNILElBQUksQ0FBQyxLQUFhO1FBQ2hCLE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3ZCLENBQUM7SUFDRDs7Ozs7T0FLRztJQUNILEVBQUUsQ0FBQyxLQUFhO1FBQ2QsT0FBTyxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDMUIsQ0FBQztDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgYmlnaW50VHJhbnNmb3JtZXIgPSB7XG4gIC8qKlxuICAgKiBjb252ZXJ0cyBkYXRhIGZyb20gc3RyaW5nIGluIGRhdGFiYXNlIHRvIGJpZ2ludCBpbiBjb2RlXG4gICAqXG4gICAqIEBwYXJhbSB7c3RyaW5nfSB2YWx1ZVxuICAgKiBAcmV0dXJuIHtiaWdpbnR9XG4gICAqL1xuICBmcm9tKHZhbHVlOiBzdHJpbmcpIHtcbiAgICByZXR1cm4gQmlnSW50KHZhbHVlKTtcbiAgfSxcbiAgLyoqXG4gICAqIGNvbnZlcnRzIGRhdGEgZnJvbSBiaWdpbnQgaW4gY29kZSB0byBzdHJpbmcgaW4gZGF0YWJhc2VcbiAgICpcbiAgICogQHBhcmFtIHtiaWdpbnR9IHZhbHVlXG4gICAqIEByZXR1cm4ge3N0cmluZ31cbiAgICovXG4gIHRvKHZhbHVlOiBiaWdpbnQpIHtcbiAgICByZXR1cm4gdmFsdWUudG9TdHJpbmcoKTtcbiAgfSxcbn07XG4iXX0=

package/dist/utils.js

@@ -10,11 +10,11 @@ const JsonBI = JSONBigInt({
  */
 const getWidInfo = (WIDs) => {
     const WIDsArray = WIDs.split(',');
-    const hash = Buffer.from(blake2b(WIDsArray.join(''), undefined, 32)).toString('hex');
+    const hash = Buffer.from(blake2b(Buffer.from(WIDsArray.join(''), 'hex'), undefined, 32)).toString('hex');
     return {
         WIDsHash: hash,
         WIDsCount: WIDsArray.length,
     };
 };
 export { JsonBI, getWidInfo };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNsQyxPQUFPLFVBQVUsTUFBTSxhQUFhLENBQUM7QUFFckMsTUFBTSxNQUFNLEdBQUcsVUFBVSxDQUFDO0lBQ3hCLGVBQWUsRUFBRSxJQUFJO0NBQ3RCLENBQUMsQ0FBQztBQUVIOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsR0FBRyxDQUFDLElBQVksRUFBRSxFQUFFO0lBQ2xDLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxTQUFTLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQzNFLEtBQUssQ0FDTixDQUFDO0lBRUYsT0FBTztRQUNMLFFBQVEsRUFBRSxJQUFJO1FBQ2QsU0FBUyxFQUFFLFNBQVMsQ0FBQyxNQUFNO0tBQzVCLENBQUM7QUFDSixDQUFDLENBQUM7QUFFRixPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYmxha2UyYiB9IGZyb20gJ2JsYWtlanMnO1xuaW1wb3J0IEpTT05CaWdJbnQgZnJvbSAnanNvbi1iaWdpbnQnO1xuXG5jb25zdCBKc29uQkkgPSBKU09OQmlnSW50KHtcbiAgdXNlTmF0aXZlQmlnSW50OiB0cnVlLFxufSk7XG5cbi8qKlxuICogY2FsY3VsYXRlcyBoYXNoIG9mIFdJRHNcbiAqIEBwYXJhbSBXSURzXG4gKiBAcmV0dXJucyByZXR1cm5zIFdJRHNIYXNoIHdpdGggaXQncyBjb3VudFxuICovXG5jb25zdCBnZXRXaWRJbmZvID0gKFdJRHM6IHN0cmluZykgPT4ge1xuICBjb25zdCBXSURzQXJyYXkgPSBXSURzLnNwbGl0KCcsJyk7XG4gIGNvbnN0IGhhc2ggPSBCdWZmZXIuZnJvbShibGFrZTJiKFdJRHNBcnJheS5qb2luKCcnKSwgdW5kZWZpbmVkLCAzMikpLnRvU3RyaW5nKFxuICAgICdoZXgnXG4gICk7XG5cbiAgcmV0dXJuIHtcbiAgICBXSURzSGFzaDogaGFzaCxcbiAgICBXSURzQ291bnQ6IFdJRHNBcnJheS5sZW5ndGgsXG4gIH07XG59O1xuXG5leHBvcnQgeyBKc29uQkksIGdldFdpZEluZm8gfTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNsQyxPQUFPLFVBQVUsTUFBTSxhQUFhLENBQUM7QUFFckMsTUFBTSxNQUFNLEdBQUcsVUFBVSxDQUFDO0lBQ3hCLGVBQWUsRUFBRSxJQUFJO0NBQ3RCLENBQUMsQ0FBQztBQUVIOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsR0FBRyxDQUFDLElBQVksRUFBRSxFQUFFO0lBQ2xDLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FDdEIsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsRUFBRSxDQUFDLENBQy9ELENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBRWxCLE9BQU87UUFDTCxRQUFRLEVBQUUsSUFBSTtRQUNkLFNBQVMsRUFBRSxTQUFTLENBQUMsTUFBTTtLQUM1QixDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBRUYsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGJsYWtlMmIgfSBmcm9tICdibGFrZWpzJztcbmltcG9ydCBKU09OQmlnSW50IGZyb20gJ2pzb24tYmlnaW50JztcblxuY29uc3QgSnNvbkJJID0gSlNPTkJpZ0ludCh7XG4gIHVzZU5hdGl2ZUJpZ0ludDogdHJ1ZSxcbn0pO1xuXG4vKipcbiAqIGNhbGN1bGF0ZXMgaGFzaCBvZiBXSURzXG4gKiBAcGFyYW0gV0lEc1xuICogQHJldHVybnMgcmV0dXJucyBXSURzSGFzaCB3aXRoIGl0J3MgY291bnRcbiAqL1xuY29uc3QgZ2V0V2lkSW5mbyA9IChXSURzOiBzdHJpbmcpID0+IHtcbiAgY29uc3QgV0lEc0FycmF5ID0gV0lEcy5zcGxpdCgnLCcpO1xuICBjb25zdCBoYXNoID0gQnVmZmVyLmZyb20oXG4gICAgYmxha2UyYihCdWZmZXIuZnJvbShXSURzQXJyYXkuam9pbignJyksICdoZXgnKSwgdW5kZWZpbmVkLCAzMilcbiAgKS50b1N0cmluZygnaGV4Jyk7XG5cbiAgcmV0dXJuIHtcbiAgICBXSURzSGFzaDogaGFzaCxcbiAgICBXSURzQ291bnQ6IFdJRHNBcnJheS5sZW5ndGgsXG4gIH07XG59O1xuXG5leHBvcnQgeyBKc29uQkksIGdldFdpZEluZm8gfTtcbiJdfQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/watcher-data-extractor",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Extractor for rosen specific boxes on ergo blockchain",
   "author": "Rosen Team",
   "license": "GPL-3.0",