@my-packages-changeit/watcher-data-extractor 13.0.10

package/dist/actions/commitmentAction.js

@@ -0,0 +1,138 @@
+import { chunk } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { In, } from '@rosen-bridge/extended-typeorm';
+import { dbIdChunkSize } from '../constants';
+import CommitmentEntity from '../entities/commitmentEntity';
+class CommitmentAction {
+    logger;
+    datasource;
+    commitmentRepository;
+    constructor(dataSource, logger) {
+        this.datasource = dataSource;
+        this.logger = logger ? logger : new DummyLogger();
+        this.commitmentRepository = dataSource.getRepository(CommitmentEntity);
+    }
+    /**
+     * It stores list of observations in the dataSource with block id
+     * @param commitments
+     * @param block
+     * @param extractor
+     */
+    storeCommitments = async (commitments, block, extractor) => {
+        if (commitments.length === 0)
+            return true;
+        const boxIds = commitments.map((commitment) => commitment.boxId);
+        const savedCommitments = await this.commitmentRepository.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(CommitmentEntity);
+        try {
+            for (const commitment of commitments) {
+                const saved = savedCommitments.some((entity) => {
+                    return entity.boxId === commitment.boxId;
+                });
+                const entity = {
+                    txId: commitment.txId,
+                    commitment: commitment.commitment,
+                    eventId: commitment.eventId,
+                    boxId: commitment.boxId,
+                    WID: commitment.WID,
+                    extractor: extractor,
+                    block: block.hash,
+                    height: block.height,
+                    boxSerialized: commitment.boxSerialized,
+                    rwtCount: commitment.rwtCount,
+                };
+                if (!saved) {
+                    this.logger.info(`Saving commitment [${commitment.boxId}] for event [${commitment.eventId}] from watcher [${commitment.WID}] at height ${block.height} and extractor ${extractor}`);
+                    await repository.insert(entity);
+                }
+                else {
+                    this.logger.info(`Updating commitment [${commitment.boxId}] for event [${commitment.eventId}] from watcher [${commitment.WID}] at height ${block.height} and extractor ${extractor}`);
+                    await repository.update({ boxId: commitment.boxId }, entity);
+                }
+                this.logger.debug(`Entity: ${JSON.stringify(entity)}`);
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store commitments action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return success;
+    };
+    /**
+     * Update spendBlock and spendHeight of commitments spent on the block
+     * @param spendId
+     * @param block
+     * @param extractor
+     */
+    spendCommitments = async (spendId, block, extractor) => {
+        // TODO: improve updating (local:ergo/rosen-bridge/scanner#85)
+        const spendIdChunks = chunk(spendId, dbIdChunkSize);
+        for (const spendIdChunk of spendIdChunks) {
+            const commitments = await this.commitmentRepository.findBy({
+                boxId: In(spendIdChunk.map((info) => info.boxId)),
+                extractor: extractor,
+            });
+            for (const commitment of commitments) {
+                const spendInfo = spendIdChunk.find((info) => info.boxId === commitment.boxId);
+                if (!spendInfo)
+                    throw new Error(`ImpossibleBehavior: box [${commitment.boxId}] is not found in spending info list`);
+                await this.commitmentRepository.update({
+                    id: commitment.id,
+                }, {
+                    spendBlock: block.hash,
+                    spendHeight: block.height,
+                    spendTxId: spendInfo.txId,
+                    spendIndex: spendInfo.index,
+                });
+                this.logger.info(`Spent commitment [${commitment.boxId}] for event [${commitment.eventId}] at height ${block.height}`);
+                this.logger.debug(`Spent commitment [${JSON.stringify(commitment)}]`);
+            }
+        }
+    };
+    /**
+     * Delete all commitments corresponding to the block(id) and extractor(id)
+     * and update all commitments spent on the specified block
+     * @param block
+     * @param extractor
+     */
+    deleteBlock = async (block, extractor) => {
+        this.logger.info(`Deleting commitments of block [${block}] and extractor ${extractor}`);
+        await this.commitmentRepository.delete({
+            block: block,
+            extractor: extractor,
+        });
+        await this.commitmentRepository.update({ spendBlock: block, extractor: extractor }, {
+            spendBlock: null,
+            spendHeight: null,
+            spendTxId: null,
+            spendIndex: null,
+        });
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `CommitmentEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @param extractorId - Identifier of the extractor
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = (extractorId) => {
+        return this.commitmentRepository
+            .createQueryBuilder('commitmentEntity')
+            .select('commitmentEntity.block', 'block')
+            .where('commitmentEntity.extractor = :extractorId', { extractorId });
+    };
+}
+export default CommitmentAction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commitmentAction.js","sourceRoot":"","sources":["../../lib/actions/commitmentAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAElC,OAAO,EAAkB,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAEL,EAAE,GAGH,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,gBAAgB,MAAM,8BAA8B,CAAC;AAI5D,MAAM,gBAAgB;IACX,MAAM,CAAiB;IACf,UAAU,CAAa;IACvB,oBAAoB,CAA+B;IAEpE,YAAY,UAAsB,EAAE,MAAuB;QACzD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC;QAClD,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACzE,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,GAAG,KAAK,EACtB,WAAuC,EACvC,KAAgB,EAChB,SAAiB,EACC,EAAE;QACpB,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1C,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACjE,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC;YAC9D,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC;YACjB,SAAS,EAAE,SAAS;SACrB,CAAC,CAAC;QACH,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QACrC,MAAM,UAAU,GACd,MAAM,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC;QAC5D,IAAI,CAAC;YACH,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;gBACrC,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;oBAC7C,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,CAAC,KAAK,CAAC;gBAC3C,CAAC,CAAC,CAAC;gBACH,MAAM,MAAM,GAAG;oBACb,IAAI,EAAE,UAAU,CAAC,IAAI;oBACrB,UAAU,EAAE,UAAU,CAAC,UAAU;oBACjC,OAAO,EAAE,UAAU,CAAC,OAAO;oBAC3B,KAAK,EAAE,UAAU,CAAC,KAAK;oBACvB,GAAG,EAAE,UAAU,CAAC,GAAG;oBACnB,SAAS,EAAE,SAAS;oBACpB,KAAK,EAAE,KAAK,CAAC,IAAI;oBACjB,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,aAAa,EAAE,UAAU,CAAC,aAAa;oBACvC,QAAQ,EAAE,UAAU,CAAC,QAAQ;iBAC9B,CAAC;gBACF,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,sBAAsB,UAAU,CAAC,KAAK,gBAAgB,UAAU,CAAC,OAAO,mBAAmB,UAAU,CAAC,GAAG,eAAe,KAAK,CAAC,MAAM,kBAAkB,SAAS,EAAE,CAClK,CAAC;oBACF,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAClC,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,wBAAwB,UAAU,CAAC,KAAK,gBAAgB,UAAU,CAAC,OAAO,mBAAmB,UAAU,CAAC,GAAG,eAAe,KAAK,CAAC,MAAM,kBAAkB,SAAS,EAAE,CACpK,CAAC;oBACF,MAAM,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC,CAAC;gBAC/D,CAAC;gBACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACzD,CAAC;YACD,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACxC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,sDAAsD,CAAC,EAAE,CAC1D,CAAC;YACF,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,OAAO,GAAG,KAAK,CAAC;QAClB,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC;IAEF;;;;;OAKG;IACH,gBAAgB,GAAG,KAAK,EACtB,OAAyB,EACzB,KAAgB,EAChB,SAAiB,EACF,EAAE;QACjB,8DAA8D;QAC9D,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QACpD,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;YACzC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC;gBACzD,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACjD,SAAS,EAAE,SAAS;aACrB,CAAC,CAAC;YAEH,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;gBACrC,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,CACjC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,KAAK,UAAU,CAAC,KAAK,CAC1C,CAAC;gBACF,IAAI,CAAC,SAAS;oBACZ,MAAM,IAAI,KAAK,CACb,4BAA4B,UAAU,CAAC,KAAK,sCAAsC,CACnF,CAAC;gBAEJ,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CACpC;oBACE,EAAE,EAAE,UAAU,CAAC,EAAE;iBAClB,EACD;oBACE,UAAU,EAAE,KAAK,CAAC,IAAI;oBACtB,WAAW,EAAE,KAAK,CAAC,MAAM;oBACzB,SAAS,EAAE,SAAS,CAAC,IAAI;oBACzB,UAAU,EAAE,SAAS,CAAC,KAAK;iBAC5B,CACF,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,qBAAqB,UAAU,CAAC,KAAK,gBAAgB,UAAU,CAAC,OAAO,eAAe,KAAK,CAAC,MAAM,EAAE,CACrG,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;IACH,CAAC,CAAC;IAEF;;;;;OAKG;IACH,WAAW,GAAG,KAAK,EAAE,KAAa,EAAE,SAAiB,EAAE,EAAE;QACvD,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,kCAAkC,KAAK,mBAAmB,SAAS,EAAE,CACtE,CAAC;QACF,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC;YACrC,KAAK,EAAE,KAAK;YACZ,SAAS,EAAE,SAAS;SACrB,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CACpC,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,EAC3C;YACE,UAAU,EAAE,IAAI;YAChB,WAAW,EAAE,IAAI;YACjB,SAAS,EAAE,IAAI;YACf,UAAU,EAAE,IAAI;SACjB,CACF,CAAC;IACJ,CAAC,CAAC;IAEF;;;;;;OAMG;IACH,qBAAqB,GAAG,CACtB,WAAmB,EACmB,EAAE;QACxC,OAAO,IAAI,CAAC,oBAAoB;aAC7B,kBAAkB,CAAC,kBAAkB,CAAC;aACtC,MAAM,CAAC,wBAAwB,EAAE,OAAO,CAAC;aACzC,KAAK,CAAC,2CAA2C,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;IACzE,CAAC,CAAC;CACH;AAED,eAAe,gBAAgB,CAAC","sourcesContent":["import { chunk } from 'lodash-es';\n\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  DataSource,\n  In,\n  Repository,\n  SelectQueryBuilder,\n} from '@rosen-bridge/extended-typeorm';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport { dbIdChunkSize } from '../constants';\nimport CommitmentEntity from '../entities/commitmentEntity';\nimport { extractedCommitment } from '../interfaces/extractedCommitment';\nimport { SpendInfo } from '../interfaces/types';\n\nclass CommitmentAction {\n  readonly logger: AbstractLogger;\n  private readonly datasource: DataSource;\n  private readonly commitmentRepository: Repository<CommitmentEntity>;\n\n  constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    this.datasource = dataSource;\n    this.logger = logger ? logger : new DummyLogger();\n    this.commitmentRepository = dataSource.getRepository(CommitmentEntity);\n  }\n\n  /**\n   * It stores list of observations in the dataSource with block id\n   * @param commitments\n   * @param block\n   * @param extractor\n   */\n  storeCommitments = async (\n    commitments: Array<extractedCommitment>,\n    block: BlockInfo,\n    extractor: string,\n  ): Promise<boolean> => {\n    if (commitments.length === 0) return true;\n    const boxIds = commitments.map((commitment) => commitment.boxId);\n    const savedCommitments = await this.commitmentRepository.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 =\n      await queryRunner.manager.getRepository(CommitmentEntity);\n    try {\n      for (const commitment of commitments) {\n        const saved = savedCommitments.some((entity) => {\n          return entity.boxId === commitment.boxId;\n        });\n        const entity = {\n          txId: commitment.txId,\n          commitment: commitment.commitment,\n          eventId: commitment.eventId,\n          boxId: commitment.boxId,\n          WID: commitment.WID,\n          extractor: extractor,\n          block: block.hash,\n          height: block.height,\n          boxSerialized: commitment.boxSerialized,\n          rwtCount: commitment.rwtCount,\n        };\n        if (!saved) {\n          this.logger.info(\n            `Saving commitment [${commitment.boxId}] for event [${commitment.eventId}] from watcher [${commitment.WID}] at height ${block.height} and extractor ${extractor}`,\n          );\n          await repository.insert(entity);\n        } else {\n          this.logger.info(\n            `Updating commitment [${commitment.boxId}] for event [${commitment.eventId}] from watcher [${commitment.WID}] at height ${block.height} and extractor ${extractor}`,\n          );\n          await repository.update({ boxId: commitment.boxId }, entity);\n        }\n        this.logger.debug(`Entity: ${JSON.stringify(entity)}`);\n      }\n      await queryRunner.commitTransaction();\n    } catch (e) {\n      this.logger.error(\n        `An error occurred during store commitments action: ${e}`,\n      );\n      await queryRunner.rollbackTransaction();\n      success = false;\n    } finally {\n      await queryRunner.release();\n    }\n    return success;\n  };\n\n  /**\n   * Update spendBlock and spendHeight of commitments spent on the block\n   * @param spendId\n   * @param block\n   * @param extractor\n   */\n  spendCommitments = async (\n    spendId: Array<SpendInfo>,\n    block: BlockInfo,\n    extractor: string,\n  ): Promise<void> => {\n    // TODO: improve updating (local:ergo/rosen-bridge/scanner#85)\n    const spendIdChunks = chunk(spendId, dbIdChunkSize);\n    for (const spendIdChunk of spendIdChunks) {\n      const commitments = await this.commitmentRepository.findBy({\n        boxId: In(spendIdChunk.map((info) => info.boxId)),\n        extractor: extractor,\n      });\n\n      for (const commitment of commitments) {\n        const spendInfo = spendIdChunk.find(\n          (info) => info.boxId === commitment.boxId,\n        );\n        if (!spendInfo)\n          throw new Error(\n            `ImpossibleBehavior: box [${commitment.boxId}] is not found in spending info list`,\n          );\n\n        await this.commitmentRepository.update(\n          {\n            id: commitment.id,\n          },\n          {\n            spendBlock: block.hash,\n            spendHeight: block.height,\n            spendTxId: spendInfo.txId,\n            spendIndex: spendInfo.index,\n          },\n        );\n        this.logger.info(\n          `Spent commitment [${commitment.boxId}] for event [${commitment.eventId}] at height ${block.height}`,\n        );\n        this.logger.debug(`Spent commitment [${JSON.stringify(commitment)}]`);\n      }\n    }\n  };\n\n  /**\n   * Delete all commitments corresponding to the block(id) and extractor(id)\n   * and update all commitments spent on the specified block\n   * @param block\n   * @param extractor\n   */\n  deleteBlock = async (block: string, extractor: string) => {\n    this.logger.info(\n      `Deleting commitments of block [${block}] and extractor ${extractor}`,\n    );\n    await this.commitmentRepository.delete({\n      block: block,\n      extractor: extractor,\n    });\n    await this.commitmentRepository.update(\n      { spendBlock: block, extractor: extractor },\n      {\n        spendBlock: null,\n        spendHeight: null,\n        spendTxId: null,\n        spendIndex: null,\n      },\n    );\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `CommitmentEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @param extractorId - Identifier of the extractor\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (\n    extractorId: string,\n  ): SelectQueryBuilder<CommitmentEntity> => {\n    return this.commitmentRepository\n      .createQueryBuilder('commitmentEntity')\n      .select('commitmentEntity.block', 'block')\n      .where('commitmentEntity.extractor = :extractorId', { extractorId });\n  };\n}\n\nexport default CommitmentAction;\n"]}

package/dist/actions/eventTriggerAction.d.ts

@@ -0,0 +1,29 @@
+import { AbstractErgoBoxAction, EntityInfo, SpendInfo } from '@rosen-bridge/abstract-extractor';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import EventTriggerEntity from '../entities/eventTriggerEntity';
+import { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';
+declare class EventTriggerAction extends AbstractErgoBoxAction<ExtractedEventTrigger, EventTriggerEntity> {
+    constructor(dataSource: DataSource, logger?: AbstractLogger);
+    /**
+     * create the box entity from extracted data and block information
+     */
+    createEntity: (triggerBoxes: ExtractedEventTrigger[], block: BlockInfo, extractor: string) => Omit<EventTriggerEntity, "id">[];
+    /**
+     * convert the database entity back to raw data
+     */
+    convertEntityToData: (entities: EventTriggerEntity[]) => ExtractedEventTrigger[];
+    /**
+     * update spending information of stored event triggers
+     * and set result and paymentTxId of the event
+     * chunk spendInfos to prevent large database queries
+     * @param spendInfArray
+     * @param block
+     * @param extractorId
+     * @returns spent box ids
+     */
+    spendBoxes: (spendInfoArray: Array<SpendInfo>, block: BlockInfo, extractorId: string) => Promise<EntityInfo[]>;
+}
+export default EventTriggerAction;
+//# sourceMappingURL=eventTriggerAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventTriggerAction.d.ts","sourceRoot":"","sources":["../../lib/actions/eventTriggerAction.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,qBAAqB,EAErB,UAAU,EACV,SAAS,EACV,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAM,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,OAAO,kBAAkB,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAG5E,cAAM,kBAAmB,SAAQ,qBAAqB,CACpD,qBAAqB,EACrB,kBAAkB,CACnB;gBACa,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,cAAc;IAI3D;;OAEG;IACH,YAAY,GACV,cAAc,qBAAqB,EAAE,EACrC,OAAO,SAAS,EAChB,WAAW,MAAM,KAChB,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,EAAE,CAwBjC;IAEF;;OAEG;IACH,mBAAmB,GACjB,UAAU,kBAAkB,EAAE,KAC7B,qBAAqB,EAAE,CAuBxB;IAEF;;;;;;;;OAQG;IACH,UAAU,GACR,gBAAgB,KAAK,CAAC,SAAS,CAAC,EAChC,OAAO,SAAS,EAChB,aAAa,MAAM,KAClB,OAAO,CAAC,UAAU,EAAE,CAAC,CAyCtB;CACH;AAED,eAAe,kBAAkB,CAAC"}

package/dist/actions/eventTriggerAction.js

@@ -0,0 +1,101 @@
+import { chunk, pick } from 'lodash-es';
+import { AbstractErgoBoxAction, DB_CHUNK_SIZE, } from '@rosen-bridge/abstract-extractor';
+import { In } from '@rosen-bridge/extended-typeorm';
+import EventTriggerEntity from '../entities/eventTriggerEntity';
+import { JsonBI } from '../utils';
+class EventTriggerAction extends AbstractErgoBoxAction {
+    constructor(dataSource, logger) {
+        super(dataSource, EventTriggerEntity, logger);
+    }
+    /**
+     * create the box entity from extracted data and block information
+     */
+    createEntity = (triggerBoxes, block, extractor) => {
+        return triggerBoxes.map((trigger) => ({
+            txId: trigger.txId,
+            eventId: trigger.eventId,
+            identifier: trigger.identifier,
+            serialized: trigger.serialized,
+            block: block.hash,
+            height: block.height,
+            extractor: extractor,
+            WIDsCount: trigger.WIDsCount,
+            WIDsHash: trigger.WIDsHash,
+            amount: trigger.amount,
+            bridgeFee: trigger.bridgeFee,
+            fromAddress: trigger.fromAddress,
+            toAddress: trigger.toAddress,
+            fromChain: trigger.fromChain,
+            networkFee: trigger.networkFee,
+            sourceChainTokenId: trigger.sourceChainTokenId,
+            targetChainTokenId: trigger.targetChainTokenId,
+            sourceBlockId: trigger.sourceBlockId,
+            toChain: trigger.toChain,
+            sourceTxId: trigger.sourceTxId,
+            sourceChainHeight: trigger.sourceChainHeight,
+        }));
+    };
+    /**
+     * convert the database entity back to raw data
+     */
+    convertEntityToData = (entities) => {
+        return entities.map((data) => pick(data, [
+            'eventId',
+            'txId',
+            'identifier',
+            'serialized',
+            'fromChain',
+            'toChain',
+            'fromAddress',
+            'toAddress',
+            'amount',
+            'bridgeFee',
+            'networkFee',
+            'sourceChainTokenId',
+            'targetChainTokenId',
+            'sourceBlockId',
+            'sourceTxId',
+            'WIDsCount',
+            'WIDsHash',
+            'sourceChainHeight',
+        ]));
+    };
+    /**
+     * update spending information of stored event triggers
+     * and set result and paymentTxId of the event
+     * chunk spendInfos to prevent large database queries
+     * @param spendInfArray
+     * @param block
+     * @param extractorId
+     * @returns spent box ids
+     */
+    spendBoxes = async (spendInfoArray, block, extractorId) => {
+        const spentData = [];
+        const spendInfoChunks = chunk(spendInfoArray, DB_CHUNK_SIZE);
+        for (const spendInfoChunk of spendInfoChunks) {
+            const spentTriggers = await this.repository.findBy({
+                identifier: In(spendInfoChunk.map((spendInfo) => spendInfo.boxId)),
+                extractor: extractorId,
+            });
+            for (const spentTrigger of spentTriggers) {
+                const spendInfo = spendInfoChunk.find((info) => info.boxId === spentTrigger.identifier);
+                if (!spendInfo || !spendInfo.extras || !spendInfo.extras.result) {
+                    throw Error(`ImpossibleBehavior:: spending information extras does not contain result, ${JsonBI.stringify(spendInfo)}`);
+                }
+                await this.repository.update({ identifier: spendInfo.boxId, extractor: extractorId }, {
+                    spendBlock: block.hash,
+                    spendHeight: block.height,
+                    spendTxId: spendInfo.txId,
+                    result: spendInfo.extras.result,
+                    paymentTxId: spendInfo.extras.paymentTxId || '',
+                });
+                spentData.push({ identifier: spendInfo.boxId });
+                this.logger.info(`Spent trigger [${spentTrigger.identifier}] of event [${spentTrigger.eventId}] at height ${block.height}`);
+                this.logger.debug(`Spent trigger: [${JSON.stringify(spentTrigger)}] with spending information [${JsonBI.stringify(spendInfo)}]`);
+            }
+        }
+        return spentData;
+    };
+}
+export default EventTriggerAction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eventTriggerAction.js","sourceRoot":"","sources":["../../lib/actions/eventTriggerAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { chunk, pick } from 'lodash-es';\n\nimport {\n  AbstractErgoBoxAction,\n  DB_CHUNK_SIZE,\n  EntityInfo,\n  SpendInfo,\n} from '@rosen-bridge/abstract-extractor';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { DataSource, In } from '@rosen-bridge/extended-typeorm';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport EventTriggerEntity from '../entities/eventTriggerEntity';\nimport { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';\nimport { JsonBI } from '../utils';\n\nclass EventTriggerAction extends AbstractErgoBoxAction<\n  ExtractedEventTrigger,\n  EventTriggerEntity\n> {\n  constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    super(dataSource, EventTriggerEntity, logger);\n  }\n\n  /**\n   * create the box entity from extracted data and block information\n   */\n  createEntity = (\n    triggerBoxes: ExtractedEventTrigger[],\n    block: BlockInfo,\n    extractor: string,\n  ): Omit<EventTriggerEntity, 'id'>[] => {\n    return triggerBoxes.map((trigger) => ({\n      txId: trigger.txId,\n      eventId: trigger.eventId,\n      identifier: trigger.identifier,\n      serialized: trigger.serialized,\n      block: block.hash,\n      height: block.height,\n      extractor: extractor,\n      WIDsCount: trigger.WIDsCount,\n      WIDsHash: trigger.WIDsHash,\n      amount: trigger.amount,\n      bridgeFee: trigger.bridgeFee,\n      fromAddress: trigger.fromAddress,\n      toAddress: trigger.toAddress,\n      fromChain: trigger.fromChain,\n      networkFee: trigger.networkFee,\n      sourceChainTokenId: trigger.sourceChainTokenId,\n      targetChainTokenId: trigger.targetChainTokenId,\n      sourceBlockId: trigger.sourceBlockId,\n      toChain: trigger.toChain,\n      sourceTxId: trigger.sourceTxId,\n      sourceChainHeight: trigger.sourceChainHeight,\n    }));\n  };\n\n  /**\n   * convert the database entity back to raw data\n   */\n  convertEntityToData = (\n    entities: EventTriggerEntity[],\n  ): ExtractedEventTrigger[] => {\n    return entities.map((data) =>\n      pick(data, [\n        'eventId',\n        'txId',\n        'identifier',\n        'serialized',\n        'fromChain',\n        'toChain',\n        'fromAddress',\n        'toAddress',\n        'amount',\n        'bridgeFee',\n        'networkFee',\n        'sourceChainTokenId',\n        'targetChainTokenId',\n        'sourceBlockId',\n        'sourceTxId',\n        'WIDsCount',\n        'WIDsHash',\n        'sourceChainHeight',\n      ]),\n    );\n  };\n\n  /**\n   * update spending information of stored event triggers\n   * and set result and paymentTxId of the event\n   * chunk spendInfos to prevent large database queries\n   * @param spendInfArray\n   * @param block\n   * @param extractorId\n   * @returns spent box ids\n   */\n  spendBoxes = async (\n    spendInfoArray: Array<SpendInfo>,\n    block: BlockInfo,\n    extractorId: string,\n  ): Promise<EntityInfo[]> => {\n    const spentData = [];\n    const spendInfoChunks = chunk(spendInfoArray, DB_CHUNK_SIZE);\n    for (const spendInfoChunk of spendInfoChunks) {\n      const spentTriggers = await this.repository.findBy({\n        identifier: In(spendInfoChunk.map((spendInfo) => spendInfo.boxId)),\n        extractor: extractorId,\n      });\n      for (const spentTrigger of spentTriggers) {\n        const spendInfo = spendInfoChunk.find(\n          (info) => info.boxId === spentTrigger.identifier,\n        );\n        if (!spendInfo || !spendInfo.extras || !spendInfo.extras.result) {\n          throw Error(\n            `ImpossibleBehavior:: spending information extras does not contain result, ${JsonBI.stringify(\n              spendInfo,\n            )}`,\n          );\n        }\n        await this.repository.update(\n          { identifier: spendInfo.boxId, extractor: extractorId },\n          {\n            spendBlock: block.hash,\n            spendHeight: block.height,\n            spendTxId: spendInfo.txId,\n            result: spendInfo.extras.result,\n            paymentTxId: spendInfo.extras.paymentTxId || '',\n          },\n        );\n        spentData.push({ identifier: spendInfo.boxId });\n        this.logger.info(\n          `Spent trigger [${spentTrigger.identifier}] of event [${spentTrigger.eventId}] at height ${block.height}`,\n        );\n        this.logger.debug(\n          `Spent trigger: [${JSON.stringify(\n            spentTrigger,\n          )}] with spending information [${JsonBI.stringify(spendInfo)}]`,\n        );\n      }\n    }\n    return spentData;\n  };\n}\n\nexport default EventTriggerAction;\n"]}

package/dist/actions/permitAction.d.ts

@@ -0,0 +1,73 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource, SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import PermitEntity from '../entities/permitEntity';
+import { ExtractedPermit } from '../interfaces/extractedPermit';
+declare class PermitAction {
+    readonly logger: AbstractLogger;
+    private readonly datasource;
+    private readonly permitRepository;
+    constructor(dataSource: DataSource, logger?: AbstractLogger);
+    /**
+     * insert a new permit boxes in the database
+     * @param permits
+     * @param initialHeight
+     * @param extractor
+     */
+    insertPermit: (permit: ExtractedPermit, extractor: string) => Promise<import("@rosen-bridge/extended-typeorm").InsertResult>;
+    /**
+     * update an unspent permit in the database
+     * @param permit
+     * @param extractor
+     */
+    updatePermit: (permit: ExtractedPermit, extractor: string) => Promise<void>;
+    /**
+     * It stores list of permits in the dataSource with block id
+     * @param permits
+     * @param block
+     * @param extractor
+     */
+    storePermits: (permits: Array<ExtractedPermit>, block: BlockInfo, extractor: string) => Promise<boolean>;
+    /**
+     * Update spendBlock and spendHeight of permits spent on the block
+     * @param spendId
+     * @param block
+     * @param extractor
+     */
+    spendPermits: (spendId: Array<string>, block: BlockInfo, extractor: string) => Promise<void>;
+    /**
+     * Delete all permits corresponding to the block(id) and extractor(id)
+     * and update all permits spent on the specified block
+     * @param block
+     * @param extractor
+     */
+    deleteBlock: (block: string, extractor: string) => Promise<void>;
+    /**
+     *  Returns all stored permit box ids
+     */
+    getAllPermitBoxIds: (extractor: string) => Promise<Array<string>>;
+    /**
+     * Removes specified permit
+     * @param boxId
+     * @param extractor
+     */
+    removePermit: (boxId: string, extractor: string) => Promise<import("@rosen-bridge/extended-typeorm").DeleteResult>;
+    /**
+     * Update the permit spending information
+     * @param boxId
+     * @param extractor
+     * @param blockId
+     * @param blockHeight
+     */
+    updateSpendBlock: (boxId: string, extractor: string, blockId: string, blockHeight: number) => Promise<import("@rosen-bridge/extended-typeorm").UpdateResult>;
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `PermitEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @param extractorId - Identifier of the extractor
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery: (extractorId: string) => SelectQueryBuilder<PermitEntity>;
+}
+export default PermitAction;
+//# sourceMappingURL=permitAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permitAction.d.ts","sourceRoot":"","sources":["../../lib/actions/permitAction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,UAAU,EAGV,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAG7D,OAAO,YAAY,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,cAAM,YAAY;IAChB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;gBAEhD,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,cAAc;IAM3D;;;;;OAKG;IACH,YAAY,GAAU,QAAQ,eAAe,EAAE,WAAW,MAAM,oEAY9D;IAEF;;;;OAIG;IACH,YAAY,GAAU,QAAQ,eAAe,EAAE,WAAW,MAAM,mBAa9D;IAEF;;;;;OAKG;IACH,YAAY,GACV,SAAS,KAAK,CAAC,eAAe,CAAC,EAC/B,OAAO,SAAS,EAChB,WAAW,MAAM,sBAiDjB;IAEF;;;;;OAKG;IACH,YAAY,GACV,SAAS,KAAK,CAAC,MAAM,CAAC,EACtB,OAAO,SAAS,EAChB,WAAW,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAoBd;IAEF;;;;;OAKG;IACH,WAAW,GAAU,OAAO,MAAM,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CASnE;IAEF;;OAEG;IACH,kBAAkB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAUpE;IAEF;;;;OAIG;IACH,YAAY,GAAU,OAAO,MAAM,EAAE,WAAW,MAAM,oEAKpD;IAEF;;;;;;OAMG;IACH,gBAAgB,GACd,OAAO,MAAM,EACb,WAAW,MAAM,EACjB,SAAS,MAAM,EACf,aAAa,MAAM,oEAMnB;IAEF;;;;;;OAMG;IACH,qBAAqB,GACnB,aAAa,MAAM,KAClB,kBAAkB,CAAC,YAAY,CAAC,CAKjC;CACH;AAED,eAAe,YAAY,CAAC"}

package/dist/actions/permitAction.js

@@ -0,0 +1,187 @@
+import { chunk } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { In, } from '@rosen-bridge/extended-typeorm';
+import { dbIdChunkSize } from '../constants';
+import PermitEntity from '../entities/permitEntity';
+class PermitAction {
+    logger;
+    datasource;
+    permitRepository;
+    constructor(dataSource, logger) {
+        this.datasource = dataSource;
+        this.logger = logger ? logger : new DummyLogger();
+        this.permitRepository = dataSource.getRepository(PermitEntity);
+    }
+    /**
+     * insert a new permit boxes in the database
+     * @param permits
+     * @param initialHeight
+     * @param extractor
+     */
+    insertPermit = async (permit, extractor) => {
+        return this.permitRepository.insert({
+            boxId: permit.boxId,
+            boxSerialized: permit.boxSerialized,
+            block: permit.block,
+            height: permit.height,
+            extractor: extractor,
+            WID: permit.WID,
+            txId: permit.txId,
+            spendBlock: permit.spendBlock,
+            spendHeight: permit.spendHeight,
+        });
+    };
+    /**
+     * update an unspent permit in the database
+     * @param permit
+     * @param extractor
+     */
+    updatePermit = async (permit, extractor) => {
+        await this.permitRepository.update({ boxId: permit.boxId, extractor: extractor }, {
+            boxSerialized: permit.boxSerialized,
+            block: permit.block,
+            height: permit.height,
+            WID: permit.WID,
+            txId: permit.txId,
+            spendBlock: null,
+            spendHeight: null,
+        });
+    };
+    /**
+     * It stores list of permits in the dataSource with block id
+     * @param permits
+     * @param block
+     * @param extractor
+     */
+    storePermits = async (permits, block, extractor) => {
+        if (permits.length === 0)
+            return true;
+        const boxIds = permits.map((permit) => permit.boxId);
+        const savedPermits = await this.permitRepository.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(PermitEntity);
+        try {
+            for (const permit of permits) {
+                const saved = savedPermits.some((entity) => {
+                    return entity.boxId === permit.boxId;
+                });
+                const entity = {
+                    boxId: permit.boxId,
+                    boxSerialized: permit.boxSerialized,
+                    block: block.hash,
+                    height: block.height,
+                    extractor: extractor,
+                    WID: permit.WID,
+                    txId: permit.txId,
+                };
+                if (!saved) {
+                    this.logger.debug(`Saving permit [${permit.boxId}] belonging to watcher [${permit.WID}] at height ${block.height} and extractor ${extractor}`);
+                    await repository.insert(entity);
+                }
+                else {
+                    this.logger.debug(`Updating permit [${permit.boxId}] belonging to watcher [${permit.WID}] at height ${block.height} and extractor ${extractor}`);
+                    await repository.update({ boxId: permit.boxId }, entity);
+                }
+                this.logger.debug(`Entity: ${JSON.stringify(entity)}`);
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store permit action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return success;
+    };
+    /**
+     * Update spendBlock and spendHeight of permits spent on the block
+     * @param spendId
+     * @param block
+     * @param extractor
+     */
+    spendPermits = async (spendId, block, extractor) => {
+        const spendIdChunks = chunk(spendId, dbIdChunkSize);
+        for (const spendIdChunk of spendIdChunks) {
+            const updateResult = await this.permitRepository.update({ boxId: In(spendIdChunk), extractor: extractor }, { spendBlock: block.hash, spendHeight: block.height });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const spentRows = await this.permitRepository.findBy({
+                    boxId: In(spendIdChunk),
+                    spendBlock: block.hash,
+                });
+                for (const row of spentRows) {
+                    this.logger.debug(`Spent permit with boxId [${row.boxId}] belonging to watcher with WID [${row.WID}] at height ${block.height}`);
+                }
+            }
+        }
+    };
+    /**
+     * Delete all permits corresponding to the block(id) and extractor(id)
+     * and update all permits spent on the specified block
+     * @param block
+     * @param extractor
+     */
+    deleteBlock = async (block, extractor) => {
+        this.logger.info(`Deleting permits at block ${block} and extractor ${extractor}`);
+        await this.permitRepository.delete({ block: block, extractor: extractor });
+        await this.permitRepository.update({ spendBlock: block, extractor: extractor }, { spendBlock: null, spendHeight: null });
+    };
+    /**
+     *  Returns all stored permit box ids
+     */
+    getAllPermitBoxIds = async (extractor) => {
+        const boxIds = await this.permitRepository.find({
+            where: {
+                extractor: extractor,
+            },
+            select: {
+                boxId: true,
+            },
+        });
+        return boxIds.map((item) => item.boxId);
+    };
+    /**
+     * Removes specified permit
+     * @param boxId
+     * @param extractor
+     */
+    removePermit = async (boxId, extractor) => {
+        return await this.permitRepository.delete({
+            boxId: boxId,
+            extractor: extractor,
+        });
+    };
+    /**
+     * Update the permit spending information
+     * @param boxId
+     * @param extractor
+     * @param blockId
+     * @param blockHeight
+     */
+    updateSpendBlock = async (boxId, extractor, blockId, blockHeight) => {
+        return await this.permitRepository.update({ boxId: boxId, extractor: extractor }, { spendBlock: blockId, spendHeight: blockHeight });
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `PermitEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @param extractorId - Identifier of the extractor
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = (extractorId) => {
+        return this.permitRepository
+            .createQueryBuilder('permitEntity')
+            .select('permitEntity.block', 'block')
+            .where('permitEntity.extractor = :extractorId', { extractorId });
+    };
+}
+export default PermitAction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permitAction.js","sourceRoot":"","sources":["../../lib/actions/permitAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { chunk } from 'lodash-es';\n\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  DataSource,\n  In,\n  Repository,\n  SelectQueryBuilder,\n} from '@rosen-bridge/extended-typeorm';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport { dbIdChunkSize } from '../constants';\nimport PermitEntity from '../entities/permitEntity';\nimport { ExtractedPermit } from '../interfaces/extractedPermit';\n\nclass PermitAction {\n  readonly logger: AbstractLogger;\n  private readonly datasource: DataSource;\n  private readonly permitRepository: Repository<PermitEntity>;\n\n  constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    this.datasource = dataSource;\n    this.logger = logger ? logger : new DummyLogger();\n    this.permitRepository = dataSource.getRepository(PermitEntity);\n  }\n\n  /**\n   * insert a new permit boxes in the database\n   * @param permits\n   * @param initialHeight\n   * @param extractor\n   */\n  insertPermit = async (permit: ExtractedPermit, extractor: string) => {\n    return this.permitRepository.insert({\n      boxId: permit.boxId,\n      boxSerialized: permit.boxSerialized,\n      block: permit.block,\n      height: permit.height,\n      extractor: extractor,\n      WID: permit.WID,\n      txId: permit.txId,\n      spendBlock: permit.spendBlock,\n      spendHeight: permit.spendHeight,\n    });\n  };\n\n  /**\n   * update an unspent permit in the database\n   * @param permit\n   * @param extractor\n   */\n  updatePermit = async (permit: ExtractedPermit, extractor: string) => {\n    await this.permitRepository.update(\n      { boxId: permit.boxId, extractor: extractor },\n      {\n        boxSerialized: permit.boxSerialized,\n        block: permit.block,\n        height: permit.height,\n        WID: permit.WID,\n        txId: permit.txId,\n        spendBlock: null,\n        spendHeight: null,\n      },\n    );\n  };\n\n  /**\n   * It stores list of permits in the dataSource with block id\n   * @param permits\n   * @param block\n   * @param extractor\n   */\n  storePermits = async (\n    permits: Array<ExtractedPermit>,\n    block: BlockInfo,\n    extractor: string,\n  ) => {\n    if (permits.length === 0) return true;\n    const boxIds = permits.map((permit) => permit.boxId);\n    const savedPermits = await this.permitRepository.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(PermitEntity);\n    try {\n      for (const permit of permits) {\n        const saved = savedPermits.some((entity) => {\n          return entity.boxId === permit.boxId;\n        });\n        const entity = {\n          boxId: permit.boxId,\n          boxSerialized: permit.boxSerialized,\n          block: block.hash,\n          height: block.height,\n          extractor: extractor,\n          WID: permit.WID,\n          txId: permit.txId,\n        };\n        if (!saved) {\n          this.logger.debug(\n            `Saving permit [${permit.boxId}] belonging to watcher [${permit.WID}] at height ${block.height} and extractor ${extractor}`,\n          );\n          await repository.insert(entity);\n        } else {\n          this.logger.debug(\n            `Updating permit [${permit.boxId}] belonging to watcher [${permit.WID}] at height ${block.height} and extractor ${extractor}`,\n          );\n          await repository.update({ boxId: permit.boxId }, entity);\n        }\n        this.logger.debug(`Entity: ${JSON.stringify(entity)}`);\n      }\n      await queryRunner.commitTransaction();\n    } catch (e) {\n      this.logger.error(`An error occurred during store permit action: ${e}`);\n      await queryRunner.rollbackTransaction();\n      success = false;\n    } finally {\n      await queryRunner.release();\n    }\n    return success;\n  };\n\n  /**\n   * Update spendBlock and spendHeight of permits spent on the block\n   * @param spendId\n   * @param block\n   * @param extractor\n   */\n  spendPermits = async (\n    spendId: Array<string>,\n    block: BlockInfo,\n    extractor: string,\n  ): Promise<void> => {\n    const spendIdChunks = chunk(spendId, dbIdChunkSize);\n    for (const spendIdChunk of spendIdChunks) {\n      const updateResult = await this.permitRepository.update(\n        { boxId: In(spendIdChunk), extractor: extractor },\n        { spendBlock: block.hash, spendHeight: block.height },\n      );\n\n      if (updateResult.affected && updateResult.affected > 0) {\n        const spentRows = await this.permitRepository.findBy({\n          boxId: In(spendIdChunk),\n          spendBlock: block.hash,\n        });\n        for (const row of spentRows) {\n          this.logger.debug(\n            `Spent permit with boxId [${row.boxId}] belonging to watcher with WID [${row.WID}] at height ${block.height}`,\n          );\n        }\n      }\n    }\n  };\n\n  /**\n   * Delete all permits corresponding to the block(id) and extractor(id)\n   * and update all permits spent on the specified block\n   * @param block\n   * @param extractor\n   */\n  deleteBlock = async (block: string, extractor: string): Promise<void> => {\n    this.logger.info(\n      `Deleting permits at block ${block} and extractor ${extractor}`,\n    );\n    await this.permitRepository.delete({ block: block, extractor: extractor });\n    await this.permitRepository.update(\n      { spendBlock: block, extractor: extractor },\n      { spendBlock: null, spendHeight: null },\n    );\n  };\n\n  /**\n   *  Returns all stored permit box ids\n   */\n  getAllPermitBoxIds = async (extractor: string): Promise<Array<string>> => {\n    const boxIds = await this.permitRepository.find({\n      where: {\n        extractor: extractor,\n      },\n      select: {\n        boxId: true,\n      },\n    });\n    return boxIds.map((item: { boxId: string }) => item.boxId);\n  };\n\n  /**\n   * Removes specified permit\n   * @param boxId\n   * @param extractor\n   */\n  removePermit = async (boxId: string, extractor: string) => {\n    return await this.permitRepository.delete({\n      boxId: boxId,\n      extractor: extractor,\n    });\n  };\n\n  /**\n   * Update the permit 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.permitRepository.update(\n      { boxId: boxId, extractor: extractor },\n      { spendBlock: blockId, spendHeight: blockHeight },\n    );\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `PermitEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @param extractorId - Identifier of the extractor\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (\n    extractorId: string,\n  ): SelectQueryBuilder<PermitEntity> => {\n    return this.permitRepository\n      .createQueryBuilder('permitEntity')\n      .select('permitEntity.block', 'block')\n      .where('permitEntity.extractor = :extractorId', { extractorId });\n  };\n}\n\nexport default PermitAction;\n"]}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+declare const dbIdChunkSize = 100;
+declare const DefaultApiLimit = 100;
+export { dbIdChunkSize, DefaultApiLimit };
+//# 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,aAAa,MAAM,CAAC;AAC1B,QAAA,MAAM,eAAe,MAAM,CAAC;AAE5B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC"}

package/dist/constants.js

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

package/dist/entities/collateralEntity.d.ts

@@ -0,0 +1,8 @@
+import { AbstractErgoBoxEntity } from '@rosen-bridge/abstract-extractor';
+declare class CollateralEntity extends AbstractErgoBoxEntity {
+    txId: string;
+    wid: string;
+    rwtCount: bigint;
+}
+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":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAIzE,cACM,gBAAiB,SAAQ,qBAAqB;IAElD,IAAI,EAAE,MAAM,CAAC;IAGb,GAAG,EAAE,MAAM,CAAC;IAGZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAe,gBAAgB,CAAC"}