@rosen-bridge/abstract-scanner 0.1.0-52fc0239

package/dist/scanner/abstract/generalScanner.d.ts

@@ -0,0 +1,63 @@
+import { AbstractScanner } from './scanner';
+import { AbstractNetworkConnector, Block } from '@rosen-bridge/scanner-interfaces';
+import { BlockEntity } from '../../entities/blockEntity';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+declare abstract class GeneralScanner<TransactionType> extends AbstractScanner<TransactionType> {
+    private scannerName;
+    private dataSource;
+    private network;
+    private blockRetrieveGap;
+    private suffix?;
+    private readonly initialHeight;
+    protected blockChainLastHeight: number | undefined;
+    name: () => string;
+    constructor(scannerName: string, dataSource: DataSource, initialHeight: number, network: AbstractNetworkConnector<TransactionType>, blockRetrieveGap?: number, logger?: AbstractLogger, suffix?: string | undefined);
+    /**
+     * Get the first block to process
+     * @returns The first block at the configured initial height
+     */
+    protected getFirstBlock: () => Promise<Block>;
+    /**
+     * function that checks if fork is happen in the blockchain or not
+     * @return Promise<Boolean>
+     */
+    protected isForkHappen: () => Promise<boolean>;
+    /**
+     * This method introduces delay between consecutive block processing operations
+     */
+    protected delayBetweenBlocksProcessing: (startTime: number) => Promise<void>;
+    /**
+     * process a block and execute all extractor on it.
+     * @param block
+     */
+    protected processBlock: (block: Block) => Promise<false | BlockEntity>;
+    /**
+     * process forward in scanner. get blocks and store information from transactions.
+     * @param lastSavedBlock: last saved block entity in database
+     */
+    protected stepForward: (lastSavedBlock: BlockEntity) => Promise<void>;
+    /**
+     * Step backward in blockchain and find fork point.
+     * and remove all forked blocks from database
+     */
+    protected stepBackward: () => Promise<void>;
+    /**
+     * Initialize the extractors with the first block
+     * Process and store the first block in database
+     * @returns
+     */
+    protected initialize: () => Promise<BlockEntity>;
+    /**
+     * Return the latest height of the blockchain
+     * @returns { number | undefined }
+     */
+    getBlockChainLastHeight: () => number | undefined;
+    /**
+     * worker function that runs for syncing the database with the Cardano blockchain and checks if we have any fork
+     * scenario in the blockchain and invalidate the database till the database synced again.
+     */
+    update: () => Promise<void>;
+}
+export { GeneralScanner };
+//# sourceMappingURL=generalScanner.d.ts.map

package/dist/scanner/abstract/generalScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalScanner.d.ts","sourceRoot":"","sources":["../../../lib/scanner/abstract/generalScanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EACL,wBAAwB,EACxB,KAAK,EACN,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE5D,uBAAe,cAAc,CAC3B,eAAe,CACf,SAAQ,eAAe,CAAC,eAAe,CAAC;IAOtC,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,UAAU;IAElB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,gBAAgB;IAExB,OAAO,CAAC,MAAM,CAAC;IAZjB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,SAAS,CAAC,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAa;IAE/D,IAAI,eAAmE;gBAG7D,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,UAAU,EAC9B,aAAa,EAAE,MAAM,EACb,OAAO,EAAE,wBAAwB,CAAC,eAAe,CAAC,EAClD,gBAAgB,SAAI,EAC5B,MAAM,CAAC,EAAE,cAAc,EACf,MAAM,CAAC,oBAAQ;IAezB;;;OAGG;IACH,SAAS,CAAC,aAAa,QAAO,QAAQ,KAAK,CAAC,CAE1C;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,QAAa,QAAQ,OAAO,CAAC,CAUjD;IAEF;;OAEG;IACH,SAAS,CAAC,4BAA4B,cAAqB,MAAM,mBAK/D;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,UAAiB,KAAK,kCAyB1C;IAEF;;;OAGG;IACH,SAAS,CAAC,WAAW,mBAA0B,WAAW,mBA8BxD;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,sBAepB;IAEF;;;;OAIG;IACH,SAAS,CAAC,UAAU,6BAYlB;IAEF;;;OAGG;IACI,uBAAuB,QAAO,MAAM,GAAG,SAAS,CAC3B;IAE5B;;;OAGG;IACH,MAAM,sBAqBJ;CACH;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/scanner/abstract/generalScanner.js

