@rosen-bridge/fraud-extractor 0.1.1

package/README.md

@@ -0,0 +1,39 @@
+# Fraud Extractor
+
+### Table of Contents
+
+- [Description](#description)
+- [Related Projects](#related-projects)
+- [How to Use the Fraud Extractor](#how-to-use-the-fraud-extractor)
+  - [Install](#install)
+  - [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+
+<a name="headers"/>
+
+## Description
+
+Data extractors are modules that are integrated within a scanner. They drive the required information from the scanned blocks and store them in their own database. Fraud extractor, extracts fraud boxes information from blocks and stores them in the database. Cleanup service creates frauds from timed out unspent triggers; these triggers might have incorrect data or be a duplicated version of a valid trigger. Then the fraud funds will be seized by the service to punish the faulty reports.
+
+## Related Projects
+
+TBD
+
+## How to Use the Fraud Extractor
+
+### Install
+
+TBD
+
+### Usage
+
+TBD
+
+## Contributing
+
+TBD
+
+## License
+
+TBD

package/dist/actions/fraudAction.d.ts

@@ -0,0 +1,64 @@
+import { DataSource } from 'typeorm';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockEntity } from '@rosen-bridge/scanner';
+import { ExtractedFraud } from '../interfaces/types';
+export declare class FraudAction {
+    private readonly datasource;
+    private readonly logger;
+    private readonly repository;
+    constructor(dataSource: DataSource, logger: AbstractLogger);
+    /**
+     * Store a list of frauds in a specific block
+     * @param frauds
+     * @param spendBoxes
+     * @param block
+     * @param extractor
+     */
+    storeBlockFrauds: (frauds: Array<ExtractedFraud>, block: BlockEntity, extractor: string) => Promise<boolean>;
+    /**
+     * Insert a new fraud into database
+     * @param fraud
+     * @param extractor
+     */
+    insertFraud: (fraud: ExtractedFraud, extractor: string) => Promise<import("typeorm").InsertResult>;
+    /**
+     * Update an unspent fraud information in the database
+     * @param fraud
+     * @param extractor
+     */
+    updateFraud: (fraud: ExtractedFraud, extractor: string) => Promise<import("typeorm").UpdateResult>;
+    /**
+     * Update spendBlock and spendHeight of frauds spent on the block
+     * @param spendIds
+     * @param block
+     * @param extractor
+     */
+    spendFrauds: (spendIds: Array<string>, block: BlockEntity, extractor: string, txId: string) => Promise<void>;
+    /**
+     * Update all frauds related to an specific invalid block
+     * if box had been spent in the block mark it as unspent,
+     * and if it was created within the block remove it from database
+     * @param block
+     * @param extractor
+     */
+    deleteBlock: (block: string, extractor: string) => Promise<void>;
+    /**
+     * Return all stored fraud box ids
+     */
+    getAllBoxIds: (extractor: string) => Promise<Array<string>>;
+    /**
+     * Remove an specified fraud
+     * @param boxId
+     * @param extractor
+     */
+    removeFraud: (boxId: string, extractor: string) => Promise<import("typeorm").DeleteResult>;
+    /**
+     * Update the fraud spending information
+     * @param boxId
+     * @param extractor
+     * @param blockId
+     * @param blockHeight
+     */
+    updateSpendBlock: (boxId: string, extractor: string, blockId: string, blockHeight: number) => Promise<import("typeorm").UpdateResult>;
+}
+//# sourceMappingURL=fraudAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fraudAction.d.ts","sourceRoot":"","sources":["../../lib/actions/fraudAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,SAAS,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIrD,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;gBAEzC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc;IAK1D;;;;;;OAMG;IACH,gBAAgB,WACN,MAAM,cAAc,CAAC,SACtB,WAAW,aACP,MAAM,sBAgDjB;IAEF;;;;OAIG;IACH,WAAW,UAAiB,cAAc,aAAa,MAAM,6CAY3D;IAEF;;;;OAIG;IACH,WAAW,UAAiB,cAAc,aAAa,MAAM,6CAe3D;IAEF;;;;;OAKG;IACH,WAAW,aACC,MAAM,MAAM,CAAC,SAChB,WAAW,aACP,MAAM,QACX,MAAM,KACX,QAAQ,IAAI,CAAC,CAqBd;IAEF;;;;;;OAMG;IACH,WAAW,UAAiB,MAAM,aAAa,MAAM,KAAG,QAAQ,IAAI,CAAC,CAgCnE;IAEF;;OAEG;IACH,YAAY,cAAqB,MAAM,KAAG,QAAQ,MAAM,MAAM,CAAC,CAAC,CAU9D;IAEF;;;;OAIG;IACH,WAAW,UAAiB,MAAM,aAAa,MAAM,6CAEnD;IAEF;;;;;;OAMG;IACH,gBAAgB,UACP,MAAM,aACF,MAAM,WACR,MAAM,eACF,MAAM,6CAMnB;CACH"}

package/dist/actions/fraudAction.js

@@ -0,0 +1,196 @@
+import { In } from 'typeorm';
+import { FraudEntity } from '../entities/fraudEntity';
+import { dbIdChunkSize } from '../constants';
+import { chunk } from 'lodash-es';
+export class FraudAction {
+    datasource;
+    logger;
+    repository;
+    constructor(dataSource, logger) {
+        this.datasource = dataSource;
+        this.logger = logger;
+        this.repository = dataSource.getRepository(FraudEntity);
+    }
+    /**
+     * Store a list of frauds in a specific block
+     * @param frauds
+     * @param spendBoxes
+     * @param block
+     * @param extractor
+     */
+    storeBlockFrauds = async (frauds, block, extractor) => {
+        const boxIds = frauds.map((item) => item.boxId);
+        const dbBoxes = await this.repository.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(FraudEntity);
+        try {
+            for (const fraud of frauds) {
+                const entity = {
+                    triggerBoxId: fraud.triggerBoxId,
+                    boxId: fraud.boxId,
+                    wid: fraud.wid,
+                    rwtCount: fraud.rwtCount,
+                    creationBlock: block.hash,
+                    creationHeight: block.height,
+                    creationTxId: fraud.txId,
+                    serialized: fraud.serialized,
+                    extractor: extractor,
+                    spendBlock: undefined,
+                    spendHeight: undefined,
+                    spendTxId: undefined,
+                };
+                const dbBox = dbBoxes.filter((item) => item.boxId === fraud.boxId);
+                if (dbBox.length > 0) {
+                    this.logger.info(`Updating fraud with boxId [${fraud.boxId}]`);
+                    this.logger.debug(`Updated fraud: [${JSON.stringify(entity)}]`);
+                    await repository.update({ id: dbBox[0].id }, entity);
+                }
+                else {
+                    this.logger.info(`Storing fraud with boxId: [${fraud.boxId}]`);
+                    this.logger.debug(`Inserted fraud: [${JSON.stringify(entity)}]`);
+                    await repository.insert(entity);
+                }
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during storing fraud boxes: ${e}`);
+            await queryRunner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return success;
+    };
+    /**
+     * Insert a new fraud into database
+     * @param fraud
+     * @param extractor
+     */
+    insertFraud = async (fraud, extractor) => {
+        return this.repository.insert({
+            boxId: fraud.boxId,
+            triggerBoxId: fraud.triggerBoxId,
+            wid: fraud.wid,
+            rwtCount: fraud.rwtCount,
+            creationBlock: fraud.blockId,
+            creationHeight: fraud.height,
+            creationTxId: fraud.txId,
+            serialized: fraud.serialized,
+            extractor: extractor,
+        });
+    };
+    /**
+     * Update an unspent fraud information in the database
+     * @param fraud
+     * @param extractor
+     */
+    updateFraud = async (fraud, extractor) => {
+        return this.repository.update({ boxId: fraud.boxId, extractor: extractor }, {
+            triggerBoxId: fraud.triggerBoxId,
+            creationBlock: fraud.blockId,
+            creationHeight: fraud.height,
+            creationTxId: fraud.txId,
+            serialized: fraud.serialized,
+            wid: fraud.wid,
+            rwtCount: fraud.rwtCount,
+            spendBlock: null,
+            spendHeight: 0,
+        });
+    };
+    /**
+     * Update spendBlock and spendHeight of frauds spent on the block
+     * @param spendIds
+     * @param block
+     * @param extractor
+     */
+    spendFrauds = async (spendIds, block, extractor, txId) => {
+        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, spendTxId: txId });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const spentRows = await this.repository.findBy({
+                    boxId: In(spendIdChunk),
+                    spendBlock: block.hash,
+                    spendTxId: txId,
+                });
+                for (const row of spentRows) {
+                    this.logger.debug(`Spent box with boxId [${row.boxId}] at transaction [${txId}] at height ${block.height}`);
+                }
+            }
+        }
+    };
+    /**
+     * Update all frauds related to an specific invalid block
+     * if box had been spent in the block mark it as unspent,
+     * and if it was created within the block remove it from database
+     * @param block
+     * @param extractor
+     */
+    deleteBlock = async (block, extractor) => {
+        this.logger.info(`Deleting frauds in block [${block}]`);
+        const invalidRows = await this.repository.findBy({
+            extractor: extractor,
+            creationBlock: block,
+        });
+        if (invalidRows.length > 0) {
+            await this.repository.delete({
+                extractor: extractor,
+                creationBlock: block,
+            });
+            for (const row of invalidRows) {
+                this.logger.debug(`deleted invalid fraud with boxId [${row.boxId}] at the forked block [${block}]`);
+            }
+        }
+        const updatingRows = await this.repository.findBy({
+            extractor: extractor,
+            spendBlock: block,
+        });
+        if (updatingRows.length > 0) {
+            await this.repository.update({ spendBlock: block, extractor: extractor }, { spendBlock: null, spendHeight: 0, spendTxId: null });
+            for (const row of updatingRows) {
+                this.logger.debug(`removed spending information of the fraud with boxId [${row.boxId}], spent at the forked block [${block}]`);
+            }
+        }
+    };
+    /**
+     * Return all stored fraud box ids
+     */
+    getAllBoxIds = async (extractor) => {
+        const boxIds = await this.repository.find({
+            select: {
+                boxId: true,
+            },
+            where: {
+                extractor: extractor,
+            },
+        });
+        return boxIds.map((item) => item.boxId);
+    };
+    /**
+     * Remove an specified fraud
+     * @param boxId
+     * @param extractor
+     */
+    removeFraud = async (boxId, extractor) => {
+        return await this.repository.delete({ boxId: boxId, extractor: extractor });
+    };
+    /**
+     * Update the fraud 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":"fraudAction.js","sourceRoot":"","sources":["../../lib/actions/fraudAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, In, Repository } from 'typeorm';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { BlockEntity } from '@rosen-bridge/scanner';\n\nimport { FraudEntity } from '../entities/fraudEntity';\nimport { ExtractedFraud } from '../interfaces/types';\nimport { dbIdChunkSize } from '../constants';\nimport { chunk } from 'lodash-es';\n\nexport class FraudAction {\n  private readonly datasource: DataSource;\n  private readonly logger: AbstractLogger;\n  private readonly repository: Repository<FraudEntity>;\n\n  constructor(dataSource: DataSource, logger: AbstractLogger) {\n    this.datasource = dataSource;\n    this.logger = logger;\n    this.repository = dataSource.getRepository(FraudEntity);\n  }\n  /**\n   * Store a list of frauds in a specific block\n   * @param frauds\n   * @param spendBoxes\n   * @param block\n   * @param extractor\n   */\n  storeBlockFrauds = async (\n    frauds: Array<ExtractedFraud>,\n    block: BlockEntity,\n    extractor: string\n  ) => {\n    const boxIds = frauds.map((item) => item.boxId);\n    const dbBoxes = await this.repository.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(FraudEntity);\n    try {\n      for (const fraud of frauds) {\n        const entity = {\n          triggerBoxId: fraud.triggerBoxId,\n          boxId: fraud.boxId,\n          wid: fraud.wid,\n          rwtCount: fraud.rwtCount,\n          creationBlock: block.hash,\n          creationHeight: block.height,\n          creationTxId: fraud.txId,\n          serialized: fraud.serialized,\n          extractor: extractor,\n          spendBlock: undefined,\n          spendHeight: undefined,\n          spendTxId: undefined,\n        };\n        const dbBox = dbBoxes.filter((item) => item.boxId === fraud.boxId);\n        if (dbBox.length > 0) {\n          this.logger.info(`Updating fraud with boxId [${fraud.boxId}]`);\n          this.logger.debug(`Updated fraud: [${JSON.stringify(entity)}]`);\n          await repository.update({ id: dbBox[0].id }, entity);\n        } else {\n          this.logger.info(`Storing fraud with boxId: [${fraud.boxId}]`);\n          this.logger.debug(`Inserted fraud: [${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 storing fraud boxes: ${e}`);\n      await queryRunner.rollbackTransaction();\n      success = false;\n    } finally {\n      await queryRunner.release();\n    }\n    return success;\n  };\n\n  /**\n   * Insert a new fraud into database\n   * @param fraud\n   * @param extractor\n   */\n  insertFraud = async (fraud: ExtractedFraud, extractor: string) => {\n    return this.repository.insert({\n      boxId: fraud.boxId,\n      triggerBoxId: fraud.triggerBoxId,\n      wid: fraud.wid,\n      rwtCount: fraud.rwtCount,\n      creationBlock: fraud.blockId,\n      creationHeight: fraud.height,\n      creationTxId: fraud.txId,\n      serialized: fraud.serialized,\n      extractor: extractor,\n    });\n  };\n\n  /**\n   * Update an unspent fraud information in the database\n   * @param fraud\n   * @param extractor\n   */\n  updateFraud = async (fraud: ExtractedFraud, extractor: string) => {\n    return this.repository.update(\n      { boxId: fraud.boxId, extractor: extractor },\n      {\n        triggerBoxId: fraud.triggerBoxId,\n        creationBlock: fraud.blockId,\n        creationHeight: fraud.height,\n        creationTxId: fraud.txId,\n        serialized: fraud.serialized,\n        wid: fraud.wid,\n        rwtCount: fraud.rwtCount,\n        spendBlock: null,\n        spendHeight: 0,\n      }\n    );\n  };\n\n  /**\n   * Update spendBlock and spendHeight of frauds spent on the block\n   * @param spendIds\n   * @param block\n   * @param extractor\n   */\n  spendFrauds = async (\n    spendIds: Array<string>,\n    block: BlockEntity,\n    extractor: string,\n    txId: 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, spendTxId: txId }\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          spendTxId: txId,\n        });\n        for (const row of spentRows) {\n          this.logger.debug(\n            `Spent box with boxId [${row.boxId}] at transaction [${txId}] at height ${block.height}`\n          );\n        }\n      }\n    }\n  };\n\n  /**\n   * Update all frauds related to an specific invalid block\n   * if box had been spent in the block mark it as unspent,\n   * and if it was created within the block remove it from database\n   * @param block\n   * @param extractor\n   */\n  deleteBlock = async (block: string, extractor: string): Promise<void> => {\n    this.logger.info(`Deleting frauds in block [${block}]`);\n    const invalidRows = await this.repository.findBy({\n      extractor: extractor,\n      creationBlock: block,\n    });\n    if (invalidRows.length > 0) {\n      await this.repository.delete({\n        extractor: extractor,\n        creationBlock: block,\n      });\n      for (const row of invalidRows) {\n        this.logger.debug(\n          `deleted invalid fraud with boxId [${row.boxId}] at the forked block [${block}]`\n        );\n      }\n    }\n    const updatingRows = await this.repository.findBy({\n      extractor: extractor,\n      spendBlock: block,\n    });\n    if (updatingRows.length > 0) {\n      await this.repository.update(\n        { spendBlock: block, extractor: extractor },\n        { spendBlock: null, spendHeight: 0, spendTxId: null }\n      );\n      for (const row of updatingRows) {\n        this.logger.debug(\n          `removed spending information of the fraud with boxId [${row.boxId}], spent at the forked block [${block}]`\n        );\n      }\n    }\n  };\n\n  /**\n   * Return all stored fraud 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   * Remove an specified fraud\n   * @param boxId\n   * @param extractor\n   */\n  removeFraud = async (boxId: string, extractor: string) => {\n    return await this.repository.delete({ boxId: boxId, extractor: extractor });\n  };\n\n  /**\n   * Update the fraud 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/fraudEntity.d.ts

@@ -0,0 +1,16 @@
+export declare class FraudEntity {
+    id: number;
+    boxId: string;
+    creationBlock: string;
+    creationHeight: number;
+    creationTxId: string;
+    serialized: string;
+    triggerBoxId: string;
+    wid: string;
+    rwtCount: string;
+    spendBlock?: string | null;
+    spendHeight?: number;
+    spendTxId?: string | null;
+    extractor: string;
+}
+//# sourceMappingURL=fraudEntity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fraudEntity.d.ts","sourceRoot":"","sources":["../../lib/entities/fraudEntity.ts"],"names":[],"mappings":"AAEA,qBACa,WAAW;IAEtB,EAAE,EAAE,MAAM,CAAC;IAGX,KAAK,EAAE,MAAM,CAAC;IAGd,aAAa,EAAE,MAAM,CAAC;IAGtB,cAAc,EAAE,MAAM,CAAC;IAGvB,YAAY,EAAE,MAAM,CAAC;IAGrB,UAAU,EAAE,MAAM,CAAC;IAGnB,YAAY,EAAE,MAAM,CAAC;IAGrB,GAAG,EAAE,MAAM,CAAC;IAGZ,QAAQ,EAAE,MAAM,CAAC;IAGjB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG3B,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG1B,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/entities/fraudEntity.js

@@ -0,0 +1,82 @@
+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 FraudEntity = class FraudEntity {
+    id;
+    boxId;
+    creationBlock;
+    creationHeight;
+    creationTxId;
+    serialized;
+    triggerBoxId;
+    wid;
+    rwtCount;
+    spendBlock;
+    spendHeight;
+    spendTxId;
+    extractor;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], FraudEntity.prototype, "id", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "boxId", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "creationBlock", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", Number)
+], FraudEntity.prototype, "creationHeight", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "creationTxId", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "serialized", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "triggerBoxId", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "wid", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "rwtCount", void 0);
+__decorate([
+    Column({ nullable: true, type: 'text' }),
+    __metadata("design:type", Object)
+], FraudEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true }),
+    __metadata("design:type", Number)
+], FraudEntity.prototype, "spendHeight", void 0);
+__decorate([
+    Column({ nullable: true, type: 'text' }),
+    __metadata("design:type", Object)
+], FraudEntity.prototype, "spendTxId", void 0);
+__decorate([
+    Column(),
+    __metadata("design:type", String)
+], FraudEntity.prototype, "extractor", void 0);
+FraudEntity = __decorate([
+    Entity()
+], FraudEntity);
+export { FraudEntity };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/extractor/fraudExtractor.d.ts

@@ -0,0 +1,144 @@
+import { DataSource } from 'typeorm';
+import { AbstractExtractor } from '@rosen-bridge/scanner';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockEntity, Transaction } from '@rosen-bridge/scanner';
+import { V1 } from '@rosen-clients/ergo-explorer';
+import { ExtractedFraud } from '../interfaces/types';
+export declare class FraudExtractor implements AbstractExtractor<Transaction> {
+    private readonly logger;
+    private readonly actions;
+    private readonly id;
+    private readonly ergoTree;
+    private readonly rwt;
+    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<V1.TransactionInfo>;
+            getApiV1TransactionsByinputsscripttemplatehashP1: (p1: string, params?: V1.GetApiV1TransactionsByinputsscripttemplatehashP1Params | undefined) => Promise<V1.ItemsTransactionInfo>;
+            getApiV1TransactionsByglobalindexStream: (params: V1.GetApiV1TransactionsByglobalindexStreamParams) => Promise<V1.ListTransactionInfo>;
+            getApiV1BoxesUnspentBylastepochsStream: (params: V1.GetApiV1BoxesUnspentBylastepochsStreamParams) => Promise<V1.ListOutputInfo>;
+            getApiV1BoxesUnspentByglobalindexStream: (params: V1.GetApiV1BoxesUnspentByglobalindexStreamParams) => Promise<V1.ListOutputInfo>;
+            getApiV1BoxesUnspentStream: (params: V1.GetApiV1BoxesUnspentStreamParams) => Promise<V1.ListOutputInfo>;
+            getApiV1BoxesByergotreetemplatehashP1Stream: (p1: string, params: V1.GetApiV1BoxesByergotreetemplatehashP1StreamParams) => Promise<V1.ListOutputInfo>;
+            getApiV1BoxesUnspentByergotreetemplatehashP1Stream: (p1: string, params: V1.GetApiV1BoxesUnspentByergotreetemplatehashP1StreamParams) => Promise<V1.ListOutputInfo>;
+            getApiV1BoxesUnspentBytokenidP1: (p1: string, params?: V1.GetApiV1BoxesUnspentBytokenidP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesBytokenidP1: (p1: string, params?: V1.GetApiV1BoxesBytokenidP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesP1: (p1: string) => Promise<V1.OutputInfo>;
+            getApiV1BoxesByergotreeP1: (p1: string, params?: V1.GetApiV1BoxesByergotreeP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesByergotreetemplatehashP1: (p1: string, params?: V1.GetApiV1BoxesByergotreetemplatehashP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesUnspentByergotreeP1: (p1: string, params?: V1.GetApiV1BoxesUnspentByergotreeP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesUnspentByergotreetemplatehashP1: (p1: string, params?: V1.GetApiV1BoxesUnspentByergotreetemplatehashP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesByaddressP1: (p1: string, params?: V1.GetApiV1BoxesByaddressP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesUnspentByaddressP1: (p1: string, params?: V1.GetApiV1BoxesUnspentByaddressP1Params | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1BoxesByglobalindexStream: (params: V1.GetApiV1BoxesByglobalindexStreamParams) => Promise<V1.ListOutputInfo>;
+            postApiV1BoxesUnspentSearchUnion: (boxAssetsQuery: V1.BoxAssetsQuery, params?: V1.PostApiV1BoxesUnspentSearchUnionParams | undefined) => Promise<V1.ItemsOutputInfo>;
+            postApiV1BoxesUnspentSearch: (boxQuery: V1.BoxQuery, params?: V1.PostApiV1BoxesUnspentSearchParams | undefined) => Promise<V1.ItemsOutputInfo>;
+            postApiV1BoxesSearch: (boxQuery: V1.BoxQuery, params?: V1.PostApiV1BoxesSearchParams | undefined) => Promise<V1.ItemsOutputInfo>;
+            getApiV1Tokens: (params?: V1.GetApiV1TokensParams | undefined) => Promise<V1.ItemsTokenInfo>;
+            getApiV1TokensSearch: (params: V1.GetApiV1TokensSearchParams) => Promise<V1.ItemsTokenInfo>;
+            getApiV1TokensBysymbolP1: (p1: string) => Promise<V1.TokenInfo[]>;
+            getApiV1TokensP1: (p1: string) => Promise<V1.TokenInfo>;
+            getApiV1Assets: (params?: V1.GetApiV1AssetsParams | undefined) => Promise<V1.ItemsTokenInfo>;
+            getApiV1AssetsSearchBytokenid: (params: V1.GetApiV1AssetsSearchBytokenidParams) => Promise<V1.ItemsAssetInfo>;
+            getApiV1EpochsParams: () => Promise<V1.EpochInfo>;
+            getApiV1AddressesP1Transactions: (p1: string, params?: V1.GetApiV1AddressesP1TransactionsParams | undefined) => Promise<V1.ItemsTransactionInfo>;
+            getApiV1AddressesP1BalanceConfirmed: (p1: string, params?: V1.GetApiV1AddressesP1BalanceConfirmedParams | undefined) => Promise<V1.Balance>;
+            getApiV1AddressesP1BalanceTotal: (p1: string) => Promise<V1.TotalBalance>;
+            getApiV1Blocks: (params?: V1.GetApiV1BlocksParams | undefined) => Promise<V1.ItemsBlockInfo>;
+            getApiV1BlocksP1: (p1: string) => Promise<V1.BlockSummary>;
+            getApiV1BlocksHeaders: (params?: V1.GetApiV1BlocksHeadersParams | undefined) => Promise<V1.ItemsBlockHeader>;
+            getApiV1BlocksByglobalindexStream: (params: V1.GetApiV1BlocksByglobalindexStreamParams) => Promise<V1.ListBlockInfo>;
+            getApiV1BlocksStreamSummary: (params?: V1.GetApiV1BlocksStreamSummaryParams | undefined) => Promise<V1.ListBlockSummaryV1>;
+            postApiV1MempoolTransactionsSubmit: (postApiV1MempoolTransactionsSubmitBody: V1.PostApiV1MempoolTransactionsSubmitBody) => Promise<V1.TxIdResponse>;
+            getApiV1MempoolTransactionsByaddressP1: (p1: string, params?: V1.GetApiV1MempoolTransactionsByaddressP1Params | undefined) => Promise<V1.ItemsUTransactionInfo>;
+            getApiV1MempoolBoxesUnspent: () => Promise<V1.ListOutputInfo>;
+            getApiV1Info: () => Promise<V1.NetworkState>;
+            getApiV1Networkstate: () => Promise<V1.NetworkState>;
+            getApiV1Networkstats: () => Promise<V1.NetworkStats>;
+        };
+    };
+    constructor(dataSource: DataSource, id: string, explorerUrl: string, fraudAddress: string, rwt: string, logger?: AbstractLogger);
+    /**
+     * get Id for current extractor
+     */
+    getId: () => string;
+    /**
+     * Extract fraud boxes in the specified block transactions
+     * @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 frauds
+     */
+    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
+     */
+    validateOldStoredFrauds: (unchangedStoredBoxIds: Array<string>, initialHeight: number) => Promise<void>;
+    /**
+     * Return extracted information of a fraud with its boxId
+     * @param boxId
+     */
+    getFraudInfoWithBoxId: (boxId: string) => Promise<ExtractedFraud | undefined>;
+    /**
+     * Get unspent frauds created bellow the initial height
+     * @param initialHeight
+     * @returns
+     */
+    getUnspentFrauds: (initialHeight: number) => Promise<Array<ExtractedFraud>>;
+    /**
+     * Returns block information of tx
+     * @param txId
+     */
+    getTxBlock: (txId: string) => Promise<{
+        id: string;
+        height: number;
+    }>;
+    /**
+     * Returns trigger boxId from fraud transaction id
+     * @param txId
+     */
+    getTriggerBoxId: (txId: string) => Promise<string | undefined>;
+    /**
+     * Extract needed information for storing in database from api json outputs
+     * @param boxes
+     */
+    extractBoxData: (boxes: Array<V1.OutputInfo>) => Promise<ExtractedFraud[]>;
+}
+//# sourceMappingURL=fraudExtractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fraudExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/fraudExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,EAAE,EAAE,EAAE,MAAM,8BAA8B,CAAC;AAKlD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,qBAAa,cAAe,YAAW,iBAAiB,CAAC,WAAW,CAAC;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,QAAQ,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAC;gBAGX,UAAU,EAAE,UAAU,EACtB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,cAAc;IAYzB;;OAEG;IACH,KAAK,eAAsB;IAE3B;;;;OAIG;IACH,mBAAmB,QACZ,MAAM,WAAW,CAAC,SAChB,WAAW,KACjB,QAAQ,OAAO,CAAC,CA2EjB;IAEF;;;OAGG;IACH,SAAS,SAAgB,MAAM,KAAG,QAAQ,IAAI,CAAC,CAE7C;IAEF;;OAEG;IACH,eAAe,kBAAyB,MAAM,mBAkC5C;IAEF;;;;;OAKG;IACH,uBAAuB,0BACE,MAAM,MAAM,CAAC,iBACrB,MAAM,mBA2BrB;IAEF;;;OAGG;IACH,qBAAqB,UACZ,MAAM,KACZ,QAAQ,cAAc,GAAG,SAAS,CAAC,CAQpC;IAEF;;;;OAIG;IACH,gBAAgB,kBACC,MAAM,KACpB,QAAQ,MAAM,cAAc,CAAC,CAAC,CA+B/B;IAEF;;;OAGG;IACH,UAAU,SAAgB,MAAM;;;OAM9B;IAEF;;;OAGG;IACH,eAAe,SAAgB,MAAM,iCAGnC;IAEF;;;OAGG;IACH,cAAc,UAAiB,MAAM,GAAG,UAAU,CAAC,+BAoDjD;CACH"}

package/dist/extractor/fraudExtractor.js

@@ -0,0 +1,262 @@
+import * as wasm from 'ergo-lib-wasm-nodejs';
+import { Buffer } from 'buffer';
+import { difference } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+import JsonBI from '@rosen-bridge/json-bigint';
+import { FraudAction } from '../actions/fraudAction';
+import { DefaultApiLimit } from '../constants';
+export class FraudExtractor {
+    logger;
+    actions;
+    id;
+    ergoTree;
+    rwt;
+    api;
+    constructor(dataSource, id, explorerUrl, fraudAddress, rwt, logger) {
+        this.id = id;
+        this.ergoTree = wasm.Address.from_base58(fraudAddress)
+            .to_ergo_tree()
+            .to_base16_bytes();
+        this.rwt = rwt;
+        this.logger = logger ? logger : new DummyLogger();
+        this.actions = new FraudAction(dataSource, this.logger);
+        this.api = ergoExplorerClientFactory(explorerUrl);
+    }
+    /**
+     * get Id for current extractor
+     */
+    getId = () => `${this.id}`;
+    /**
+     * Extract fraud boxes in the specified block transactions
+     * @param txs
+     * @param block
+     */
+    processTransactions = (txs, block) => {
+        return new Promise((resolve, reject) => {
+            try {
+                const newFrauds = [];
+                const txSpendIds = [];
+                txs.forEach((transaction) => {
+                    for (const output of transaction.outputs) {
+                        if (output.ergoTree !== this.ergoTree ||
+                            !output.assets ||
+                            output.assets[0].tokenId !== this.rwt) {
+                            continue;
+                        }
+                        const boxOutput = wasm.ErgoBox.from_json(JsonBI.stringify(output));
+                        const r4 = boxOutput
+                            .register_value(wasm.NonMandatoryRegisterId.R4)
+                            ?.to_coll_coll_byte();
+                        if (!r4) {
+                            this.logger.debug(`A new fraud box found without correct wid format at height ${block.height}`);
+                            continue;
+                        }
+                        const newFraud = {
+                            boxId: output.boxId,
+                            txId: transaction.id,
+                            triggerBoxId: transaction.inputs[0].boxId,
+                            wid: Buffer.from(r4[0]).toString('hex'),
+                            rwtCount: output.assets[0].amount.toString(),
+                            serialized: Buffer.from(wasm.ErgoBox.from_json(JsonBI.stringify(output)).sigma_serialize_bytes()).toString('base64'),
+                        };
+                        newFrauds.push(newFraud);
+                        this.logger.debug(`new fraud found [${newFraud}] at height ${block.height}`);
+                    }
+                    txSpendIds.push({
+                        txId: transaction.id,
+                        spendBoxes: transaction.inputs.map((box) => box.boxId),
+                    });
+                });
+                this.actions
+                    .storeBlockFrauds(newFrauds, block, this.getId())
+                    .then(async (status) => {
+                    if (status) {
+                        if (newFrauds.length > 0)
+                            this.logger.debug(`successfully stored new frauds at hight ${block.height}`);
+                        for (const spendIds of txSpendIds)
+                            await this.actions.spendFrauds(spendIds.spendBoxes, block, this.getId(), spendIds.txId);
+                    }
+                    resolve(status);
+                })
+                    .catch((e) => {
+                    this.logger.error(`An error occurred in processing frauds in block [${block.hash}]: ${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.deleteBlock(hash, this.getId());
+    };
+    /**
+     * Initializes the database with older frauds
+     */
+    initializeBoxes = async (initialHeight) => {
+        // Getting unspent boxes
+        this.logger.debug(`Initializing fraud table. storing fraud boxes created bellow height ${initialHeight}.`);
+        const unspentFrauds = await this.getUnspentFrauds(initialHeight);
+        const unspentBoxIds = unspentFrauds.map((box) => box.boxId);
+        this.logger.debug(`Unspent fraud boxIds ${unspentBoxIds}`);
+        // Storing extracted boxes
+        let allStoredBoxIds = await this.actions.getAllBoxIds(this.getId());
+        for (const fraud of unspentFrauds) {
+            if (allStoredBoxIds.includes(fraud.boxId)) {
+                await this.actions.updateFraud(fraud, this.getId());
+                this.logger.info(`Updated the existing unspent fraud with boxId, [${fraud.boxId}]`);
+                this.logger.debug(`Updated fraud: [${JSON.stringify(fraud)}]`);
+            }
+            else {
+                await this.actions.insertFraud(fraud, this.getId());
+                this.logger.info(`Inserted new unspent fraud with boxId, [${fraud.boxId}]`);
+                this.logger.debug(`Inserted fraud: [${JSON.stringify(fraud)}]`);
+            }
+        }
+        // Remove updated box ids from existing boxes in database
+        allStoredBoxIds = difference(allStoredBoxIds, unspentBoxIds);
+        // Validating remained boxes
+        this.logger.debug(`Validating and updating stored fraud boxes with boxIds ${allStoredBoxIds}`);
+        await this.validateOldStoredFrauds(allStoredBoxIds, initialHeight);
+    };
+    /**
+     * Validate all remaining boxes in the database
+     * update the correct ones and remove the invalid ones
+     * @param unchangedStoredBoxIds
+     * @param initialHeight
+     */
+    validateOldStoredFrauds = async (unchangedStoredBoxIds, initialHeight) => {
+        for (const boxId of unchangedStoredBoxIds) {
+            const box = await this.getFraudInfoWithBoxId(boxId);
+            if (box && box.spendBlock && box.spendHeight) {
+                if (box.spendHeight < initialHeight) {
+                    this.logger.debug(`updating spending information of fraud with boxId [${box.boxId}] spent at height [${box.spendHeight}]`);
+                    await this.actions.updateSpendBlock(boxId, this.getId(), box.spendBlock, box.spendHeight);
+                }
+                else {
+                    this.logger.debug(`fraud with boxId [${box.boxId}] has been spent after the initialization height, updating spending information skipped.`);
+                }
+            }
+            else {
+                await this.actions.removeFraud(boxId, this.getId());
+                this.logger.info(`Removed invalid fraud [${boxId}] in initialization validation`);
+            }
+        }
+    };
+    /**
+     * Return extracted information of a fraud with its boxId
+     * @param boxId
+     */
+    getFraudInfoWithBoxId = 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 frauds created bellow the initial height
+     * @param initialHeight
+     * @returns
+     */
+    getUnspentFrauds = async (initialHeight) => {
+        let allBoxes = [];
+        let offset = 0, total = DefaultApiLimit, boxes;
+        while (offset < total) {
+            boxes = await this.api.v1.getApiV1BoxesUnspentByergotreeP1(this.ergoTree, {
+                offset: offset,
+                limit: DefaultApiLimit,
+            });
+            if (!boxes.items) {
+                throw new Error('Explorer api output items should not be undefined.');
+            }
+            allBoxes = [
+                ...allBoxes,
+                ...(await this.extractBoxData(boxes.items.filter((box) => box.creationHeight < initialHeight &&
+                    box.assets &&
+                    box.assets[0].tokenId == this.rwt))),
+            ];
+            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,
+        };
+    };
+    /**
+     * Returns trigger boxId from fraud transaction id
+     * @param txId
+     */
+    getTriggerBoxId = async (txId) => {
+        const tx = await this.api.v1.getApiV1TransactionsP1(txId);
+        return tx.inputs?.[0].boxId;
+    };
+    /**
+     * Extract needed information for storing in database from api json outputs
+     * @param boxes
+     */
+    extractBoxData = async (boxes) => {
+        const extractedFrauds = [];
+        for (const box of boxes) {
+            try {
+                this.logger.debug(`Extracting box fraud information from box with boxId [${box.boxId}]`);
+                let spendBlock, spendHeight;
+                // Extract spending information
+                if (box.spentTransactionId) {
+                    const block = await this.getTxBlock(box.spentTransactionId);
+                    spendBlock = block.id;
+                    spendHeight = block.height;
+                }
+                // Extract WID
+                const ergoBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));
+                const r4 = ergoBox
+                    .register_value(wasm.NonMandatoryRegisterId.R4)
+                    ?.to_coll_coll_byte();
+                // Extract trigger boxId
+                const triggerBoxId = await this.getTriggerBoxId(box.transactionId);
+                if (!r4 || !triggerBoxId) {
+                    this.logger.warn(`Skipping storing fraud with boxId [${box.boxId}], wid or trigger box id is undefined`);
+                    continue;
+                }
+                const extractedFraud = {
+                    boxId: ergoBox.box_id().to_str(),
+                    triggerBoxId: triggerBoxId,
+                    wid: Buffer.from(r4[0]).toString('hex'),
+                    rwtCount: box.assets[0].amount.toString(),
+                    serialized: Buffer.from(ergoBox.sigma_serialize_bytes()).toString('base64'),
+                    blockId: box.blockId,
+                    height: box.settlementHeight,
+                    txId: box.transactionId,
+                    spendBlock: spendBlock,
+                    spendHeight: spendHeight,
+                    spendTxId: box.spentTransactionId,
+                };
+                extractedFrauds.push(extractedFraud);
+                this.logger.debug(`Extracted fraud: [${extractedFraud}]`);
+            }
+            catch (e) {
+                this.logger.error(`Extracting fraud information failed for box [${box.boxId}] with error: ${e}`);
+            }
+        }
+        return extractedFrauds;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fraudExtractor.js","sourceRoot":"","sources":["../../lib/extractor/fraudExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource } from 'typeorm';\nimport * as wasm from 'ergo-lib-wasm-nodejs';\nimport { Buffer } from 'buffer';\nimport { difference } from 'lodash-es';\nimport { AbstractExtractor } from '@rosen-bridge/scanner';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { BlockEntity, Transaction } from '@rosen-bridge/scanner';\nimport ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';\nimport { V1 } from '@rosen-clients/ergo-explorer';\nimport JsonBI from '@rosen-bridge/json-bigint';\n\nimport { FraudAction } from '../actions/fraudAction';\nimport { DefaultApiLimit } from '../constants';\nimport { ExtractedFraud } from '../interfaces/types';\n\nexport class FraudExtractor implements AbstractExtractor<Transaction> {\n  private readonly logger: AbstractLogger;\n  private readonly actions: FraudAction;\n  private readonly id: string;\n  private readonly ergoTree: string;\n  private readonly rwt: string;\n  readonly api;\n\n  constructor(\n    dataSource: DataSource,\n    id: string,\n    explorerUrl: string,\n    fraudAddress: string,\n    rwt: string,\n    logger?: AbstractLogger\n  ) {\n    this.id = id;\n    this.ergoTree = wasm.Address.from_base58(fraudAddress)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.rwt = rwt;\n    this.logger = logger ? logger : new DummyLogger();\n    this.actions = new FraudAction(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   * Extract fraud boxes in the specified block transactions\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 newFrauds: Array<ExtractedFraud> = [];\n        const txSpendIds: Array<{ txId: string; spendBoxes: Array<string> }> =\n          [];\n        txs.forEach((transaction) => {\n          for (const output of transaction.outputs) {\n            if (\n              output.ergoTree !== this.ergoTree ||\n              !output.assets ||\n              output.assets[0].tokenId !== this.rwt\n            ) {\n              continue;\n            }\n            const boxOutput = wasm.ErgoBox.from_json(JsonBI.stringify(output));\n            const r4 = boxOutput\n              .register_value(wasm.NonMandatoryRegisterId.R4)\n              ?.to_coll_coll_byte();\n            if (!r4) {\n              this.logger.debug(\n                `A new fraud box found without correct wid format at height ${block.height}`\n              );\n              continue;\n            }\n            const newFraud = {\n              boxId: output.boxId,\n              txId: transaction.id,\n              triggerBoxId: transaction.inputs[0].boxId,\n              wid: Buffer.from(r4[0]).toString('hex'),\n              rwtCount: output.assets[0].amount.toString(),\n              serialized: Buffer.from(\n                wasm.ErgoBox.from_json(\n                  JsonBI.stringify(output)\n                ).sigma_serialize_bytes()\n              ).toString('base64'),\n            };\n            newFrauds.push(newFraud);\n            this.logger.debug(\n              `new fraud found [${newFraud}] at height ${block.height}`\n            );\n          }\n          txSpendIds.push({\n            txId: transaction.id,\n            spendBoxes: transaction.inputs.map((box) => box.boxId),\n          });\n        });\n        this.actions\n          .storeBlockFrauds(newFrauds, block, this.getId())\n          .then(async (status) => {\n            if (status) {\n              if (newFrauds.length > 0)\n                this.logger.debug(\n                  `successfully stored new frauds at hight ${block.height}`\n                );\n              for (const spendIds of txSpendIds)\n                await this.actions.spendFrauds(\n                  spendIds.spendBoxes,\n                  block,\n                  this.getId(),\n                  spendIds.txId\n                );\n            }\n            resolve(status);\n          })\n          .catch((e) => {\n            this.logger.error(\n              `An error occurred in processing frauds in block [${block.hash}]: ${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.deleteBlock(hash, this.getId());\n  };\n\n  /**\n   * Initializes the database with older frauds\n   */\n  initializeBoxes = async (initialHeight: number) => {\n    // Getting unspent boxes\n    this.logger.debug(\n      `Initializing fraud table. storing fraud boxes created bellow height ${initialHeight}.`\n    );\n    const unspentFrauds = await this.getUnspentFrauds(initialHeight);\n    const unspentBoxIds = unspentFrauds.map((box) => box.boxId);\n    this.logger.debug(`Unspent fraud boxIds ${unspentBoxIds}`);\n\n    // Storing extracted boxes\n    let allStoredBoxIds = await this.actions.getAllBoxIds(this.getId());\n    for (const fraud of unspentFrauds) {\n      if (allStoredBoxIds.includes(fraud.boxId)) {\n        await this.actions.updateFraud(fraud, this.getId());\n        this.logger.info(\n          `Updated the existing unspent fraud with boxId, [${fraud.boxId}]`\n        );\n        this.logger.debug(`Updated fraud: [${JSON.stringify(fraud)}]`);\n      } else {\n        await this.actions.insertFraud(fraud, this.getId());\n        this.logger.info(\n          `Inserted new unspent fraud with boxId, [${fraud.boxId}]`\n        );\n        this.logger.debug(`Inserted fraud: [${JSON.stringify(fraud)}]`);\n      }\n    }\n\n    // Remove updated box ids from existing boxes in database\n    allStoredBoxIds = difference(allStoredBoxIds, unspentBoxIds);\n    // Validating remained boxes\n    this.logger.debug(\n      `Validating and updating stored fraud boxes with boxIds ${allStoredBoxIds}`\n    );\n    await this.validateOldStoredFrauds(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  validateOldStoredFrauds = async (\n    unchangedStoredBoxIds: Array<string>,\n    initialHeight: number\n  ) => {\n    for (const boxId of unchangedStoredBoxIds) {\n      const box = await this.getFraudInfoWithBoxId(boxId);\n      if (box && box.spendBlock && box.spendHeight) {\n        if (box.spendHeight < initialHeight) {\n          this.logger.debug(\n            `updating spending information of fraud with boxId [${box.boxId}] spent at height [${box.spendHeight}]`\n          );\n          await this.actions.updateSpendBlock(\n            boxId,\n            this.getId(),\n            box.spendBlock,\n            box.spendHeight\n          );\n        } else {\n          this.logger.debug(\n            `fraud with boxId [${box.boxId}] has been spent after the initialization height, updating spending information skipped.`\n          );\n        }\n      } else {\n        await this.actions.removeFraud(boxId, this.getId());\n        this.logger.info(\n          `Removed invalid fraud [${boxId}] in initialization validation`\n        );\n      }\n    }\n  };\n\n  /**\n   * Return extracted information of a fraud with its boxId\n   * @param boxId\n   */\n  getFraudInfoWithBoxId = async (\n    boxId: string\n  ): Promise<ExtractedFraud | 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 frauds created bellow the initial height\n   * @param initialHeight\n   * @returns\n   */\n  getUnspentFrauds = async (\n    initialHeight: number\n  ): Promise<Array<ExtractedFraud>> => {\n    let allBoxes: Array<ExtractedFraud> = [];\n    let offset = 0,\n      total = DefaultApiLimit,\n      boxes: V1.ItemsOutputInfo;\n    while (offset < total) {\n      boxes = await this.api.v1.getApiV1BoxesUnspentByergotreeP1(\n        this.ergoTree,\n        {\n          offset: offset,\n          limit: DefaultApiLimit,\n        }\n      );\n      if (!boxes.items) {\n        throw new Error('Explorer api output items should not be undefined.');\n      }\n      allBoxes = [\n        ...allBoxes,\n        ...(await this.extractBoxData(\n          boxes.items.filter(\n            (box) =>\n              box.creationHeight < initialHeight &&\n              box.assets &&\n              box.assets[0].tokenId == this.rwt\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   * Returns trigger boxId from fraud transaction id\n   * @param txId\n   */\n  getTriggerBoxId = async (txId: string) => {\n    const tx = await this.api.v1.getApiV1TransactionsP1(txId);\n    return tx.inputs?.[0].boxId;\n  };\n\n  /**\n   * Extract needed information for storing in database from api json outputs\n   * @param boxes\n   */\n  extractBoxData = async (boxes: Array<V1.OutputInfo>) => {\n    const extractedFrauds: Array<ExtractedFraud> = [];\n    for (const box of boxes) {\n      try {\n        this.logger.debug(\n          `Extracting box fraud information from box with boxId [${box.boxId}]`\n        );\n        let spendBlock, spendHeight;\n        // Extract spending information\n        if (box.spentTransactionId) {\n          const block = await this.getTxBlock(box.spentTransactionId);\n          spendBlock = block.id;\n          spendHeight = block.height;\n        }\n        // Extract WID\n        const ergoBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n        const r4 = ergoBox\n          .register_value(wasm.NonMandatoryRegisterId.R4)\n          ?.to_coll_coll_byte();\n        // Extract trigger boxId\n        const triggerBoxId = await this.getTriggerBoxId(box.transactionId);\n        if (!r4 || !triggerBoxId) {\n          this.logger.warn(\n            `Skipping storing fraud with boxId [${box.boxId}], wid or trigger box id is undefined`\n          );\n          continue;\n        }\n\n        const extractedFraud = {\n          boxId: ergoBox.box_id().to_str(),\n          triggerBoxId: triggerBoxId,\n          wid: Buffer.from(r4[0]).toString('hex'),\n          rwtCount: box.assets![0].amount.toString(),\n          serialized: Buffer.from(ergoBox.sigma_serialize_bytes()).toString(\n            'base64'\n          ),\n          blockId: box.blockId,\n          height: box.settlementHeight,\n          txId: box.transactionId,\n          spendBlock: spendBlock,\n          spendHeight: spendHeight,\n          spendTxId: box.spentTransactionId,\n        };\n        extractedFrauds.push(extractedFraud);\n        this.logger.debug(`Extracted fraud: [${extractedFraud}]`);\n      } catch (e) {\n        this.logger.error(\n          `Extracting fraud information failed for box [${box.boxId}] with error: ${e}`\n        );\n      }\n    }\n    return extractedFrauds;\n  };\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { FraudExtractor } from './extractor/fraudExtractor';
+export { FraudEntity } from './entities/fraudEntity';
+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,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { FraudExtractor } from './extractor/fraudExtractor';
+export { FraudEntity } from './entities/fraudEntity';
+export { migrations } from './migrations/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQzVELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBGcmF1ZEV4dHJhY3RvciB9IGZyb20gJy4vZXh0cmFjdG9yL2ZyYXVkRXh0cmFjdG9yJztcbmV4cG9ydCB7IEZyYXVkRW50aXR5IH0gZnJvbSAnLi9lbnRpdGllcy9mcmF1ZEVudGl0eSc7XG5leHBvcnQgeyBtaWdyYXRpb25zIH0gZnJvbSAnLi9taWdyYXRpb25zL2luZGV4JztcbiJdfQ==

package/dist/interfaces/types.d.ts

@@ -0,0 +1,15 @@
+interface ExtractedFraud {
+    boxId: string;
+    serialized: string;
+    triggerBoxId: string;
+    wid: string;
+    rwtCount: string;
+    blockId?: string;
+    height?: number;
+    txId?: string;
+    spendBlock?: string;
+    spendHeight?: number;
+    spendTxId?: string;
+}
+export { ExtractedFraud };
+//# 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,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/interfaces/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvaW50ZXJmYWNlcy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW50ZXJmYWNlIEV4dHJhY3RlZEZyYXVkIHtcbiAgYm94SWQ6IHN0cmluZztcbiAgc2VyaWFsaXplZDogc3RyaW5nO1xuICB0cmlnZ2VyQm94SWQ6IHN0cmluZztcbiAgd2lkOiBzdHJpbmc7XG4gIHJ3dENvdW50OiBzdHJpbmc7XG4gIGJsb2NrSWQ/OiBzdHJpbmc7XG4gIGhlaWdodD86IG51bWJlcjtcbiAgdHhJZD86IHN0cmluZztcbiAgc3BlbmRCbG9jaz86IHN0cmluZztcbiAgc3BlbmRIZWlnaHQ/OiBudW1iZXI7XG4gIHNwZW5kVHhJZD86IHN0cmluZztcbn1cblxuZXhwb3J0IHsgRXh0cmFjdGVkRnJhdWQgfTtcbiJdfQ==

package/dist/migrations/index.d.ts

@@ -0,0 +1,7 @@
+import { migration1693308311652 } from './postgres/1693308311652-migration';
+import { migration1693122371215 } from './sqlite/1693122371215-migration';
+export declare const migrations: {
+    sqlite: (typeof migration1693122371215)[];
+    postgres: (typeof migration1693308311652)[];
+};
+//# 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;AAC5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E,eAAO,MAAM,UAAU;;;CAGtB,CAAC"}

package/dist/migrations/index.js

@@ -0,0 +1,7 @@
+import { migration1693308311652 } from './postgres/1693308311652-migration';
+import { migration1693122371215 } from './sqlite/1693122371215-migration';
+export const migrations = {
+    sqlite: [migration1693122371215],
+    postgres: [migration1693308311652],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvbWlncmF0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM1RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUUxRSxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUc7SUFDeEIsTUFBTSxFQUFFLENBQUMsc0JBQXNCLENBQUM7SUFDaEMsUUFBUSxFQUFFLENBQUMsc0JBQXNCLENBQUM7Q0FDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG1pZ3JhdGlvbjE2OTMzMDgzMTE2NTIgfSBmcm9tICcuL3Bvc3RncmVzLzE2OTMzMDgzMTE2NTItbWlncmF0aW9uJztcbmltcG9ydCB7IG1pZ3JhdGlvbjE2OTMxMjIzNzEyMTUgfSBmcm9tICcuL3NxbGl0ZS8xNjkzMTIyMzcxMjE1LW1pZ3JhdGlvbic7XG5cbmV4cG9ydCBjb25zdCBtaWdyYXRpb25zID0ge1xuICBzcWxpdGU6IFttaWdyYXRpb24xNjkzMTIyMzcxMjE1XSxcbiAgcG9zdGdyZXM6IFttaWdyYXRpb24xNjkzMzA4MzExNjUyXSxcbn07XG4iXX0=

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

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

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

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

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

@@ -0,0 +1,29 @@
+export class migration1693308311652 {
+    name = 'migration1693308311652';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "fraud_entity" (
+                "id" SERIAL NOT NULL,
+                "boxId" character varying NOT NULL,
+                "creationBlock" character varying NOT NULL,
+                "creationHeight" integer NOT NULL,
+                "creationTxId" character varying NOT NULL,
+                "serialized" character varying NOT NULL,
+                "triggerBoxId" character varying NOT NULL,
+                "wid" character varying NOT NULL,
+                "rwtCount" character varying NOT NULL,
+                "spendBlock" text,
+                "spendHeight" integer,
+                "spendTxId" text,
+                "extractor" character varying NOT NULL,
+                CONSTRAINT "PK_2cf2cfa218dd4a5642bc3f3cf98" PRIMARY KEY ("id")
+            )
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            DROP TABLE "fraud_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTY5MzMwODMxMTY1Mi1taWdyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvbWlncmF0aW9ucy9wb3N0Z3Jlcy8xNjkzMzA4MzExNjUyLW1pZ3JhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLElBQUksR0FBRyx3QkFBd0IsQ0FBQztJQUV6QixLQUFLLENBQUMsRUFBRSxDQUFDLFdBQXdCO1FBQ3RDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7U0FpQm5CLENBQUMsQ0FBQztJQUNULENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSSxDQUFDLFdBQXdCO1FBQ3hDLE1BQU0sV0FBVyxDQUFDLEtBQUssQ0FBQzs7U0FFbkIsQ0FBQyxDQUFDO0lBQ1QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTWlncmF0aW9uSW50ZXJmYWNlLCBRdWVyeVJ1bm5lciB9IGZyb20gJ3R5cGVvcm0nO1xuXG5leHBvcnQgY2xhc3MgbWlncmF0aW9uMTY5MzMwODMxMTY1MiBpbXBsZW1lbnRzIE1pZ3JhdGlvbkludGVyZmFjZSB7XG4gIG5hbWUgPSAnbWlncmF0aW9uMTY5MzMwODMxMTY1Mic7XG5cbiAgcHVibGljIGFzeW5jIHVwKHF1ZXJ5UnVubmVyOiBRdWVyeVJ1bm5lcik6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHF1ZXJ5UnVubmVyLnF1ZXJ5KGBcbiAgICAgICAgICAgIENSRUFURSBUQUJMRSBcImZyYXVkX2VudGl0eVwiIChcbiAgICAgICAgICAgICAgICBcImlkXCIgU0VSSUFMIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwiYm94SWRcIiBjaGFyYWN0ZXIgdmFyeWluZyBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcImNyZWF0aW9uQmxvY2tcIiBjaGFyYWN0ZXIgdmFyeWluZyBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcImNyZWF0aW9uSGVpZ2h0XCIgaW50ZWdlciBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcImNyZWF0aW9uVHhJZFwiIGNoYXJhY3RlciB2YXJ5aW5nIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwic2VyaWFsaXplZFwiIGNoYXJhY3RlciB2YXJ5aW5nIE5PVCBOVUxMLFxuICAgICAgICAgICAgICAgIFwidHJpZ2dlckJveElkXCIgY2hhcmFjdGVyIHZhcnlpbmcgTk9UIE5VTEwsXG4gICAgICAgICAgICAgICAgXCJ3aWRcIiBjaGFyYWN0ZXIgdmFyeWluZyBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBcInJ3dENvdW50XCIgY2hhcmFjdGVyIHZhcnlpbmcgTk9UIE5VTEwsXG4gICAgICAgICAgICAgICAgXCJzcGVuZEJsb2NrXCIgdGV4dCxcbiAgICAgICAgICAgICAgICBcInNwZW5kSGVpZ2h0XCIgaW50ZWdlcixcbiAgICAgICAgICAgICAgICBcInNwZW5kVHhJZFwiIHRleHQsXG4gICAgICAgICAgICAgICAgXCJleHRyYWN0b3JcIiBjaGFyYWN0ZXIgdmFyeWluZyBOT1QgTlVMTCxcbiAgICAgICAgICAgICAgICBDT05TVFJBSU5UIFwiUEtfMmNmMmNmYTIxOGRkNGE1NjQyYmMzZjNjZjk4XCIgUFJJTUFSWSBLRVkgKFwiaWRcIilcbiAgICAgICAgICAgIClcbiAgICAgICAgYCk7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgZG93bihxdWVyeVJ1bm5lcjogUXVlcnlSdW5uZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBxdWVyeVJ1bm5lci5xdWVyeShgXG4gICAgICAgICAgICBEUk9QIFRBQkxFIFwiZnJhdWRfZW50aXR5XCJcbiAgICAgICAgYCk7XG4gIH1cbn1cbiJdfQ==

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"1693122371215-migration.d.ts","sourceRoot":"","sources":["../../../lib/migrations/sqlite/1693122371215-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/sqlite/1693122371215-migration.js

@@ -0,0 +1,28 @@
+export class migration1693122371215 {
+    name = 'migration1693122371215';
+    async up(queryRunner) {
+        await queryRunner.query(`
+            CREATE TABLE "fraud_entity" (
+                "id" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+                "boxId" varchar NOT NULL,
+                "creationBlock" varchar NOT NULL,
+                "creationHeight" integer NOT NULL,
+                "creationTxId" varchar NOT NULL,
+                "serialized" varchar NOT NULL,
+                "triggerBoxId" varchar NOT NULL,
+                "wid" varchar NOT NULL,
+                "rwtCount" varchar NOT NULL,
+                "spendBlock" text,
+                "spendHeight" integer,
+                "spendTxId" text,
+                "extractor" varchar NOT NULL
+            )
+        `);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`
+            DROP TABLE "fraud_entity"
+        `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@rosen-bridge/fraud-extractor",
+  "version": "0.1.1",
+  "description": "fraud information extractor for watcher faulty reports",
+  "author": "Rosen Team",
+  "license": "GPL-3.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prettify": "prettier --write . --ignore-path ../../.gitignore",
+    "lint": "eslint --fix . && npm run prettify",
+    "test": "jest --detectOpenHandles",
+    "coverage": "jest --detectOpenHandles --coverage",
+    "build": "tsc --build",
+    "type-check": "tsc --noEmit",
+    "release": "npm run test && npm run build && npm publish --access public"
+  },
+  "dependencies": {
+    "@rosen-bridge/abstract-logger": "^0.3.0",
+    "@rosen-bridge/json-bigint": "^0.1.0",
+    "@rosen-bridge/scanner": "^2.2.1",
+    "blakejs": "^1.2.1",
+    "ergo-lib-wasm-nodejs": "^0.24.1",
+    "lodash-es": "^4.17.21",
+    "reflect-metadata": "^0.1.13",
+    "sqlite3": "^5.0.9",
+    "typeorm": "^0.3.7"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@babel/preset-env": "^7.19.0",
+    "@types/jest": "^28.1.6",
+    "@types/json-bigint": "^1.0.1",
+    "@types/node": "^18.0.6",
+    "@typescript-eslint/eslint-plugin": "^5.30.7",
+    "@typescript-eslint/parser": "^5.26.0",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.5.0",
+    "jest": "^28.1.3",
+    "json-bigint": "^1.0.0",
+    "prettier": "2.7.1",
+    "ts-jest": "^28.0.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.7.4"
+  },
+  "engines": {
+    "node": ">=16.14.0"
+  }
+}