@my-packages-changeit/abstract-scanner 2.0.3

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

@@ -0,0 +1,134 @@
+export class migration1747655941239 {
+    name = 'migration1747655941239';
+    async up(queryRunner) {
+        // Update block_entity table for cardano
+        await queryRunner.query(`
+      UPDATE block_entity 
+      SET scanner = 'cardano' 
+      WHERE scanner IN (
+        'cardano-BlockFrost',
+        'cardano-graphql',
+        'cardano-koios',
+        'cardano-ogmios'
+      )
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity 
+      SET scanner = 'bitcoin' 
+      WHERE scanner IN (
+        'bitcoin-esplora',
+        'bitcoin-rpc'
+      )
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity
+      SET scanner = 'ethereum'
+      WHERE scanner = 'ethereum-evm-rpc';
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity
+      SET scanner = 'binance'
+      WHERE scanner = 'binance-evm-rpc';
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity 
+      SET scanner = 'doge' 
+      WHERE scanner IN (
+        'doge-esplora',
+        'doge-rpc'
+      )
+    `);
+        // Update extractor_status_entity table for cardano
+        await queryRunner.query(`
+      UPDATE extractor_status_entity 
+      SET scannerId = 'cardano' 
+      WHERE scannerId IN (
+        'cardano-BlockFrost',
+        'cardano-graphql',
+        'cardano-koios',
+        'cardano-ogmios'
+      )
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity 
+      SET scannerId = 'bitcoin' 
+      WHERE scannerId IN (
+        'bitcoin-esplora',
+        'bitcoin-rpc'
+      )
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity
+      SET scannerId = 'ethereum'
+      WHERE scannerId = 'ethereum-evm-rpc';
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity
+      SET scannerId = 'binance'
+      WHERE scannerId = 'binance-evm-rpc';
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity 
+      SET scannerId = 'doge' 
+      WHERE scannerId IN (
+        'doge-esplora',
+        'doge-rpc'
+      )
+    `);
+    }
+    async down(queryRunner) {
+        // Revert block_entity table
+        await queryRunner.query(`
+      UPDATE block_entity 
+      SET scanner = 'cardano-koios' 
+      WHERE scanner = 'cardano'
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity 
+      SET scanner = 'bitcoin-esplora' 
+      WHERE scanner = 'bitcoin'
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity
+      SET scanner = 'ethereum-evm-rpc'
+      WHERE scanner = 'ethereum';
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity
+      SET scanner = 'binance-evm-rpc'
+      WHERE scanner = 'binance';
+    `);
+        await queryRunner.query(`
+      UPDATE block_entity 
+      SET scanner = 'doge-esplora' 
+      WHERE scanner = 'doge'
+    `);
+        // Revert extractor_status_entity table
+        await queryRunner.query(`
+      UPDATE extractor_status_entity 
+      SET scannerId = 'cardano-koios' 
+      WHERE scannerId = 'cardano'
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity 
+      SET scannerId = 'bitcoin-esplora' 
+      WHERE scannerId = 'bitcoin'
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity
+      SET scannerId = 'ethereum-evm-rpc'
+      WHERE scannerId = 'ethereum';
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity
+      SET scannerId = 'binance-evm-rpc'
+      WHERE scannerId = 'binance';
+    `);
+        await queryRunner.query(`
+      UPDATE extractor_status_entity 
+      SET scannerId = 'doge-esplora' 
+      WHERE scannerId = 'doge'
+    `);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,78 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+import { AbstractNetworkConnector, Block } from '@rosen-bridge/scanner-interfaces';
+import { BlockEntity } from '../../entities/blockEntity';
+import { AbstractScanner } from './scanner';
+declare abstract class GeneralScanner<TransactionType> extends AbstractScanner<TransactionType> {
+    private scannerName;
+    private dataSource;
+    private network;
+    private blockRetrieveGap;
+    private suffix?;
+    private heightGap;
+    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, heightGap?: number);
+    /**
+     * 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 the 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;
+    /**
+     * Checks if any registered extractor detects an event
+     * within the given block height range.
+     *
+     * @param {number} fromHeight - The starting block height to check.
+     * @param {number} toHeight - The ending block height to check.
+     * @returns {Promise<boolean>} True if at least one event is found,
+     * false otherwise.
+     */
+    protected checkExtractorsForEvents: (fromHeight: number, toHeight: number) => Promise<boolean>;
+    /**
+     * worker function that synchronizes the database with the blockchain.
+     * It handles scanner initialization, fork resolution,
+     * step-by-step block processing,
+     * and fast-forwarding when no events are detected.
+     */
+    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,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE5D,OAAO,EACL,wBAAwB,EACxB,KAAK,EACN,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,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;IACf,OAAO,CAAC,SAAS;IAbnB,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,EAAE,MAAM,YAAA,EACf,SAAS,SAAI;IAgBvB;;;OAGG;IACH,SAAS,CAAC,aAAa,QAAO,OAAO,CAAC,KAAK,CAAC,CAE1C;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,QAAa,OAAO,CAAC,OAAO,CAAC,CAUjD;IAEF;;;OAGG;IACH,SAAS,CAAC,4BAA4B,GAAU,WAAW,MAAM,mBAK/D;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,GAAU,OAAO,KAAK,kCA0B1C;IAEF;;;;OAIG;IACH,SAAS,CAAC,WAAW,GAAU,gBAAgB,WAAW,mBAuCxD;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,sBAepB;IAEF;;;;OAIG;IACH,SAAS,CAAC,UAAU,6BAYlB;IAEF;;;OAGG;IACI,uBAAuB,QAAO,MAAM,GAAG,SAAS,CAC3B;IAE5B;;;;;;;;OAQG;IACH,SAAS,CAAC,wBAAwB,GAChC,YAAY,MAAM,EAClB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAAC,CASjB;IAEF;;;;;OAKG;IACH,MAAM,sBAwBJ;CACH;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/scanner/abstract/generalScanner.js

@@ -0,0 +1,210 @@
+import JsonBI from '@rosen-bridge/json-bigint';
+import { BlockDbAction } from '../action';
+import { AbstractScanner } from './scanner';
+class GeneralScanner extends AbstractScanner {
+    scannerName;
+    dataSource;
+    network;
+    blockRetrieveGap;
+    suffix;
+    heightGap;
+    initialHeight;
+    blockChainLastHeight = undefined;
+    name = () => this.scannerName + (this.suffix ? `-${this.suffix}` : '');
+    constructor(scannerName, dataSource, initialHeight, network, blockRetrieveGap = 0, logger, suffix, heightGap = 1) {
+        super(logger);
+        this.scannerName = scannerName;
+        this.dataSource = dataSource;
+        this.network = network;
+        this.blockRetrieveGap = blockRetrieveGap;
+        this.suffix = suffix;
+        this.heightGap = heightGap;
+        /**
+         * 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.suffix = suffix;
+        this.action = new BlockDbAction(this.dataSource, this.name(), this.logger.child('BlockDbAction'));
+    }
+    /**
+     * 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, block.height);
+        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 the database
+     */
+    stepForward = async (lastSavedBlock) => {
+        const currentHeight = await this.network.getCurrentHeight();
+        const firstBlock = await this.action.getFirstSavedBlock();
+        if (!firstBlock || firstBlock.height >= currentHeight) {
+            return;
+        }
+        let step = Math.min(this.heightGap, currentHeight - lastSavedBlock.height);
+        let stopHeight = lastSavedBlock.height + step;
+        for (let height = lastSavedBlock.height; height < currentHeight;) {
+            if (step > 1 &&
+                (await this.checkExtractorsForEvents(height, height + step))) {
+                stopHeight = height + step;
+                step = 1;
+            }
+            height += step;
+            const block = await this.network.getBlockAtHeight(height);
+            if (block.parentHash != lastSavedBlock.hash && step === 1) {
+                this.logger.debug(`Invalid block at height ${lastSavedBlock.height + 1}. Block info 
+            is [${JsonBI.stringify(block)} and the expected parent hash is [${lastSavedBlock.hash}]`);
+                break;
+            }
+            const savedBlock = await this.processBlock(block);
+            if (typeof savedBlock === 'boolean') {
+                break;
+            }
+            else {
+                lastSavedBlock = savedBlock;
+            }
+            if (height == stopHeight) {
+                step = Math.min(this.heightGap, currentHeight - height);
+                stopHeight = height + step;
+            }
+        }
+    };
+    /**
+     * 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;
+    /**
+     * Checks if any registered extractor detects an event
+     * within the given block height range.
+     *
+     * @param {number} fromHeight - The starting block height to check.
+     * @param {number} toHeight - The ending block height to check.
+     * @returns {Promise<boolean>} True if at least one event is found,
+     * false otherwise.
+     */
+    checkExtractorsForEvents = async (fromHeight, toHeight) => {
+        for (const extractor of this.extractors) {
+            const hasEvent = await extractor.hasEventInHeightRange(fromHeight, toHeight);
+            if (hasEvent)
+                return true;
+        }
+        return false;
+    };
+    /**
+     * worker function that synchronizes the database with the blockchain.
+     * It handles scanner initialization, fork resolution,
+     * step-by-step block processing,
+     * and fast-forwarding when no events are detected.
+     */
+    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}`);
+            if (e instanceof Error && e.stack) {
+                this.logger.error(`error stack: ${e.stack}`);
+            }
+        }
+    };
+}
+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 { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { DataSource } from '@rosen-bridge/extended-typeorm';\nimport JsonBI from '@rosen-bridge/json-bigint';\nimport {\n  AbstractNetworkConnector,\n  Block,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport { BlockEntity } from '../../entities/blockEntity';\nimport { BlockDbAction } from '../action';\nimport { AbstractScanner } from './scanner';\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    private heightGap = 1,\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.suffix = suffix;\n    this.action = new BlockDbAction(\n      this.dataSource,\n      this.name(),\n      this.logger.child('BlockDbAction'),\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\n   * 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, block.height);\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 \n          ${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\n   * transactions.\n   * @param lastSavedBlock last saved block entity in the database\n   */\n  protected stepForward = async (lastSavedBlock: BlockEntity) => {\n    const currentHeight = await this.network.getCurrentHeight();\n    const firstBlock = await this.action.getFirstSavedBlock();\n\n    if (!firstBlock || firstBlock.height >= currentHeight) {\n      return;\n    }\n    let step = Math.min(this.heightGap, currentHeight - lastSavedBlock.height);\n    let stopHeight = lastSavedBlock.height + step;\n    for (let height = lastSavedBlock.height; height < currentHeight; ) {\n      if (\n        step > 1 &&\n        (await this.checkExtractorsForEvents(height, height + step))\n      ) {\n        stopHeight = height + step;\n        step = 1;\n      }\n      height += step;\n      const block = await this.network.getBlockAtHeight(height);\n      if (block.parentHash != lastSavedBlock.hash && step === 1) {\n        this.logger.debug(\n          `Invalid block at height ${lastSavedBlock.height + 1}. Block info \n            is [${JsonBI.stringify(\n              block,\n            )} and the expected parent hash is [${lastSavedBlock.hash}]`,\n        );\n        break;\n      }\n      const savedBlock = await this.processBlock(block);\n      if (typeof savedBlock === 'boolean') {\n        break;\n      } else {\n        lastSavedBlock = savedBlock;\n      }\n      if (height == stopHeight) {\n        step = Math.min(this.heightGap, currentHeight - height);\n        stopHeight = height + step;\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   * Checks if any registered extractor detects an event\n   * within the given block height range.\n   *\n   * @param {number} fromHeight - The starting block height to check.\n   * @param {number} toHeight - The ending block height to check.\n   * @returns {Promise<boolean>} True if at least one event is found,\n   * false otherwise.\n   */\n  protected checkExtractorsForEvents = async (\n    fromHeight: number,\n    toHeight: number,\n  ): Promise<boolean> => {\n    for (const extractor of this.extractors) {\n      const hasEvent = await extractor.hasEventInHeightRange(\n        fromHeight,\n        toHeight,\n      );\n      if (hasEvent) return true;\n    }\n    return false;\n  };\n\n  /**\n   * worker function that synchronizes the database with the blockchain.\n   * It handles scanner initialization, fork resolution,\n   * step-by-step block processing,\n   * and fast-forwarding when no events are detected.\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      if (e instanceof Error && e.stack) {\n        this.logger.error(`error stack: ${e.stack}`);\n      }\n    }\n  };\n}\n\nexport { GeneralScanner };\n"]}

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

@@ -0,0 +1,49 @@
+import { AbstractExtractor } from '@rosen-bridge/abstract-extractor';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { ObjectLiteral } from '@rosen-bridge/extended-typeorm';
+import { Block, BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { Mutex } from '@rosen-bridge/semaphore';
+import { BlockDbAction } from '../action';
+export declare abstract class AbstractScanner<TransactionType> {
+    action: BlockDbAction;
+    extractors: Array<AbstractExtractor<TransactionType, ObjectLiteral>>;
+    newExtractors: Array<AbstractExtractor<TransactionType, ObjectLiteral>>;
+    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, ObjectLiteral>) => Promise<void>;
+    /**
+     * remove an extractor from scanner
+     * @param extractor
+     */
+    removeExtractor: (extractor: AbstractExtractor<TransactionType, ObjectLiteral>) => 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":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,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,EAAE,aAAa,CAAC,CAAC,CAAC;IACrE,aAAa,EAAE,KAAK,CAAC,iBAAiB,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,CAAC;IACxE,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,GAAU,QAAQ,MAAM,mBAiBzC;IAEF;;;;OAIG;IACH,SAAS,CAAC,wBAAwB,GAChC,OAAO,KAAK,EACZ,cAAc,KAAK,CAAC,eAAe,CAAC,kDAyBpC;IAEF;;;OAGG;IACH,iBAAiB,GACf,WAAW,iBAAiB,CAAC,eAAe,EAAE,aAAa,CAAC,KAC3D,OAAO,CAAC,IAAI,CAAC,CAmBd;IAEF;;;OAGG;IACH,eAAe,GACb,WAAW,iBAAiB,CAAC,eAAe,EAAE,aAAa,CAAC,KAC3D,OAAO,CAAC,IAAI,CAAC,CAQd;IAEF;;;;OAIG;IACH,OAAO,CAAC,oBAAoB,CAkB1B;IAEF;;;;OAIG;IACH,SAAS,CAAC,8BAA8B,GAAU,OAAO,SAAS,mBAqDhE;CACH"}