@@ -0,0 +1,173 @@
+import { AbstractScanner } from './scanner';
+import JsonBI from '@rosen-bridge/json-bigint';
+import { BlockDbAction } from '../action';
+class GeneralScanner extends AbstractScanner {
+    scannerName;
+    dataSource;
+    network;
+    blockRetrieveGap;
+    suffix;
+    initialHeight;
+    blockChainLastHeight = undefined;
+    name = () => this.scannerName + (this.suffix ? `-${this.suffix}` : '');
+    constructor(scannerName, dataSource, initialHeight, network, blockRetrieveGap = 0, logger, suffix) {
+        super(logger);
+        this.scannerName = scannerName;
+        this.dataSource = dataSource;
+        this.network = network;
+        this.blockRetrieveGap = blockRetrieveGap;
+        this.suffix = suffix;
+        /**
+         * In order to keep the scanners functionalities consistent, we add config
+         * `initialHeight` by one so that it matches how other scanners work.
+         */
+        this.initialHeight = initialHeight + 1;
+        this.action = new BlockDbAction(this.dataSource, this.scannerName, this.logger);
+    }
+    /**
+     * Get the first block to process
+     * @returns The first block at the configured initial height
+     */
+    getFirstBlock = () => {
+        return this.network.getBlockAtHeight(this.initialHeight);
+    };
+    /**
+     * function that checks if fork is happen in the blockchain or not
+     * @return Promise<Boolean>
+     */
+    isForkHappen = async () => {
+        const lastSavedBlock = await this.action.getLastSavedBlock();
+        if (lastSavedBlock !== undefined) {
+            const lastSavedBlockFromNetwork = await this.network.getBlockAtHeight(lastSavedBlock.height);
+            return lastSavedBlockFromNetwork.hash !== lastSavedBlock.hash;
+        }
+        else {
+            return false;
+        }
+    };
+    /**
+     * This method introduces delay between consecutive block processing operations
+     */
+    delayBetweenBlocksProcessing = async (startTime) => {
+        const spentTime = new Date().getTime() - startTime;
+        await new Promise((resolve) => setTimeout(() => resolve(null), this.blockRetrieveGap - spentTime));
+    };
+    /**
+     * process a block and execute all extractor on it.
+     * @param block
+     */
+    processBlock = async (block) => {
+        const startTime = new Date().getTime();
+        this.logger.debug(`Processing block at height [${block.height}] in scanner ${this.name()}`);
+        const txs = await this.network.getBlockTxs(block.hash);
+        if (block.txCount) {
+            if (txs.length != block.txCount) {
+                this.logger.debug(`Aborting block process with hash [${block.hash}] expected to have ${block.txCount} transactions but had ${txs.length}`);
+                return false;
+            }
+            this.logger.debug(`processing ${block.txCount} transactions of block with hash [${block.hash}]`);
+        }
+        const result = await this.processBlockTransactions(block, txs);
+        // Spending time between block fetches if the setting is enabled
+        if (this.blockRetrieveGap)
+            await this.delayBetweenBlocksProcessing(startTime);
+        return result;
+    };
+    /**
+     * process forward in scanner. get blocks and store information from transactions.
+     * @param lastSavedBlock: last saved block entity in database
+     */
+    stepForward = async (lastSavedBlock) => {
+        const currentHeight = await this.network.getCurrentHeight();
+        const firstBlock = await this.action.getFirstSavedBlock();
+        if (!firstBlock || firstBlock.height >= currentHeight) {
+            return;
+        }
+        for (let height = lastSavedBlock.height + 1; height <= currentHeight; height++) {
+            const block = await this.network.getBlockAtHeight(height);
+            if (lastSavedBlock !== undefined) {
+                if (block.parentHash === lastSavedBlock.hash) {
+                    const savedBlock = await this.processBlock(block);
+                    if (typeof savedBlock === 'boolean') {
+                        break;
+                    }
+                    else {
+                        lastSavedBlock = savedBlock;
+                    }
+                }
+                else {
+                    this.logger.debug(`Invalid block at height ${height}. Block info is [${JsonBI.stringify(block)} and the expected parent hash is [${lastSavedBlock.hash}]`);
+                    break;
+                }
+            }
+        }
+    };
+    /**
+     * Step backward in blockchain and find fork point.
+     * and remove all forked blocks from database
+     */
+    stepBackward = async () => {
+        let block = await this.action.getLastSavedBlock();
+        while (block) {
+            const blockFromNetwork = await this.network.getBlockAtHeight(block.height);
+            if (blockFromNetwork.hash === block.hash &&
+                block.parentHash === blockFromNetwork.parentHash) {
+                return;
+            }
+            await this.forkBlock(block.height);
+            block = await this.action.getLastSavedBlock();
+        }
+    };
+    /**
+     * Initialize the extractors with the first block
+     * Process and store the first block in database
+     * @returns
+     */
+    initialize = async () => {
+        const block = await this.getFirstBlock();
+        await this.verifyExtractorsInitialization({
+            height: block.height - 1,
+            hash: block.parentHash,
+        });
+        await this.processBlock(block);
+        const entity = await this.action.getFirstSavedBlock();
+        if (entity === undefined) {
+            throw new Error('Can not store block in database');
+        }
+        return entity;
+    };
+    /**
+     * Return the latest height of the blockchain
+     * @returns { number | undefined }
+     */
+    getBlockChainLastHeight = () => this.blockChainLastHeight;
+    /**
+     * worker function that runs for syncing the database with the Cardano blockchain and checks if we have any fork
+     * scenario in the blockchain and invalidate the database till the database synced again.
+     */
+    update = async () => {
+        try {
+            const latestHeight = await this.network.getCurrentHeight();
+            if (!this.blockChainLastHeight ||
+                this.blockChainLastHeight < latestHeight)
+                this.blockChainLastHeight = latestHeight;
+            let lastSavedBlock = await this.action.getLastSavedBlock();
+            if (!lastSavedBlock) {
+                lastSavedBlock = await this.initialize();
+            }
+            else
+                await this.verifyExtractorsInitialization(lastSavedBlock);
+            if (!(await this.isForkHappen())) {
+                await this.stepForward(lastSavedBlock);
+            }
+            else {
+                await this.stepBackward();
+            }
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during update process. ${e}`);
+        }
+    };
+}
+export { GeneralScanner };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generalScanner.js","sourceRoot":"","sources":["../../../lib/scanner/abstract/generalScanner.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractScanner } from './scanner';\nimport {\n  AbstractNetworkConnector,\n  Block,\n} from '@rosen-bridge/scanner-interfaces';\nimport { BlockEntity } from '../../entities/blockEntity';\nimport JsonBI from '@rosen-bridge/json-bigint';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { BlockDbAction } from '../action';\nimport { DataSource } from '@rosen-bridge/extended-typeorm';\n\nabstract class GeneralScanner<\n  TransactionType\n> extends AbstractScanner<TransactionType> {\n  private readonly initialHeight: number;\n  protected blockChainLastHeight: number | undefined = undefined;\n\n  name = () => this.scannerName + (this.suffix ? `-${this.suffix}` : '');\n\n  constructor(\n    private scannerName: string,\n    private dataSource: DataSource,\n    initialHeight: number,\n    private network: AbstractNetworkConnector<TransactionType>,\n    private blockRetrieveGap = 0,\n    logger?: AbstractLogger,\n    private suffix?: string\n  ) {\n    super(logger);\n    /**\n     * In order to keep the scanners functionalities consistent, we add config\n     * `initialHeight` by one so that it matches how other scanners work.\n     */\n    this.initialHeight = initialHeight + 1;\n    this.action = new BlockDbAction(\n      this.dataSource,\n      this.scannerName,\n      this.logger\n    );\n  }\n\n  /**\n   * Get the first block to process\n   * @returns The first block at the configured initial height\n   */\n  protected getFirstBlock = (): Promise<Block> => {\n    return this.network.getBlockAtHeight(this.initialHeight);\n  };\n\n  /**\n   * function that checks if fork is happen in the blockchain or not\n   * @return Promise<Boolean>\n   */\n  protected isForkHappen = async (): Promise<boolean> => {\n    const lastSavedBlock = await this.action.getLastSavedBlock();\n    if (lastSavedBlock !== undefined) {\n      const lastSavedBlockFromNetwork = await this.network.getBlockAtHeight(\n        lastSavedBlock.height\n      );\n      return lastSavedBlockFromNetwork.hash !== lastSavedBlock.hash;\n    } else {\n      return false;\n    }\n  };\n\n  /**\n   * This method introduces delay between consecutive block processing operations\n   */\n  protected delayBetweenBlocksProcessing = async (startTime: number) => {\n    const spentTime = new Date().getTime() - startTime;\n    await new Promise((resolve) =>\n      setTimeout(() => resolve(null), this.blockRetrieveGap - spentTime)\n    );\n  };\n\n  /**\n   * process a block and execute all extractor on it.\n   * @param block\n   */\n  protected processBlock = async (block: Block) => {\n    const startTime = new Date().getTime();\n    this.logger.debug(\n      `Processing block at height [${block.height}] in scanner ${this.name()}`\n    );\n    const txs = await this.network.getBlockTxs(block.hash);\n    if (block.txCount) {\n      if (txs.length != block.txCount) {\n        this.logger.debug(\n          `Aborting block process with hash [${block.hash}] expected to have ${block.txCount} transactions but had ${txs.length}`\n        );\n        return false;\n      }\n      this.logger.debug(\n        `processing ${block.txCount} transactions of block with hash [${block.hash}]`\n      );\n    }\n\n    const result = await this.processBlockTransactions(block, txs);\n\n    // Spending time between block fetches if the setting is enabled\n    if (this.blockRetrieveGap)\n      await this.delayBetweenBlocksProcessing(startTime);\n\n    return result;\n  };\n\n  /**\n   * process forward in scanner. get blocks and store information from transactions.\n   * @param lastSavedBlock: last saved block entity in database\n   */\n  protected stepForward = async (lastSavedBlock: BlockEntity) => {\n    const currentHeight = await this.network.getCurrentHeight();\n    const firstBlock = await this.action.getFirstSavedBlock();\n    if (!firstBlock || firstBlock.height >= currentHeight) {\n      return;\n    }\n    for (\n      let height = lastSavedBlock.height + 1;\n      height <= currentHeight;\n      height++\n    ) {\n      const block = await this.network.getBlockAtHeight(height);\n      if (lastSavedBlock !== undefined) {\n        if (block.parentHash === lastSavedBlock.hash) {\n          const savedBlock = await this.processBlock(block);\n          if (typeof savedBlock === 'boolean') {\n            break;\n          } else {\n            lastSavedBlock = savedBlock;\n          }\n        } else {\n          this.logger.debug(\n            `Invalid block at height ${height}. Block info is [${JsonBI.stringify(\n              block\n            )} and the expected parent hash is [${lastSavedBlock.hash}]`\n          );\n          break;\n        }\n      }\n    }\n  };\n\n  /**\n   * Step backward in blockchain and find fork point.\n   * and remove all forked blocks from database\n   */\n  protected stepBackward = async () => {\n    let block = await this.action.getLastSavedBlock();\n    while (block) {\n      const blockFromNetwork = await this.network.getBlockAtHeight(\n        block.height\n      );\n      if (\n        blockFromNetwork.hash === block.hash &&\n        block.parentHash === blockFromNetwork.parentHash\n      ) {\n        return;\n      }\n      await this.forkBlock(block.height);\n      block = await this.action.getLastSavedBlock();\n    }\n  };\n\n  /**\n   * Initialize the extractors with the first block\n   * Process and store the first block in database\n   * @returns\n   */\n  protected initialize = async () => {\n    const block = await this.getFirstBlock();\n    await this.verifyExtractorsInitialization({\n      height: block.height - 1,\n      hash: block.parentHash,\n    });\n    await this.processBlock(block);\n    const entity = await this.action.getFirstSavedBlock();\n    if (entity === undefined) {\n      throw new Error('Can not store block in database');\n    }\n    return entity;\n  };\n\n  /**\n   * Return the latest height of the blockchain\n   * @returns { number | undefined }\n   */\n  public getBlockChainLastHeight = (): number | undefined =>\n    this.blockChainLastHeight;\n\n  /**\n   * worker function that runs for syncing the database with the Cardano blockchain and checks if we have any fork\n   * scenario in the blockchain and invalidate the database till the database synced again.\n   */\n  update = async () => {\n    try {\n      const latestHeight = await this.network.getCurrentHeight();\n      if (\n        !this.blockChainLastHeight ||\n        this.blockChainLastHeight < latestHeight\n      )\n        this.blockChainLastHeight = latestHeight;\n\n      let lastSavedBlock = await this.action.getLastSavedBlock();\n      if (!lastSavedBlock) {\n        lastSavedBlock = await this.initialize();\n      } else await this.verifyExtractorsInitialization(lastSavedBlock);\n      if (!(await this.isForkHappen())) {\n        await this.stepForward(lastSavedBlock);\n      } else {\n        await this.stepBackward();\n      }\n    } catch (e) {\n      this.logger.error(`An error occurred during update process. ${e}`);\n    }\n  };\n}\n\nexport { GeneralScanner };\n"]}

package/dist/scanner/abstract/scanner.d.ts

@@ -0,0 +1,48 @@
+import { Mutex } from 'await-semaphore';
+import { Block, BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractExtractor } from '@rosen-bridge/abstract-extractor';
+import { BlockDbAction } from '../action';
+export declare abstract class AbstractScanner<TransactionType> {
+    action: BlockDbAction;
+    extractors: Array<AbstractExtractor<TransactionType>>;
+    newExtractors: Array<AbstractExtractor<TransactionType>>;
+    logger: AbstractLogger;
+    initializeMutex: Mutex;
+    constructor(logger?: AbstractLogger);
+    abstract name: () => string;
+    /**
+     * fork blocks from specific height from scanner.
+     * @param height: selected height
+     */
+    protected forkBlock: (height: number) => Promise<void>;
+    /**
+     * process a block and all of its transactions. store any information into database
+     * @param block: selected block
+     * @param transactions: list of transaction for selected block
+     */
+    protected processBlockTransactions: (block: Block, transactions: Array<TransactionType>) => Promise<false | import("../..").BlockEntity>;
+    /**
+     * register a nre extractor to scanner.
+     * @param extractor
+     */
+    registerExtractor: (extractor: AbstractExtractor<TransactionType>) => Promise<void>;
+    /**
+     * remove an extractor from scanner
+     * @param extractor
+     */
+    removeExtractor: (extractor: AbstractExtractor<TransactionType>) => Promise<void>;
+    /**
+     * Initialize all specified extractors and store the updated status
+     * @param extractorIds
+     * @param height
+     */
+    private initializeExtractors;
+    /**
+     * Initializes the extractors if they're not synced or not initialized yet,
+     * and update the active extractors list
+     * @param block
+     */
+    protected verifyExtractorsInitialization: (block: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=scanner.d.ts.map

package/dist/scanner/abstract/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../lib/scanner/abstract/scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAE5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,8BAAsB,eAAe,CAAC,eAAe;IACnD,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,KAAK,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC,CAAC;IACtD,aAAa,EAAE,KAAK,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC,CAAC;IACzD,MAAM,EAAE,cAAc,CAAC;IACvB,eAAe,EAAE,KAAK,CAAC;gBAEX,MAAM,CAAC,EAAE,cAAc;IAOnC,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC;IAE5B;;;OAGG;IACH,SAAS,CAAC,SAAS,WAAkB,MAAM,mBAuBzC;IAEF;;;;OAIG;IACH,SAAS,CAAC,wBAAwB,UACzB,KAAK,gBACE,MAAM,eAAe,CAAC,kDAyBpC;IAEF;;;OAGG;IACH,iBAAiB,cACJ,kBAAkB,eAAe,CAAC,KAC5C,QAAQ,IAAI,CAAC,CAmBd;IAEF;;;OAGG;IACH,eAAe,cACF,kBAAkB,eAAe,CAAC,KAC5C,QAAQ,IAAI,CAAC,CAQd;IAEF;;;;OAIG;IACH,OAAO,CAAC,oBAAoB,CAkB1B;IAEF;;;;OAIG;IACH,SAAS,CAAC,8BAA8B,UAAiB,SAAS,mBA2DhE;CACH"}

package/dist/scanner/abstract/scanner.js

@@ -0,0 +1,154 @@
+import { Mutex } from 'await-semaphore';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { difference, remove } from 'lodash-es';
+export class AbstractScanner {
+    action;
+    extractors;
+    newExtractors;
+    logger;
+    initializeMutex;
+    constructor(logger) {
+        this.extractors = [];
+        this.newExtractors = [];
+        this.logger = logger ? logger : new DummyLogger();
+        this.initializeMutex = new Mutex();
+    }
+    /**
+     * fork blocks from specific height from scanner.
+     * @param height: selected height
+     */
+    forkBlock = async (height) => {
+        let lastBlock = await this.action.getLastSavedBlock();
+        while (lastBlock && lastBlock.height >= height) {
+            this.logger.debug(`Reverting block ${lastBlock.hash} at height ${lastBlock.height}`);
+            await this.action.revertBlockStatus(lastBlock.height, lastBlock.parentHash, this.extractors.map((e) => e.getId()));
+            for (const extractor of this.extractors) {
+                try {
+                    await extractor.forkBlock(lastBlock.hash);
+                }
+                catch (e) {
+                    this.logger.error(`An error occurred during fork block in extractor ${extractor.getId()}: ${e}`);
+                }
+            }
+            await this.action.removeBlocksFromHeight(lastBlock.height);
+            lastBlock = await this.action.getBlockAtHeight(lastBlock.height - 1);
+        }
+    };
+    /**
+     * process a block and all of its transactions. store any information into database
+     * @param block: selected block
+     * @param transactions: list of transaction for selected block
+     */
+    processBlockTransactions = async (block, transactions) => {
+        const savedBlock = await this.action.saveBlock(block);
+        if (typeof savedBlock === 'boolean') {
+            return false;
+        }
+        let success = true;
+        for (const extractor of this.extractors) {
+            if (!(await extractor.processTransactions(transactions, savedBlock))) {
+                success = false;
+                break;
+            }
+        }
+        if (success &&
+            (await this.action.updateBlockStatus(block.height, block.hash, this.extractors.map((e) => e.getId())))) {
+            return savedBlock;
+        }
+        return false;
+    };
+    /**
+     * register a nre extractor to scanner.
+     * @param extractor
+     */
+    registerExtractor = async (extractor) => {
+        const notRegisteredIn = (extractors) => extractors.filter((extractorItem) => extractorItem.getId() === extractor.getId()).length === 0;
+        const release = await this.initializeMutex.acquire();
+        if (notRegisteredIn(this.extractors) &&
+            notRegisteredIn(this.newExtractors)) {
+            this.newExtractors.push(extractor);
+        }
+        else {
+            this.logger.warn(`Extractor with id ${extractor.getId()} is already registered`);
+        }
+        release();
+    };
+    /**
+     * remove an extractor from scanner
+     * @param extractor
+     */
+    removeExtractor = async (extractor) => {
+        const removeFn = (ex) => ex.getId() === extractor.getId();
+        const release = await this.initializeMutex.acquire();
+        remove(this.extractors, removeFn);
+        remove(this.newExtractors, removeFn);
+        release();
+    };
+    /**
+     * Initialize all specified extractors and store the updated status
+     * @param extractorIds
+     * @param height
+     */
+    initializeExtractors = async (extractorIds, block) => {
+        const allExtractors = [...this.extractors, ...this.newExtractors];
+        const initRequiredExtractors = allExtractors.filter((extractor) => extractorIds.includes(extractor.getId()));
+        for (const extractor of initRequiredExtractors) {
+            this.logger.info(`Initializing [${extractor.getId()}] boxes`);
+            await extractor.initializeBoxes(block);
+            await this.action.updateOrInsertExtractorStatus(extractor.getId(), block.height, block.hash);
+            this.logger.debug(`Initialization finished for [${extractor.getId()}]`);
+        }
+    };
+    /**
+     * Initializes the extractors if they're not synced or not initialized yet,
+     * and update the active extractors list
+     * @param block
+     */
+    verifyExtractorsInitialization = async (block) => {
+        const getIds = (extractors) => {
+            return extractors.map((extractor) => extractor.getId());
+        };
+        this.logger.debug(`Initializing extractors for block [${block.height}]`);
+        let success = true;
+        const release = await this.initializeMutex.acquire();
+        try {
+            const extractorsStatus = await this.action.getExtractorsStatus([
+                ...getIds(this.extractors),
+                ...getIds(this.newExtractors),
+            ]);
+            this.logger.debug(`Stored extractors status are [${JSON.stringify(extractorsStatus)}]`);
+            // Find extractors not synced with the latest height
+            const notSyncedExtractorIds = extractorsStatus
+                .filter((es) => es.updateBlockHash != block.hash)
+                .map((es) => es.extractorId);
+            if (notSyncedExtractorIds.length > 0)
+                this.logger.debug(`Old not synced extractors are ${notSyncedExtractorIds}`);
+            // Find new extractors not available in database
+            const storedExtractorIds = extractorsStatus.map((es) => es.extractorId);
+            const newRegisteredExtractorIds = difference(getIds(this.newExtractors), storedExtractorIds);
+            if (newRegisteredExtractorIds.length > 0)
+                this.logger.debug(`New registered extractors are ${newRegisteredExtractorIds}`);
+            // Initialize required extractors
+            const initRequiredExtractors = [
+                ...newRegisteredExtractorIds,
+                ...notSyncedExtractorIds,
+            ];
+            if (initRequiredExtractors.length > 0) {
+                this.logger.info(`Initializing ${initRequiredExtractors.length} extractor(s) for [${this.name()}]`, { initRequiredExtractors });
+                await this.initializeExtractors(initRequiredExtractors, block);
+            }
+            this.extractors.push(...this.newExtractors);
+            this.newExtractors = [];
+        }
+        catch (e) {
+            this.logger.warn(`Initialization for extractors failed with error ${e}`);
+            success = false;
+        }
+        finally {
+            release();
+        }
+        if (!success)
+            throw new Error(`Initialization failed for new extractors ${getIds(this.newExtractors)}`);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scanner.js","sourceRoot":"","sources":["../../../lib/scanner/abstract/scanner.ts"],"names":[],"mappings":"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","sourcesContent":["import { Mutex } from 'await-semaphore';\nimport { Block, BlockInfo } from '@rosen-bridge/scanner-interfaces';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { difference, remove } from 'lodash-es';\nimport { AbstractExtractor } from '@rosen-bridge/abstract-extractor';\n\nimport { BlockDbAction } from '../action';\n\nexport abstract class AbstractScanner<TransactionType> {\n  action: BlockDbAction;\n  extractors: Array<AbstractExtractor<TransactionType>>;\n  newExtractors: Array<AbstractExtractor<TransactionType>>;\n  logger: AbstractLogger;\n  initializeMutex: Mutex;\n\n  constructor(logger?: AbstractLogger) {\n    this.extractors = [];\n    this.newExtractors = [];\n    this.logger = logger ? logger : new DummyLogger();\n    this.initializeMutex = new Mutex();\n  }\n\n  abstract name: () => string;\n\n  /**\n   * fork blocks from specific height from scanner.\n   * @param height: selected height\n   */\n  protected forkBlock = async (height: number) => {\n    let lastBlock = await this.action.getLastSavedBlock();\n    while (lastBlock && lastBlock.height >= height) {\n      this.logger.debug(\n        `Reverting block ${lastBlock.hash} at height ${lastBlock.height}`\n      );\n      await this.action.revertBlockStatus(\n        lastBlock.height,\n        lastBlock.parentHash,\n        this.extractors.map((e) => e.getId())\n      );\n      for (const extractor of this.extractors) {\n        try {\n          await extractor.forkBlock(lastBlock.hash);\n        } catch (e) {\n          this.logger.error(\n            `An error occurred during fork block in extractor ${extractor.getId()}: ${e}`\n          );\n        }\n      }\n      await this.action.removeBlocksFromHeight(lastBlock.height);\n      lastBlock = await this.action.getBlockAtHeight(lastBlock.height - 1);\n    }\n  };\n\n  /**\n   * process a block and all of its transactions. store any information into database\n   * @param block: selected block\n   * @param transactions: list of transaction for selected block\n   */\n  protected processBlockTransactions = async (\n    block: Block,\n    transactions: Array<TransactionType>\n  ) => {\n    const savedBlock = await this.action.saveBlock(block);\n    if (typeof savedBlock === 'boolean') {\n      return false;\n    }\n    let success = true;\n    for (const extractor of this.extractors) {\n      if (!(await extractor.processTransactions(transactions, savedBlock))) {\n        success = false;\n        break;\n      }\n    }\n\n    if (\n      success &&\n      (await this.action.updateBlockStatus(\n        block.height,\n        block.hash,\n        this.extractors.map((e) => e.getId())\n      ))\n    ) {\n      return savedBlock;\n    }\n    return false;\n  };\n\n  /**\n   * register a nre extractor to scanner.\n   * @param extractor\n   */\n  registerExtractor = async (\n    extractor: AbstractExtractor<TransactionType>\n  ): Promise<void> => {\n    const notRegisteredIn = (\n      extractors: Array<AbstractExtractor<TransactionType>>\n    ) =>\n      extractors.filter(\n        (extractorItem) => extractorItem.getId() === extractor.getId()\n      ).length === 0;\n    const release = await this.initializeMutex.acquire();\n    if (\n      notRegisteredIn(this.extractors) &&\n      notRegisteredIn(this.newExtractors)\n    ) {\n      this.newExtractors.push(extractor);\n    } else {\n      this.logger.warn(\n        `Extractor with id ${extractor.getId()} is already registered`\n      );\n    }\n    release();\n  };\n\n  /**\n   * remove an extractor from scanner\n   * @param extractor\n   */\n  removeExtractor = async (\n    extractor: AbstractExtractor<TransactionType>\n  ): Promise<void> => {\n    const removeFn = (ex: AbstractExtractor<TransactionType>) =>\n      ex.getId() === extractor.getId();\n\n    const release = await this.initializeMutex.acquire();\n    remove(this.extractors, removeFn);\n    remove(this.newExtractors, removeFn);\n    release();\n  };\n\n  /**\n   * Initialize all specified extractors and store the updated status\n   * @param extractorIds\n   * @param height\n   */\n  private initializeExtractors = async (\n    extractorIds: string[],\n    block: BlockInfo\n  ) => {\n    const allExtractors = [...this.extractors, ...this.newExtractors];\n    const initRequiredExtractors = allExtractors.filter((extractor) =>\n      extractorIds.includes(extractor.getId())\n    );\n    for (const extractor of initRequiredExtractors) {\n      this.logger.info(`Initializing [${extractor.getId()}] boxes`);\n      await extractor.initializeBoxes(block);\n      await this.action.updateOrInsertExtractorStatus(\n        extractor.getId(),\n        block.height,\n        block.hash\n      );\n      this.logger.debug(`Initialization finished for [${extractor.getId()}]`);\n    }\n  };\n\n  /**\n   * Initializes the extractors if they're not synced or not initialized yet,\n   * and update the active extractors list\n   * @param block\n   */\n  protected verifyExtractorsInitialization = async (block: BlockInfo) => {\n    const getIds = (extractors: Array<AbstractExtractor<TransactionType>>) => {\n      return extractors.map((extractor) => extractor.getId());\n    };\n    this.logger.debug(`Initializing extractors for block [${block.height}]`);\n    let success = true;\n    const release = await this.initializeMutex.acquire();\n    try {\n      const extractorsStatus = await this.action.getExtractorsStatus([\n        ...getIds(this.extractors),\n        ...getIds(this.newExtractors),\n      ]);\n      this.logger.debug(\n        `Stored extractors status are [${JSON.stringify(extractorsStatus)}]`\n      );\n      // Find extractors not synced with the latest height\n      const notSyncedExtractorIds = extractorsStatus\n        .filter((es) => es.updateBlockHash != block.hash)\n        .map((es) => es.extractorId);\n      if (notSyncedExtractorIds.length > 0)\n        this.logger.debug(\n          `Old not synced extractors are ${notSyncedExtractorIds}`\n        );\n      // Find new extractors not available in database\n      const storedExtractorIds = extractorsStatus.map((es) => es.extractorId);\n      const newRegisteredExtractorIds = difference(\n        getIds(this.newExtractors),\n        storedExtractorIds\n      );\n      if (newRegisteredExtractorIds.length > 0)\n        this.logger.debug(\n          `New registered extractors are ${newRegisteredExtractorIds}`\n        );\n      // Initialize required extractors\n      const initRequiredExtractors = [\n        ...newRegisteredExtractorIds,\n        ...notSyncedExtractorIds,\n      ];\n      if (initRequiredExtractors.length > 0) {\n        this.logger.info(\n          `Initializing ${\n            initRequiredExtractors.length\n          } extractor(s) for [${this.name()}]`,\n          { initRequiredExtractors }\n        );\n        await this.initializeExtractors(initRequiredExtractors, block);\n      }\n      this.extractors.push(...this.newExtractors);\n      this.newExtractors = [];\n    } catch (e) {\n      this.logger.warn(`Initialization for extractors failed with error ${e}`);\n      success = false;\n    } finally {\n      release();\n    }\n    if (!success)\n      throw new Error(\n        `Initialization failed for new extractors ${getIds(this.newExtractors)}`\n      );\n  };\n}\n"]}

package/dist/scanner/abstract/webSocketScanner.d.ts

@@ -0,0 +1,29 @@
+import { AbstractScanner } from './scanner';
+import { Block } from '@rosen-bridge/scanner-interfaces';
+import { Mutex } from 'await-semaphore';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+declare abstract class WebSocketScanner<TransactionType> extends AbstractScanner<TransactionType> {
+    protected scannerName: string;
+    protected suffix?: string | undefined;
+    readonly maxTryBlock: number;
+    protected mutex: Mutex;
+    protected constructor(scannerName: string, logger?: AbstractLogger, maxTryBlock?: number, suffix?: string | undefined);
+    name: () => string;
+    abstract start: () => Promise<void>;
+    abstract stop: () => Promise<void>;
+    protected tryRunningFunction: (fn: () => Promise<boolean>, msg: string) => Promise<boolean>;
+    /**
+     * Handle new block arrived.
+     * save block and its transactions.
+     * @param block
+     * @param transactions
+     */
+    protected stepForward: (block: Block, transactions: Array<TransactionType>) => Promise<void>;
+    /**
+     * Handle forking a block
+     * @param block
+     */
+    protected stepBackward: (block: Block) => Promise<void>;
+}
+export { WebSocketScanner };
+//# sourceMappingURL=webSocketScanner.d.ts.map

package/dist/scanner/abstract/webSocketScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webSocketScanner.d.ts","sourceRoot":"","sources":["../../../lib/scanner/abstract/webSocketScanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAI/D,uBAAe,gBAAgB,CAC7B,eAAe,CACf,SAAQ,eAAe,CAAC,eAAe,CAAC;IAMtC,SAAS,CAAC,WAAW,EAAE,MAAM;IAG7B,SAAS,CAAC,MAAM,CAAC;IARnB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,SAAS,CAAC,KAAK,QAAe;IAE9B,SAAS,aACG,WAAW,EAAE,MAAM,EAC7B,MAAM,CAAC,EAAE,cAAc,EACvB,WAAW,GAAE,MAA8B,EACjC,MAAM,CAAC,oBAAQ;IAK3B,IAAI,eAAmE;IAEvE,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC,SAAS,CAAC,kBAAkB,OACtB,MAAM,QAAQ,OAAO,CAAC,OACrB,MAAM,KACV,QAAQ,OAAO,CAAC,CAUjB;IAEF;;;;;OAKG;IACH,SAAS,CAAC,WAAW,UACZ,KAAK,gBACE,MAAM,eAAe,CAAC,mBAkCpC;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,UAAiB,KAAK,mBAe1C;CACH;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/scanner/abstract/webSocketScanner.js

@@ -0,0 +1,89 @@
+import { AbstractScanner } from './scanner';
+import { Mutex } from 'await-semaphore';
+const DEFAULT_MAX_TRY_BLOCK = 10;
+class WebSocketScanner extends AbstractScanner {
+    scannerName;
+    suffix;
+    maxTryBlock;
+    mutex = new Mutex();
+    constructor(scannerName, logger, maxTryBlock = DEFAULT_MAX_TRY_BLOCK, suffix) {
+        super(logger);
+        this.scannerName = scannerName;
+        this.suffix = suffix;
+        this.maxTryBlock = maxTryBlock;
+    }
+    name = () => this.scannerName + (this.suffix ? `-${this.suffix}` : '');
+    tryRunningFunction = async (fn, msg) => {
+        for (let tryRound = 1; tryRound <= this.maxTryBlock; tryRound++) {
+            if (await fn())
+                return true;
+        }
+        this.logger.error(`${msg} can not be proceed in ${this.maxTryBlock} try. scanner restarted automatically`);
+        await this.stop();
+        await this.start();
+        return false;
+    };
+    /**
+     * Handle new block arrived.
+     * save block and its transactions.
+     * @param block
+     * @param transactions
+     */
+    stepForward = async (block, transactions) => {
+        const release = await this.mutex.acquire();
+        await this.tryRunningFunction(async () => {
+            try {
+                await this.forkBlock(block.height);
+                const lastSavedBlock = await this.action.getLastSavedBlock();
+                if (lastSavedBlock && block.parentHash !== lastSavedBlock.hash) {
+                    this.logger.error('It seems saved block is not valid in scanner.');
+                    return false;
+                }
+                else {
+                    await this.verifyExtractorsInitialization({
+                        height: block.height - 1,
+                        hash: block.parentHash,
+                    });
+                    const res = await this.processBlockTransactions(block, transactions);
+                    if (res === false) {
+                        this.logger.error(`Can not process block at height ${block.height}`);
+                    }
+                    else {
+                        return true;
+                    }
+                }
+            }
+            catch (e) {
+                this.logger.warn(`unknown error occurred ${e}`);
+                if (e instanceof Error && e.stack) {
+                    this.logger.warn(e.stack);
+                }
+            }
+            return false;
+        }, `Block at height ${block.height}`);
+        release();
+    };
+    /**
+     * Handle forking a block
+     * @param block
+     */
+    stepBackward = async (block) => {
+        const release = await this.mutex.acquire();
+        await this.tryRunningFunction(async () => {
+            try {
+                await this.forkBlock(block.height + 1);
+                return true;
+            }
+            catch (e) {
+                this.logger.error(`unknown error occurred ${e}`);
+                if (e instanceof Error && e.stack) {
+                    this.logger.warn(e.stack);
+                }
+            }
+            return false;
+        }, `Forking block at height ${block.height}`);
+        release();
+    };
+}
+export { WebSocketScanner };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webSocketScanner.js","sourceRoot":"","sources":["../../../lib/scanner/abstract/webSocketScanner.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractScanner } from './scanner';\nimport { Block } from '@rosen-bridge/scanner-interfaces';\nimport { Mutex } from 'await-semaphore';\nimport { AbstractLogger } from '@rosen-bridge/abstract-logger';\n\nconst DEFAULT_MAX_TRY_BLOCK = 10;\n\nabstract class WebSocketScanner<\n  TransactionType\n> extends AbstractScanner<TransactionType> {\n  readonly maxTryBlock: number;\n\n  protected mutex = new Mutex();\n\n  protected constructor(\n    protected scannerName: string,\n    logger?: AbstractLogger,\n    maxTryBlock: number = DEFAULT_MAX_TRY_BLOCK,\n    protected suffix?: string\n  ) {\n    super(logger);\n    this.maxTryBlock = maxTryBlock;\n  }\n  name = () => this.scannerName + (this.suffix ? `-${this.suffix}` : '');\n\n  abstract start: () => Promise<void>;\n  abstract stop: () => Promise<void>;\n\n  protected tryRunningFunction = async (\n    fn: () => Promise<boolean>,\n    msg: string\n  ): Promise<boolean> => {\n    for (let tryRound = 1; tryRound <= this.maxTryBlock; tryRound++) {\n      if (await fn()) return true;\n    }\n    this.logger.error(\n      `${msg} can not be proceed in ${this.maxTryBlock} try. scanner restarted automatically`\n    );\n    await this.stop();\n    await this.start();\n    return false;\n  };\n\n  /**\n   * Handle new block arrived.\n   * save block and its transactions.\n   * @param block\n   * @param transactions\n   */\n  protected stepForward = async (\n    block: Block,\n    transactions: Array<TransactionType>\n  ) => {\n    const release = await this.mutex.acquire();\n    await this.tryRunningFunction(async () => {\n      try {\n        await this.forkBlock(block.height);\n\n        const lastSavedBlock = await this.action.getLastSavedBlock();\n        if (lastSavedBlock && block.parentHash !== lastSavedBlock.hash) {\n          this.logger.error('It seems saved block is not valid in scanner.');\n          return false;\n        } else {\n          await this.verifyExtractorsInitialization({\n            height: block.height - 1,\n            hash: block.parentHash,\n          });\n          const res = await this.processBlockTransactions(block, transactions);\n          if (res === false) {\n            this.logger.error(\n              `Can not process block at height ${block.height}`\n            );\n          } else {\n            return true;\n          }\n        }\n      } catch (e) {\n        this.logger.warn(`unknown error occurred ${e}`);\n        if (e instanceof Error && e.stack) {\n          this.logger.warn(e.stack);\n        }\n      }\n      return false;\n    }, `Block at height ${block.height}`);\n    release();\n  };\n\n  /**\n   * Handle forking a block\n   * @param block\n   */\n  protected stepBackward = async (block: Block) => {\n    const release = await this.mutex.acquire();\n    await this.tryRunningFunction(async () => {\n      try {\n        await this.forkBlock(block.height + 1);\n        return true;\n      } catch (e) {\n        this.logger.error(`unknown error occurred ${e}`);\n        if (e instanceof Error && e.stack) {\n          this.logger.warn(e.stack);\n        }\n      }\n      return false;\n    }, `Forking block at height ${block.height}`);\n    release();\n  };\n}\n\nexport { WebSocketScanner };\n"]}