@rosen-bridge/watcher-data-extractor 8.0.2 → 9.0.0

package/dist/actions/EventTriggerAction.d.ts

@@ -1,38 +1,41 @@
 import { DataSource } from 'typeorm';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { Block } from '@rosen-bridge/abstract-extractor';
+import { AbstractInitializableErgoExtractorAction, BlockInfo, SpendInfo } from '@rosen-bridge/abstract-extractor';
 import { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';
-declare class EventTriggerAction {
+declare class EventTriggerAction extends AbstractInitializableErgoExtractorAction<ExtractedEventTrigger> {
     readonly logger: AbstractLogger;
-    private readonly datasource;
-    private readonly triggerEventRepository;
+    private readonly dataSource;
+    private readonly repository;
     constructor(dataSource: DataSource, logger?: AbstractLogger);
     /**
-     * It stores list of eventTriggers in the dataSource with block id
+     * insert all extracted eventTriggers for a block in an atomic db transaction
      * @param eventTriggers
      * @param block
-     * @param extractor
+     * @param extractorId
      */
-    storeEventTriggers: (eventTriggers: Array<ExtractedEventTrigger>, block: Block, extractor: string) => Promise<boolean>;
+    insertBoxes: (eventTriggers: Array<ExtractedEventTrigger>, block: BlockInfo, extractorId: string) => Promise<boolean>;
     /**
-     * Update spendBlock and spendHeight of eventTriggers spent on the block
-     * also update the spendTxId with the specified txId
+     * update spending information of stored event triggers
      * and set result and paymentTxId of the event
-     * @param spendId
+     * chunk spendInfos to prevent large database queries
+     * @param spendInfArray
      * @param block
-     * @param extractor
-     * @param txId
-     * @param result
-     * @param paymentTxId
+     * @param extractorId
+     */
+    spendBoxes: (spendInfoArray: Array<SpendInfo>, block: BlockInfo, extractorId: string) => Promise<void>;
+    /**
+     * remove all existing data for the extractor
+     * @param extractorId
      */
-    spendEventTriggers: (spendId: Array<string>, block: Block, extractor: string, txId: string, result: string, paymentTxId: string) => Promise<void>;
+    removeAllData: (extractorId: string) => Promise<void>;
     /**
-     * Delete all eventTriggers corresponding to the block(id) and extractor(id)
-     * and update all eventTriggers spent on the specified block
+     * delete extracted data from a specific block for specified extractor
+     * if a box is spend in this block mark it as unspent
+     * if a box is created in this block remove it from database
      * @param block
      * @param extractor
      */
-    deleteBlock: (block: string, extractor: string) => Promise<void>;
+    deleteBlockBoxes: (block: string, extractor: string) => Promise<void>;
 }
 export default EventTriggerAction;
 //# sourceMappingURL=EventTriggerAction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"EventTriggerAction.d.ts","sourceRoot":"","sources":["../../lib/actions/EventTriggerAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,SAAS,CAAC;AAErD,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAGzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAG5E,cAAM,kBAAkB;IACtB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAiC;gBAE5D,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,cAAc;IAM3D;;;;;OAKG;IACH,kBAAkB,kBACD,MAAM,qBAAqB,CAAC,SACpC,KAAK,aACD,MAAM,sBAmEjB;IAEF;;;;;;;;;;OAUG;IACH,kBAAkB,YACP,MAAM,MAAM,CAAC,SACf,KAAK,aACD,MAAM,QACX,MAAM,UACJ,MAAM,eACD,MAAM,KAClB,QAAQ,IAAI,CAAC,CA2Bd;IAEF;;;;;OAKG;IACH,WAAW,UAAiB,MAAM,aAAa,MAAM,mBAkBnD;CACH;AAED,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"EventTriggerAction.d.ts","sourceRoot":"","sources":["../../lib/actions/EventTriggerAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,SAAS,CAAC;AACrD,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,wCAAwC,EACxC,SAAS,EAET,SAAS,EACV,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAI5E,cAAM,kBAAmB,SAAQ,wCAAwC,CAAC,qBAAqB,CAAC;IAC9F,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;gBAEhD,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,cAAc;IAO3D;;;;;OAKG;IACH,WAAW,kBACM,MAAM,qBAAqB,CAAC,SACpC,SAAS,eACH,MAAM,sBAmEnB;IAEF;;;;;;;OAOG;IACH,UAAU,mBACQ,MAAM,SAAS,CAAC,SACzB,SAAS,eACH,MAAM,KAClB,QAAQ,IAAI,CAAC,CAoCd;IAEF;;;OAGG;IACH,aAAa,gBAAuB,MAAM,mBAExC;IAEF;;;;;;OAMG;IACH,gBAAgB,UAAiB,MAAM,aAAa,MAAM,mBAkBxD;CACH;AAED,eAAe,kBAAkB,CAAC"}

package/dist/actions/EventTriggerAction.js

@@ -1,33 +1,35 @@
 import { In } from 'typeorm';
-import { chunk } from 'lodash-es';
 import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractInitializableErgoExtractorAction, DB_CHUNK_SIZE, } from '@rosen-bridge/abstract-extractor';
 import EventTriggerEntity from '../entities/EventTriggerEntity';
-import { dbIdChunkSize } from '../constants';
-class EventTriggerAction {
+import { JsonBI } from '../utils';
+import { chunk } from 'lodash-es';
+class EventTriggerAction extends AbstractInitializableErgoExtractorAction {
     logger;
-    datasource;
-    triggerEventRepository;
+    dataSource;
+    repository;
     constructor(dataSource, logger) {
-        this.datasource = dataSource;
+        super();
+        this.dataSource = dataSource;
         this.logger = logger ? logger : new DummyLogger();
-        this.triggerEventRepository = dataSource.getRepository(EventTriggerEntity);
+        this.repository = dataSource.getRepository(EventTriggerEntity);
     }
     /**
-     * It stores list of eventTriggers in the dataSource with block id
+     * insert all extracted eventTriggers for a block in an atomic db transaction
      * @param eventTriggers
      * @param block
-     * @param extractor
+     * @param extractorId
      */
-    storeEventTriggers = async (eventTriggers, block, extractor) => {
+    insertBoxes = async (eventTriggers, block, extractorId) => {
         if (eventTriggers.length === 0)
             return true;
         const boxIds = eventTriggers.map((trigger) => trigger.boxId);
-        const savedTriggers = await this.triggerEventRepository.findBy({
+        const savedTriggers = await this.repository.findBy({
             boxId: In(boxIds),
-            extractor: extractor,
+            extractor: extractorId,
         });
         let success = true;
-        const queryRunner = this.datasource.createQueryRunner();
+        const queryRunner = this.dataSource.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
         const repository = await queryRunner.manager.getRepository(EventTriggerEntity);
@@ -43,7 +45,7 @@ class EventTriggerAction {
                     boxSerialized: trigger.boxSerialized,
                     block: block.hash,
                     height: block.height,
-                    extractor: extractor,
+                    extractor: extractorId,
                     WIDsCount: trigger.WIDsCount,
                     WIDsHash: trigger.WIDsHash,
                     amount: trigger.amount,
@@ -60,11 +62,11 @@ class EventTriggerAction {
                     sourceChainHeight: trigger.sourceChainHeight,
                 };
                 if (!saved) {
-                    this.logger.info(`Storing event trigger [${trigger.boxId}] for event [${trigger.eventId}] at height ${block.height} and extractor ${extractor}`);
+                    this.logger.info(`Storing event trigger [${trigger.boxId}] for event [${trigger.eventId}] at height ${block.height} and extractor ${extractorId}`);
                     await repository.insert(entity);
                 }
                 else {
-                    this.logger.info(`Updating event trigger ${trigger.boxId} for event [${trigger.eventId}] at height ${block.height} and extractor ${extractor}`);
+                    this.logger.info(`Updating event trigger ${trigger.boxId} for event [${trigger.eventId}] at height ${block.height} and extractor ${extractorId}`);
                     await repository.update({ boxId: trigger.boxId }, entity);
                 }
                 this.logger.debug(`Entity: ${JSON.stringify(entity)}`);
@@ -82,51 +84,58 @@ class EventTriggerAction {
         return success;
     };
     /**
-     * Update spendBlock and spendHeight of eventTriggers spent on the block
-     * also update the spendTxId with the specified txId
+     * update spending information of stored event triggers
      * and set result and paymentTxId of the event
-     * @param spendId
+     * chunk spendInfos to prevent large database queries
+     * @param spendInfArray
      * @param block
-     * @param extractor
-     * @param txId
-     * @param result
-     * @param paymentTxId
+     * @param extractorId
      */
-    spendEventTriggers = async (spendId, block, extractor, txId, result, paymentTxId) => {
-        const spendIdChunks = chunk(spendId, dbIdChunkSize);
-        for (const spendIdChunk of spendIdChunks) {
-            const updateResult = await this.triggerEventRepository.update({ boxId: In(spendIdChunk), extractor: extractor }, {
-                spendBlock: block.hash,
-                spendHeight: block.height,
-                spendTxId: txId,
-                result: result,
-                paymentTxId: paymentTxId,
+    spendBoxes = async (spendInfoArray, block, extractorId) => {
+        const spendInfoChunks = chunk(spendInfoArray, DB_CHUNK_SIZE);
+        for (const spendInfoChunk of spendInfoChunks) {
+            const spentTriggers = await this.repository.findBy({
+                boxId: In(spendInfoChunk.map((spendInfo) => spendInfo.boxId)),
+                extractor: extractorId,
             });
-            if (updateResult.affected && updateResult.affected > 0) {
-                const spentRows = await this.triggerEventRepository.findBy({
-                    boxId: In(spendIdChunk),
+            for (const spentTrigger of spentTriggers) {
+                const spendInfo = spendInfoChunk.find((info) => info.boxId === spentTrigger.boxId);
+                if (!spendInfo || !spendInfo.extras || spendInfo.extras.length < 2) {
+                    throw Error(`Impossible case: spending information extras does not contain result or paymentTxId, ${spendInfo}`);
+                }
+                await this.repository.update({ boxId: spendInfo.boxId, extractor: extractorId }, {
                     spendBlock: block.hash,
+                    spendHeight: block.height,
+                    spendTxId: spendInfo.txId,
+                    result: spendInfo.extras[0],
+                    paymentTxId: spendInfo.extras[1],
                 });
-                for (const row of spentRows) {
-                    this.logger.info(`Spent trigger [${row.boxId}] of event [${row.eventId}] at height ${block.height}`);
-                    this.logger.debug(`Spent trigger: [${JSON.stringify(row)}]`);
-                }
+                this.logger.info(`Spent trigger [${spentTrigger.boxId}] of event [${spentTrigger.eventId}] at height ${block.height}`);
+                this.logger.debug(`Spent trigger: [${JSON.stringify(spentTrigger)}] with spending information [${JsonBI.stringify(spendInfo)}]`);
             }
         }
     };
     /**
-     * Delete all eventTriggers corresponding to the block(id) and extractor(id)
-     * and update all eventTriggers spent on the specified block
+     * remove all existing data for the extractor
+     * @param extractorId
+     */
+    removeAllData = async (extractorId) => {
+        await this.repository.delete({ extractor: extractorId });
+    };
+    /**
+     * delete extracted data from a specific block for specified extractor
+     * if a box is spend in this block mark it as unspent
+     * if a box is created in this block remove it from database
      * @param block
      * @param extractor
      */
-    deleteBlock = async (block, extractor) => {
+    deleteBlockBoxes = async (block, extractor) => {
         this.logger.info(`Deleting event triggers at block ${block} and extractor ${extractor}`);
-        await this.triggerEventRepository.delete({
+        await this.repository.delete({
             block: block,
             extractor: extractor,
         });
-        await this.triggerEventRepository.update({ spendBlock: block, extractor: extractor }, {
+        await this.repository.update({ spendBlock: block, extractor: extractor }, {
             spendBlock: null,
             spendTxId: null,
             spendHeight: null,
@@ -136,4 +145,4 @@ class EventTriggerAction {
     };
 }
 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 { DataSource, In, Repository } from 'typeorm';\nimport { chunk } from 'lodash-es';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { Block } from '@rosen-bridge/abstract-extractor';\n\nimport EventTriggerEntity from '../entities/EventTriggerEntity';\nimport { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';\nimport { dbIdChunkSize } from '../constants';\n\nclass EventTriggerAction {\n  readonly logger: AbstractLogger;\n  private readonly datasource: DataSource;\n  private readonly triggerEventRepository: Repository<EventTriggerEntity>;\n\n  constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    this.datasource = dataSource;\n    this.logger = logger ? logger : new DummyLogger();\n    this.triggerEventRepository = dataSource.getRepository(EventTriggerEntity);\n  }\n\n  /**\n   * It stores list of eventTriggers in the dataSource with block id\n   * @param eventTriggers\n   * @param block\n   * @param extractor\n   */\n  storeEventTriggers = async (\n    eventTriggers: Array<ExtractedEventTrigger>,\n    block: Block,\n    extractor: string\n  ) => {\n    if (eventTriggers.length === 0) return true;\n    const boxIds = eventTriggers.map((trigger) => trigger.boxId);\n    const savedTriggers = await this.triggerEventRepository.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(\n      EventTriggerEntity\n    );\n    try {\n      for (const trigger of eventTriggers) {\n        const saved = savedTriggers.some((entity) => {\n          return entity.boxId === trigger.boxId;\n        });\n        const entity = {\n          txId: trigger.txId,\n          eventId: trigger.eventId,\n          boxId: trigger.boxId,\n          boxSerialized: trigger.boxSerialized,\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        if (!saved) {\n          this.logger.info(\n            `Storing event trigger [${trigger.boxId}] for event [${trigger.eventId}] at height ${block.height} and extractor ${extractor}`\n          );\n          await repository.insert(entity);\n        } else {\n          this.logger.info(\n            `Updating event trigger ${trigger.boxId} for event [${trigger.eventId}] at height ${block.height} and extractor ${extractor}`\n          );\n          await repository.update({ boxId: trigger.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 eventTrigger 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 eventTriggers spent on the block\n   * also update the spendTxId with the specified txId\n   * and set result and paymentTxId of the event\n   * @param spendId\n   * @param block\n   * @param extractor\n   * @param txId\n   * @param result\n   * @param paymentTxId\n   */\n  spendEventTriggers = async (\n    spendId: Array<string>,\n    block: Block,\n    extractor: string,\n    txId: string,\n    result: string,\n    paymentTxId: string\n  ): Promise<void> => {\n    const spendIdChunks = chunk(spendId, dbIdChunkSize);\n    for (const spendIdChunk of spendIdChunks) {\n      const updateResult = await this.triggerEventRepository.update(\n        { boxId: In(spendIdChunk), extractor: extractor },\n        {\n          spendBlock: block.hash,\n          spendHeight: block.height,\n          spendTxId: txId,\n          result: result,\n          paymentTxId: paymentTxId,\n        }\n      );\n\n      if (updateResult.affected && updateResult.affected > 0) {\n        const spentRows = await this.triggerEventRepository.findBy({\n          boxId: In(spendIdChunk),\n          spendBlock: block.hash,\n        });\n        for (const row of spentRows) {\n          this.logger.info(\n            `Spent trigger [${row.boxId}] of event [${row.eventId}] at height ${block.height}`\n          );\n          this.logger.debug(`Spent trigger: [${JSON.stringify(row)}]`);\n        }\n      }\n    }\n  };\n\n  /**\n   * Delete all eventTriggers corresponding to the block(id) and extractor(id)\n   * and update all eventTriggers 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 event triggers at block ${block} and extractor ${extractor}`\n    );\n    await this.triggerEventRepository.delete({\n      block: block,\n      extractor: extractor,\n    });\n    await this.triggerEventRepository.update(\n      { spendBlock: block, extractor: extractor },\n      {\n        spendBlock: null,\n        spendTxId: null,\n        spendHeight: null,\n        result: null,\n        paymentTxId: null,\n      }\n    );\n  };\n}\n\nexport default EventTriggerAction;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventTriggerAction.js","sourceRoot":"","sources":["../../lib/actions/EventTriggerAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, In, Repository } from 'typeorm';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  AbstractInitializableErgoExtractorAction,\n  BlockInfo,\n  DB_CHUNK_SIZE,\n  SpendInfo,\n} from '@rosen-bridge/abstract-extractor';\n\nimport EventTriggerEntity from '../entities/EventTriggerEntity';\nimport { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';\nimport { JsonBI } from '../utils';\nimport { chunk } from 'lodash-es';\n\nclass EventTriggerAction extends AbstractInitializableErgoExtractorAction<ExtractedEventTrigger> {\n  readonly logger: AbstractLogger;\n  private readonly dataSource: DataSource;\n  private readonly repository: Repository<EventTriggerEntity>;\n\n  constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    super();\n    this.dataSource = dataSource;\n    this.logger = logger ? logger : new DummyLogger();\n    this.repository = dataSource.getRepository(EventTriggerEntity);\n  }\n\n  /**\n   * insert all extracted eventTriggers for a block in an atomic db transaction\n   * @param eventTriggers\n   * @param block\n   * @param extractorId\n   */\n  insertBoxes = async (\n    eventTriggers: Array<ExtractedEventTrigger>,\n    block: BlockInfo,\n    extractorId: string\n  ) => {\n    if (eventTriggers.length === 0) return true;\n    const boxIds = eventTriggers.map((trigger) => trigger.boxId);\n    const savedTriggers = await this.repository.findBy({\n      boxId: In(boxIds),\n      extractor: extractorId,\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(\n      EventTriggerEntity\n    );\n    try {\n      for (const trigger of eventTriggers) {\n        const saved = savedTriggers.some((entity) => {\n          return entity.boxId === trigger.boxId;\n        });\n        const entity = {\n          txId: trigger.txId,\n          eventId: trigger.eventId,\n          boxId: trigger.boxId,\n          boxSerialized: trigger.boxSerialized,\n          block: block.hash,\n          height: block.height,\n          extractor: extractorId,\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        if (!saved) {\n          this.logger.info(\n            `Storing event trigger [${trigger.boxId}] for event [${trigger.eventId}] at height ${block.height} and extractor ${extractorId}`\n          );\n          await repository.insert(entity);\n        } else {\n          this.logger.info(\n            `Updating event trigger ${trigger.boxId} for event [${trigger.eventId}] at height ${block.height} and extractor ${extractorId}`\n          );\n          await repository.update({ boxId: trigger.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 eventTrigger 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 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   */\n  spendBoxes = async (\n    spendInfoArray: Array<SpendInfo>,\n    block: BlockInfo,\n    extractorId: string\n  ): Promise<void> => {\n    const spendInfoChunks = chunk(spendInfoArray, DB_CHUNK_SIZE);\n    for (const spendInfoChunk of spendInfoChunks) {\n      const spentTriggers = await this.repository.findBy({\n        boxId: 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.boxId\n        );\n        if (!spendInfo || !spendInfo.extras || spendInfo.extras.length < 2) {\n          throw Error(\n            `Impossible case: spending information extras does not contain result or paymentTxId, ${spendInfo}`\n          );\n        }\n        await this.repository.update(\n          { boxId: spendInfo.boxId, extractor: extractorId },\n          {\n            spendBlock: block.hash,\n            spendHeight: block.height,\n            spendTxId: spendInfo.txId,\n            result: spendInfo.extras[0],\n            paymentTxId: spendInfo.extras[1],\n          }\n        );\n        this.logger.info(\n          `Spent trigger [${spentTrigger.boxId}] 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  };\n\n  /**\n   * remove all existing data for the extractor\n   * @param extractorId\n   */\n  removeAllData = async (extractorId: string) => {\n    await this.repository.delete({ extractor: extractorId });\n  };\n\n  /**\n   * delete extracted data from a specific block for specified extractor\n   * if a box is spend in this block mark it as unspent\n   * if a box is created in this block remove it from database\n   * @param block\n   * @param extractor\n   */\n  deleteBlockBoxes = async (block: string, extractor: string) => {\n    this.logger.info(\n      `Deleting event triggers at block ${block} and extractor ${extractor}`\n    );\n    await this.repository.delete({\n      block: block,\n      extractor: extractor,\n    });\n    await this.repository.update(\n      { spendBlock: block, extractor: extractor },\n      {\n        spendBlock: null,\n        spendTxId: null,\n        spendHeight: null,\n        result: null,\n        paymentTxId: null,\n      }\n    );\n  };\n}\n\nexport default EventTriggerAction;\n"]}

package/dist/extractor/EventTriggerExtractor.d.ts

@@ -1,32 +1,46 @@
 import { DataSource } from 'typeorm';
 import { Transaction } from '@rosen-bridge/scanner';
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { AbstractExtractor, Block } from '@rosen-bridge/abstract-extractor';
+import { AbstractInitializableErgoExtractor, BlockInfo, ErgoNetworkType, OutputBox } from '@rosen-bridge/abstract-extractor';
+import EventTriggerAction from '../actions/EventTriggerAction';
+import { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';
 import { EventResult } from '../types';
-declare class EventTriggerExtractor extends AbstractExtractor<Transaction> {
-    readonly logger: AbstractLogger;
+declare class EventTriggerExtractor extends AbstractInitializableErgoExtractor<ExtractedEventTrigger> {
     id: string;
-    private readonly dataSource;
-    private readonly actions;
+    protected readonly actions: EventTriggerAction;
     private readonly eventTriggerErgoTree;
     private readonly permitErgoTree;
     private readonly fraudErgoTree;
     private readonly RWT;
-    constructor(id: string, dataSource: DataSource, address: string, RWT: string, permitAddress: string, fraudAddress: string, logger?: AbstractLogger);
+    constructor(id: string, dataSource: DataSource, type: ErgoNetworkType, url: string, address: string, RWT: string, permitAddress: string, fraudAddress: string, logger?: AbstractLogger);
+    /**
+     * get Id for current extractor
+     */
     getId: () => string;
+    /**
+     * check proper data format in the box
+     *  - box ergoTree
+     *  - RWT in first token place
+     *  - widListHash in R4
+     *  - event data in R5
+     *  - widCount in R7
+     * @param box
+     * @return true if the box has the required data and false otherwise
+     */
+    hasData: (box: OutputBox) => boolean;
+    /**
+     * extract box data to proper format (not including spending information)
+     * @param box
+     * @return extracted data in proper format
+     */
+    extractBoxData: (box: OutputBox) => Omit<ExtractedEventTrigger, 'spendBlock' | 'spendHeight'> | undefined;
     /**
      * gets block id and transactions corresponding to the block and saves if they are valid rosen
      *  transactions and in case of success return true and in case of failure returns false
      * @param block
      * @param txs
      */
-    processTransactions: (txs: Array<Transaction>, block: Block) => Promise<boolean>;
-    forkBlock: (hash: string) => Promise<void>;
-    /**
-     * Extractor box initialization
-     * No action needed in event trigger extractors
-     */
-    initializeBoxes: () => Promise<void>;
+    processTransactions: (txs: Array<Transaction>, block: BlockInfo) => Promise<boolean>;
     /**
      * extracts result and paymentTxId from a transaction
      * returns 'unknown' as result when tx is neither fraud or successful

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

@@ -1 +1 @@
-{"version":3,"file":"EventTriggerExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/EventTriggerExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAK5E,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,cAAM,qBAAsB,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IAChE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAG3B,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,cAAc;IAmBzB,KAAK,eAAiB;IAEtB;;;;;OAKG;IACH,mBAAmB,QACZ,MAAM,WAAW,CAAC,SAChB,KAAK,KACX,QAAQ,OAAO,CAAC,CAsIjB;IAEF,SAAS,SAAgB,MAAM,mBAE7B;IAEF;;;OAGG;IACH,eAAe,sBAEb;IAEF;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,gBAAiB,WAAW;;;MA0CtD;CACH;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"EventTriggerExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/EventTriggerExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,kCAAkC,EAClC,SAAS,EACT,eAAe,EACf,SAAS,EAEV,MAAM,kCAAkC,CAAC;AAE1C,OAAO,kBAAkB,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAE5E,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,cAAM,qBAAsB,SAAQ,kCAAkC,CAAC,qBAAqB,CAAC;IAC3F,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IAC/C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAG3B,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,cAAc;IAiBzB;;OAEG;IACH,KAAK,eAAiB;IAEtB;;;;;;;;;OASG;IACH,OAAO,QAAS,SAAS,KAAG,OAAO,CA8BjC;IAEF;;;;OAIG;IACH,cAAc,QACP,SAAS,KACb,KAAK,qBAAqB,EAAE,YAAY,GAAG,aAAa,CAAC,GAAG,SAAS,CAwDtE;IAEF;;;;;OAKG;IACH,mBAAmB,QACZ,MAAM,WAAW,CAAC,SAChB,SAAS,KACf,QAAQ,OAAO,CAAC,CA2CjB;IAEF;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,gBAAiB,WAAW;;;MA0CtD;CACH;AAED,eAAe,qBAAqB,CAAC"}

package/dist/extractor/EventTriggerExtractor.js

@@ -1,23 +1,19 @@
 import * as wasm from 'ergo-lib-wasm-nodejs';
 import { blake2b } from 'blakejs';
-import { DummyLogger } from '@rosen-bridge/abstract-logger';
-import { AbstractExtractor } from '@rosen-bridge/abstract-extractor';
+import { AbstractInitializableErgoExtractor, } from '@rosen-bridge/abstract-extractor';
 import EventTriggerAction from '../actions/EventTriggerAction';
 import { JsonBI } from '../utils';
 import { EventResult } from '../types';
-class EventTriggerExtractor extends AbstractExtractor {
-    logger;
+class EventTriggerExtractor extends AbstractInitializableErgoExtractor {
     id;
-    dataSource;
     actions;
     eventTriggerErgoTree;
     permitErgoTree;
     fraudErgoTree;
     RWT;
-    constructor(id, dataSource, address, RWT, permitAddress, fraudAddress, logger) {
-        super();
+    constructor(id, dataSource, type, url, address, RWT, permitAddress, fraudAddress, logger) {
+        super(type, url, address, logger);
         this.id = id;
-        this.dataSource = dataSource;
         this.eventTriggerErgoTree = wasm.Address.from_base58(address)
             .to_ergo_tree()
             .to_base16_bytes();
@@ -28,115 +24,139 @@ class EventTriggerExtractor extends AbstractExtractor {
             .to_ergo_tree()
             .to_base16_bytes();
         this.RWT = RWT;
-        this.logger = logger ? logger : new DummyLogger();
         this.actions = new EventTriggerAction(dataSource, this.logger);
     }
+    /**
+     * get Id for current extractor
+     */
     getId = () => this.id;
+    /**
+     * check proper data format in the box
+     *  - box ergoTree
+     *  - RWT in first token place
+     *  - widListHash in R4
+     *  - event data in R5
+     *  - widCount in R7
+     * @param box
+     * @return true if the box has the required data and false otherwise
+     */
+    hasData = (box) => {
+        try {
+            const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));
+            if (box.additionalRegisters &&
+                box.additionalRegisters.R4 &&
+                box.additionalRegisters.R5 &&
+                box.additionalRegisters.R7 &&
+                parsedBox.register_value(wasm.NonMandatoryRegisterId.R4) &&
+                parsedBox.register_value(wasm.NonMandatoryRegisterId.R5) &&
+                parsedBox.register_value(wasm.NonMandatoryRegisterId.R7) &&
+                box.assets &&
+                box.assets.length > 0 &&
+                box.assets[0].tokenId === this.RWT &&
+                box.ergoTree === this.eventTriggerErgoTree) {
+                const R4Serialized = parsedBox
+                    .register_value(wasm.NonMandatoryRegisterId.R4)
+                    .to_byte_array();
+                const R5Serialized = parsedBox
+                    .register_value(wasm.NonMandatoryRegisterId.R5)
+                    .to_coll_coll_byte();
+                if (R4Serialized.length >= 1 && R5Serialized.length >= 12)
+                    return true;
+            }
+        }
+        catch (e) {
+            this.logger.warn(`Unexpected error occurred while checking the proper trigger data format for box ${box.boxId}: ${e}`);
+        }
+        return false;
+    };
+    /**
+     * extract box data to proper format (not including spending information)
+     * @param box
+     * @return extracted data in proper format
+     */
+    extractBoxData = (box) => {
+        try {
+            const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));
+            const R4Serialized = parsedBox
+                .register_value(wasm.NonMandatoryRegisterId.R4)
+                .to_byte_array();
+            const R5Serialized = parsedBox
+                .register_value(wasm.NonMandatoryRegisterId.R5)
+                .to_coll_coll_byte();
+            const WIDsCount = parsedBox
+                .register_value(wasm.NonMandatoryRegisterId.R7)
+                .to_i32();
+            const WIDsHash = Buffer.from(R4Serialized).toString('hex');
+            const sourceTxId = Buffer.from(R5Serialized[0]).toString();
+            const eventId = Buffer.from(blake2b(sourceTxId, undefined, 32)).toString('hex');
+            return {
+                eventId: eventId,
+                txId: box.transactionId,
+                boxId: box.boxId,
+                boxSerialized: Buffer.from(parsedBox.sigma_serialize_bytes()).toString('base64'),
+                toChain: Buffer.from(R5Serialized[2]).toString(),
+                toAddress: Buffer.from(R5Serialized[4]).toString(),
+                networkFee: BigInt('0x' + Buffer.from(R5Serialized[7]).toString('hex')).toString(10),
+                bridgeFee: BigInt('0x' + Buffer.from(R5Serialized[6]).toString('hex')).toString(10),
+                amount: BigInt('0x' + Buffer.from(R5Serialized[5]).toString('hex')).toString(10),
+                sourceChainTokenId: Buffer.from(R5Serialized[8]).toString(),
+                targetChainTokenId: Buffer.from(R5Serialized[9]).toString(),
+                sourceTxId: sourceTxId,
+                fromChain: Buffer.from(R5Serialized[1]).toString(),
+                fromAddress: Buffer.from(R5Serialized[3]).toString(),
+                sourceBlockId: Buffer.from(R5Serialized[10]).toString(),
+                WIDsCount: WIDsCount,
+                WIDsHash: WIDsHash,
+                sourceChainHeight: Number(BigInt('0x' + Buffer.from(R5Serialized[11]).toString('hex')).toString(10)),
+            };
+        }
+        catch (e) {
+            this.logger.warn(`Unexpected error occurred while extracting trigger data for box ${box.boxId}: ${e}`);
+            return undefined;
+        }
+    };
     /**
      * gets block id and transactions corresponding to the block and saves if they are valid rosen
      *  transactions and in case of success return true and in case of failure returns false
      * @param block
      * @param txs
      */
-    processTransactions = (txs, block) => {
-        return new Promise((resolve, reject) => {
-            try {
-                const boxes = [];
-                const txSpendIds = [];
-                txs.forEach((transaction) => {
-                    // extract event result
-                    const { result, paymentTxId } = this.extractEventResult(transaction);
-                    for (const output of transaction.outputs) {
-                        try {
-                            if (output.additionalRegisters &&
-                                output.assets &&
-                                output.assets.length > 0 &&
-                                output.assets[0].tokenId === this.RWT &&
-                                output.ergoTree === this.eventTriggerErgoTree) {
-                                const R4 = output.additionalRegisters.R4;
-                                const R5 = output.additionalRegisters.R5;
-                                const R7 = output.additionalRegisters.R7;
-                                if (R4 && R5 && R7) {
-                                    const outputParsed = wasm.ErgoBox.from_json(JsonBI.stringify(output));
-                                    const R4Const = outputParsed.register_value(wasm.NonMandatoryRegisterId.R4);
-                                    const R5Const = outputParsed.register_value(wasm.NonMandatoryRegisterId.R5);
-                                    const R7Const = outputParsed.register_value(wasm.NonMandatoryRegisterId.R7);
-                                    if (R4Const && R5Const && R7Const) {
-                                        const R4Serialized = R4Const.to_byte_array();
-                                        const R5Serialized = R5Const.to_coll_coll_byte();
-                                        if (R4Serialized.length >= 1 && R5Serialized.length >= 12) {
-                                            const WIDsCount = R7Const.to_i32();
-                                            const WIDsHash = Buffer.from(R4Serialized).toString('hex');
-                                            const sourceTxId = Buffer.from(R5Serialized[0]).toString();
-                                            const eventId = Buffer.from(blake2b(sourceTxId, undefined, 32)).toString('hex');
-                                            boxes.push({
-                                                eventId: eventId,
-                                                txId: transaction.id,
-                                                boxId: output.boxId,
-                                                boxSerialized: Buffer.from(outputParsed.sigma_serialize_bytes()).toString('base64'),
-                                                toChain: Buffer.from(R5Serialized[2]).toString(),
-                                                toAddress: Buffer.from(R5Serialized[4]).toString(),
-                                                networkFee: BigInt('0x' + Buffer.from(R5Serialized[7]).toString('hex')).toString(10),
-                                                bridgeFee: BigInt('0x' + Buffer.from(R5Serialized[6]).toString('hex')).toString(10),
-                                                amount: BigInt('0x' + Buffer.from(R5Serialized[5]).toString('hex')).toString(10),
-                                                sourceChainTokenId: Buffer.from(R5Serialized[8]).toString(),
-                                                targetChainTokenId: Buffer.from(R5Serialized[9]).toString(),
-                                                sourceTxId: sourceTxId,
-                                                fromChain: Buffer.from(R5Serialized[1]).toString(),
-                                                fromAddress: Buffer.from(R5Serialized[3]).toString(),
-                                                sourceBlockId: Buffer.from(R5Serialized[10]).toString(),
-                                                WIDsCount: WIDsCount,
-                                                WIDsHash: WIDsHash,
-                                                sourceChainHeight: Number(BigInt('0x' + Buffer.from(R5Serialized[11]).toString('hex')).toString(10)),
-                                            });
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        catch {
-                            continue;
+    processTransactions = async (txs, block) => {
+        try {
+            const boxes = [];
+            const spendInfoArray = [];
+            txs.forEach((transaction) => {
+                // extract event result
+                const { result, paymentTxId } = this.extractEventResult(transaction);
+                for (const output of transaction.outputs) {
+                    // extract output box data
+                    if (this.hasData(output)) {
+                        this.logger.debug(`Trying to extract data from box ${output.boxId} at height ${block.height}`);
+                        const data = this.extractBoxData(output);
+                        if (data) {
+                            this.logger.debug(`Extracted data ${JsonBI.stringify(data)} from box ${output.boxId}`);
+                            boxes.push(data);
                         }
                     }
-                    // process inputs
-                    txSpendIds.push({
+                }
+                // process inputs
+                for (let index = 0; index < transaction.inputs.length; index++)
+                    spendInfoArray.push({
                         txId: transaction.id,
-                        spendBoxes: transaction.inputs.map((box) => box.boxId),
-                        result: result,
-                        paymentTxId: paymentTxId,
+                        boxId: transaction.inputs[index].boxId,
+                        index: index,
+                        extras: [result, paymentTxId],
                     });
-                });
-                this.actions
-                    .storeEventTriggers(boxes, block, this.getId())
-                    .then(() => {
-                    txSpendIds.forEach((txSpends) => {
-                        this.actions
-                            .spendEventTriggers(txSpends.spendBoxes, block, this.id, txSpends.txId, txSpends.result, txSpends.paymentTxId)
-                            .then(() => {
-                            resolve(true);
-                        });
-                    });
-                })
-                    .catch((e) => {
-                    this.logger.error(`Error in storing permits of the block ${block}: ${e}`);
-                    reject(e);
-                });
-            }
-            catch (e) {
-                this.logger.error(`block ${block} doesn't save in the database with error: ${e}`);
-                reject(e);
-            }
-        });
-    };
-    forkBlock = async (hash) => {
-        await this.actions.deleteBlock(hash, this.getId());
-    };
-    /**
-     * Extractor box initialization
-     * No action needed in event trigger extractors
-     */
-    initializeBoxes = async () => {
-        return;
+            });
+            if (boxes.length > 0)
+                await this.actions.insertBoxes(boxes, block, this.getId());
+            await this.actions.spendBoxes(spendInfoArray, block, this.id);
+        }
+        catch (e) {
+            this.logger.error(`Error in storing data in ${this.getId()} of the block ${block}: ${e}`);
+            return false;
+        }
+        return true;
     };
     /**
      * extracts result and paymentTxId from a transaction
@@ -189,4 +209,4 @@ class EventTriggerExtractor extends AbstractExtractor {
     };
 }
 export default EventTriggerExtractor;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventTriggerExtractor.js","sourceRoot":"","sources":["../../lib/extractor/EventTriggerExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource } from 'typeorm';\nimport * as wasm from 'ergo-lib-wasm-nodejs';\nimport { blake2b } from 'blakejs';\nimport { Transaction } from '@rosen-bridge/scanner';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { AbstractExtractor, Block } from '@rosen-bridge/abstract-extractor';\n\nimport EventTriggerAction from '../actions/EventTriggerAction';\nimport { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';\nimport { JsonBI } from '../utils';\nimport { EventResult } from '../types';\n\nclass EventTriggerExtractor extends AbstractExtractor<Transaction> {\n  readonly logger: AbstractLogger;\n  id: string;\n  private readonly dataSource: DataSource;\n  private readonly actions: EventTriggerAction;\n  private readonly eventTriggerErgoTree: string;\n  private readonly permitErgoTree: string;\n  private readonly fraudErgoTree: string;\n  private readonly RWT: string;\n\n  constructor(\n    id: string,\n    dataSource: DataSource,\n    address: string,\n    RWT: string,\n    permitAddress: string,\n    fraudAddress: string,\n    logger?: AbstractLogger\n  ) {\n    super();\n    this.id = id;\n    this.dataSource = dataSource;\n    this.eventTriggerErgoTree = wasm.Address.from_base58(address)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.permitErgoTree = wasm.Address.from_base58(permitAddress)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.fraudErgoTree = 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 EventTriggerAction(dataSource, this.logger);\n  }\n\n  getId = () => this.id;\n\n  /**\n   * gets block id and transactions corresponding to the block and saves if they are valid rosen\n   *  transactions and in case of success return true and in case of failure returns false\n   * @param block\n   * @param txs\n   */\n  processTransactions = (\n    txs: Array<Transaction>,\n    block: Block\n  ): Promise<boolean> => {\n    return new Promise((resolve, reject) => {\n      try {\n        const boxes: Array<ExtractedEventTrigger> = [];\n        const txSpendIds: Array<{\n          txId: string;\n          spendBoxes: Array<string>;\n          result: string;\n          paymentTxId: string;\n        }> = [];\n        txs.forEach((transaction) => {\n          // extract event result\n          const { result, paymentTxId } = this.extractEventResult(transaction);\n          for (const output of transaction.outputs) {\n            try {\n              if (\n                output.additionalRegisters &&\n                output.assets &&\n                output.assets.length > 0 &&\n                output.assets[0].tokenId === this.RWT &&\n                output.ergoTree === this.eventTriggerErgoTree\n              ) {\n                const R4 = output.additionalRegisters.R4;\n                const R5 = output.additionalRegisters.R5;\n                const R7 = output.additionalRegisters.R7;\n                if (R4 && R5 && R7) {\n                  const outputParsed = wasm.ErgoBox.from_json(\n                    JsonBI.stringify(output)\n                  );\n                  const R4Const = outputParsed.register_value(\n                    wasm.NonMandatoryRegisterId.R4\n                  );\n                  const R5Const = outputParsed.register_value(\n                    wasm.NonMandatoryRegisterId.R5\n                  );\n                  const R7Const = outputParsed.register_value(\n                    wasm.NonMandatoryRegisterId.R7\n                  );\n                  if (R4Const && R5Const && R7Const) {\n                    const R4Serialized = R4Const.to_byte_array();\n                    const R5Serialized = R5Const.to_coll_coll_byte();\n                    if (R4Serialized.length >= 1 && R5Serialized.length >= 12) {\n                      const WIDsCount = R7Const.to_i32();\n                      const WIDsHash =\n                        Buffer.from(R4Serialized).toString('hex');\n                      const sourceTxId = Buffer.from(\n                        R5Serialized[0]\n                      ).toString();\n                      const eventId = Buffer.from(\n                        blake2b(sourceTxId, undefined, 32)\n                      ).toString('hex');\n                      boxes.push({\n                        eventId: eventId,\n                        txId: transaction.id,\n                        boxId: output.boxId,\n                        boxSerialized: Buffer.from(\n                          outputParsed.sigma_serialize_bytes()\n                        ).toString('base64'),\n                        toChain: Buffer.from(R5Serialized[2]).toString(),\n                        toAddress: Buffer.from(R5Serialized[4]).toString(),\n                        networkFee: BigInt(\n                          '0x' + Buffer.from(R5Serialized[7]).toString('hex')\n                        ).toString(10),\n                        bridgeFee: BigInt(\n                          '0x' + Buffer.from(R5Serialized[6]).toString('hex')\n                        ).toString(10),\n                        amount: BigInt(\n                          '0x' + Buffer.from(R5Serialized[5]).toString('hex')\n                        ).toString(10),\n                        sourceChainTokenId: Buffer.from(\n                          R5Serialized[8]\n                        ).toString(),\n                        targetChainTokenId: Buffer.from(\n                          R5Serialized[9]\n                        ).toString(),\n                        sourceTxId: sourceTxId,\n                        fromChain: Buffer.from(R5Serialized[1]).toString(),\n                        fromAddress: Buffer.from(R5Serialized[3]).toString(),\n                        sourceBlockId: Buffer.from(R5Serialized[10]).toString(),\n                        WIDsCount: WIDsCount,\n                        WIDsHash: WIDsHash,\n                        sourceChainHeight: Number(\n                          BigInt(\n                            '0x' + Buffer.from(R5Serialized[11]).toString('hex')\n                          ).toString(10)\n                        ),\n                      });\n                    }\n                  }\n                }\n              }\n            } catch {\n              continue;\n            }\n          }\n          // process inputs\n          txSpendIds.push({\n            txId: transaction.id,\n            spendBoxes: transaction.inputs.map((box) => box.boxId),\n            result: result,\n            paymentTxId: paymentTxId,\n          });\n        });\n        this.actions\n          .storeEventTriggers(boxes, block, this.getId())\n          .then(() => {\n            txSpendIds.forEach((txSpends) => {\n              this.actions\n                .spendEventTriggers(\n                  txSpends.spendBoxes,\n                  block,\n                  this.id,\n                  txSpends.txId,\n                  txSpends.result,\n                  txSpends.paymentTxId\n                )\n                .then(() => {\n                  resolve(true);\n                });\n            });\n          })\n          .catch((e) => {\n            this.logger.error(\n              `Error in storing permits of the block ${block}: ${e}`\n            );\n            reject(e);\n          });\n      } catch (e) {\n        this.logger.error(\n          `block ${block} doesn't save in the database with error: ${e}`\n        );\n        reject(e);\n      }\n    });\n  };\n\n  forkBlock = async (hash: string) => {\n    await this.actions.deleteBlock(hash, this.getId());\n  };\n\n  /**\n   * Extractor box initialization\n   * No action needed in event trigger extractors\n   */\n  initializeBoxes = async () => {\n    return;\n  };\n\n  /**\n   * extracts result and paymentTxId from a transaction\n   * returns 'unknown' as result when tx is neither fraud or successful\n   * @param transaction\n   * @returns\n   */\n  protected extractEventResult = (transaction: Transaction) => {\n    let result = EventResult.unknown;\n    let paymentTxId = '';\n    if (transaction.outputs[0].ergoTree === this.fraudErgoTree)\n      result = EventResult.fraud;\n    else if (transaction.outputs[0].ergoTree === this.permitErgoTree) {\n      result = EventResult.successful;\n      // find first non-watcher box with R4 value\n      for (const box of transaction.outputs) {\n        // if it's watcher box, skip it\n        if (box.ergoTree === this.permitErgoTree) continue;\n        const outputParsed = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n        try {\n          const R4Serialized = outputParsed\n            .register_value(wasm.NonMandatoryRegisterId.R4)\n            ?.to_byte_array();\n          if (R4Serialized !== undefined && R4Serialized.length > 0) {\n            let txId = Buffer.from(R4Serialized).toString();\n            // we assumed txId only includes these characters\n            if (!txId.match(/^[0-9a-zA-Z\\-_.]+$/)) {\n              // backward compatibility\n              txId = Buffer.from(R4Serialized).toString('hex');\n            }\n            paymentTxId = txId;\n            if (txId === '') {\n              paymentTxId = transaction.id;\n              this.logger.debug(\n                `successful event is spent. tx [${transaction.id}] is both payment and reward distribution tx`\n              );\n            }\n            // paymentTxId is extracted. no need to process next boxes\n            break;\n          }\n        } catch (e) {\n          continue;\n        }\n      }\n    }\n    return {\n      result,\n      paymentTxId,\n    };\n  };\n}\n\nexport default EventTriggerExtractor;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventTriggerExtractor.js","sourceRoot":"","sources":["../../lib/extractor/EventTriggerExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource } from 'typeorm';\nimport * as wasm from 'ergo-lib-wasm-nodejs';\nimport { blake2b } from 'blakejs';\nimport { Transaction } from '@rosen-bridge/scanner';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  AbstractInitializableErgoExtractor,\n  BlockInfo,\n  ErgoNetworkType,\n  OutputBox,\n  SpendInfo,\n} from '@rosen-bridge/abstract-extractor';\n\nimport EventTriggerAction from '../actions/EventTriggerAction';\nimport { ExtractedEventTrigger } from '../interfaces/extractedEventTrigger';\nimport { JsonBI } from '../utils';\nimport { EventResult } from '../types';\n\nclass EventTriggerExtractor extends AbstractInitializableErgoExtractor<ExtractedEventTrigger> {\n  id: string;\n  protected readonly actions: EventTriggerAction;\n  private readonly eventTriggerErgoTree: string;\n  private readonly permitErgoTree: string;\n  private readonly fraudErgoTree: string;\n  private readonly RWT: string;\n\n  constructor(\n    id: string,\n    dataSource: DataSource,\n    type: ErgoNetworkType,\n    url: string,\n    address: string,\n    RWT: string,\n    permitAddress: string,\n    fraudAddress: string,\n    logger?: AbstractLogger\n  ) {\n    super(type, url, address, logger);\n    this.id = id;\n    this.eventTriggerErgoTree = wasm.Address.from_base58(address)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.permitErgoTree = wasm.Address.from_base58(permitAddress)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.fraudErgoTree = wasm.Address.from_base58(fraudAddress)\n      .to_ergo_tree()\n      .to_base16_bytes();\n    this.RWT = RWT;\n    this.actions = new EventTriggerAction(dataSource, this.logger);\n  }\n\n  /**\n   * get Id for current extractor\n   */\n  getId = () => this.id;\n\n  /**\n   * check proper data format in the box\n   *  - box ergoTree\n   *  - RWT in first token place\n   *  - widListHash in R4\n   *  - event data in R5\n   *  - widCount in R7\n   * @param box\n   * @return true if the box has the required data and false otherwise\n   */\n  hasData = (box: OutputBox): boolean => {\n    try {\n      const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n      if (\n        box.additionalRegisters &&\n        box.additionalRegisters.R4 &&\n        box.additionalRegisters.R5 &&\n        box.additionalRegisters.R7 &&\n        parsedBox.register_value(wasm.NonMandatoryRegisterId.R4) &&\n        parsedBox.register_value(wasm.NonMandatoryRegisterId.R5) &&\n        parsedBox.register_value(wasm.NonMandatoryRegisterId.R7) &&\n        box.assets &&\n        box.assets.length > 0 &&\n        box.assets[0].tokenId === this.RWT &&\n        box.ergoTree === this.eventTriggerErgoTree\n      ) {\n        const R4Serialized = parsedBox\n          .register_value(wasm.NonMandatoryRegisterId.R4)!\n          .to_byte_array();\n        const R5Serialized = parsedBox\n          .register_value(wasm.NonMandatoryRegisterId.R5)!\n          .to_coll_coll_byte();\n        if (R4Serialized.length >= 1 && R5Serialized.length >= 12) return true;\n      }\n    } catch (e) {\n      this.logger.warn(\n        `Unexpected error occurred while checking the proper trigger data format for box ${box.boxId}: ${e}`\n      );\n    }\n    return false;\n  };\n\n  /**\n   * extract box data to proper format (not including spending information)\n   * @param box\n   * @return extracted data in proper format\n   */\n  extractBoxData = (\n    box: OutputBox\n  ): Omit<ExtractedEventTrigger, 'spendBlock' | 'spendHeight'> | undefined => {\n    try {\n      const parsedBox = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n      const R4Serialized = parsedBox\n        .register_value(wasm.NonMandatoryRegisterId.R4)!\n        .to_byte_array();\n      const R5Serialized = parsedBox\n        .register_value(wasm.NonMandatoryRegisterId.R5)!\n        .to_coll_coll_byte();\n\n      const WIDsCount = parsedBox\n        .register_value(wasm.NonMandatoryRegisterId.R7)!\n        .to_i32();\n      const WIDsHash = Buffer.from(R4Serialized).toString('hex');\n      const sourceTxId = Buffer.from(R5Serialized[0]).toString();\n      const eventId = Buffer.from(blake2b(sourceTxId, undefined, 32)).toString(\n        'hex'\n      );\n      return {\n        eventId: eventId,\n        txId: box.transactionId,\n        boxId: box.boxId,\n        boxSerialized: Buffer.from(parsedBox.sigma_serialize_bytes()).toString(\n          'base64'\n        ),\n        toChain: Buffer.from(R5Serialized[2]).toString(),\n        toAddress: Buffer.from(R5Serialized[4]).toString(),\n        networkFee: BigInt(\n          '0x' + Buffer.from(R5Serialized[7]).toString('hex')\n        ).toString(10),\n        bridgeFee: BigInt(\n          '0x' + Buffer.from(R5Serialized[6]).toString('hex')\n        ).toString(10),\n        amount: BigInt(\n          '0x' + Buffer.from(R5Serialized[5]).toString('hex')\n        ).toString(10),\n        sourceChainTokenId: Buffer.from(R5Serialized[8]).toString(),\n        targetChainTokenId: Buffer.from(R5Serialized[9]).toString(),\n        sourceTxId: sourceTxId,\n        fromChain: Buffer.from(R5Serialized[1]).toString(),\n        fromAddress: Buffer.from(R5Serialized[3]).toString(),\n        sourceBlockId: Buffer.from(R5Serialized[10]).toString(),\n        WIDsCount: WIDsCount,\n        WIDsHash: WIDsHash,\n        sourceChainHeight: Number(\n          BigInt('0x' + Buffer.from(R5Serialized[11]).toString('hex')).toString(\n            10\n          )\n        ),\n      };\n    } catch (e) {\n      this.logger.warn(\n        `Unexpected error occurred while extracting trigger data for box ${box.boxId}: ${e}`\n      );\n      return undefined;\n    }\n  };\n\n  /**\n   * gets block id and transactions corresponding to the block and saves if they are valid rosen\n   *  transactions and in case of success return true and in case of failure returns false\n   * @param block\n   * @param txs\n   */\n  processTransactions = async (\n    txs: Array<Transaction>,\n    block: BlockInfo\n  ): Promise<boolean> => {\n    try {\n      const boxes: Array<ExtractedEventTrigger> = [];\n      const spendInfoArray: Array<SpendInfo> = [];\n      txs.forEach((transaction) => {\n        // extract event result\n        const { result, paymentTxId } = this.extractEventResult(transaction);\n        for (const output of transaction.outputs) {\n          // extract output box data\n          if (this.hasData(output)) {\n            this.logger.debug(\n              `Trying to extract data from box ${output.boxId} at height ${block.height}`\n            );\n            const data = this.extractBoxData(output);\n            if (data) {\n              this.logger.debug(\n                `Extracted data ${JsonBI.stringify(data)} from box ${\n                  output.boxId\n                }`\n              );\n              boxes.push(data);\n            }\n          }\n        }\n        // process inputs\n        for (let index = 0; index < transaction.inputs.length; index++)\n          spendInfoArray.push({\n            txId: transaction.id,\n            boxId: transaction.inputs[index].boxId,\n            index: index,\n            extras: [result, paymentTxId],\n          });\n      });\n      if (boxes.length > 0)\n        await this.actions.insertBoxes(boxes, block, this.getId());\n      await this.actions.spendBoxes(spendInfoArray, block, this.id);\n    } catch (e) {\n      this.logger.error(\n        `Error in storing data in ${this.getId()} of the block ${block}: ${e}`\n      );\n      return false;\n    }\n    return true;\n  };\n\n  /**\n   * extracts result and paymentTxId from a transaction\n   * returns 'unknown' as result when tx is neither fraud or successful\n   * @param transaction\n   * @returns\n   */\n  protected extractEventResult = (transaction: Transaction) => {\n    let result = EventResult.unknown;\n    let paymentTxId = '';\n    if (transaction.outputs[0].ergoTree === this.fraudErgoTree)\n      result = EventResult.fraud;\n    else if (transaction.outputs[0].ergoTree === this.permitErgoTree) {\n      result = EventResult.successful;\n      // find first non-watcher box with R4 value\n      for (const box of transaction.outputs) {\n        // if it's watcher box, skip it\n        if (box.ergoTree === this.permitErgoTree) continue;\n        const outputParsed = wasm.ErgoBox.from_json(JsonBI.stringify(box));\n        try {\n          const R4Serialized = outputParsed\n            .register_value(wasm.NonMandatoryRegisterId.R4)\n            ?.to_byte_array();\n          if (R4Serialized !== undefined && R4Serialized.length > 0) {\n            let txId = Buffer.from(R4Serialized).toString();\n            // we assumed txId only includes these characters\n            if (!txId.match(/^[0-9a-zA-Z\\-_.]+$/)) {\n              // backward compatibility\n              txId = Buffer.from(R4Serialized).toString('hex');\n            }\n            paymentTxId = txId;\n            if (txId === '') {\n              paymentTxId = transaction.id;\n              this.logger.debug(\n                `successful event is spent. tx [${transaction.id}] is both payment and reward distribution tx`\n              );\n            }\n            // paymentTxId is extracted. no need to process next boxes\n            break;\n          }\n        } catch (e) {\n          continue;\n        }\n      }\n    }\n    return {\n      result,\n      paymentTxId,\n    };\n  };\n}\n\nexport default EventTriggerExtractor;\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/watcher-data-extractor",
-  "version": "8.0.2",
+  "version": "9.0.0",
   "description": "Extractor for rosen specific boxes on ergo blockchain",
   "author": "Rosen Team",
   "license": "GPL-3.0",
@@ -19,11 +19,11 @@
     "dist"
   ],
   "dependencies": {
-    "@rosen-bridge/abstract-extractor": "^0.3.0",
+    "@rosen-bridge/abstract-extractor": "^0.3.1",
     "@rosen-bridge/abstract-logger": "^1.0.0",
     "@rosen-bridge/extended-typeorm": "^0.0.3",
     "@rosen-bridge/json-bigint": "^0.1.0",
-    "@rosen-bridge/scanner": "^4.1.3",
+    "@rosen-bridge/scanner": "^5.0.0",
     "@rosen-bridge/tokens": "^1.2.1",
     "@rosen-clients/ergo-explorer": "^1.1.1",
     "@types/lodash-es": "^4.17.6",