@my-packages-changeit/abstract-scanner 2.0.3

package/dist/scanner/abstract/scanner.js

@@ -0,0 +1,142 @@
+import { difference, remove } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { Mutex } from '@rosen-bridge/semaphore';
+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) {
+                await extractor.forkBlock(lastBlock.hash);
+            }
+            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.initializeData(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}]`);
+        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 = [];
+        }
+        finally {
+            release();
+        }
+    };
+}
+//# 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 { difference, remove } from 'lodash-es';\n\nimport { AbstractExtractor } from '@rosen-bridge/abstract-extractor';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { ObjectLiteral } from '@rosen-bridge/extended-typeorm';\nimport { Block, BlockInfo } from '@rosen-bridge/scanner-interfaces';\nimport { Mutex } from '@rosen-bridge/semaphore';\n\nimport { BlockDbAction } from '../action';\n\nexport abstract class AbstractScanner<TransactionType> {\n  action: BlockDbAction;\n  extractors: Array<AbstractExtractor<TransactionType, ObjectLiteral>>;\n  newExtractors: Array<AbstractExtractor<TransactionType, ObjectLiteral>>;\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        await extractor.forkBlock(lastBlock.hash);\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, ObjectLiteral>,\n  ): Promise<void> => {\n    const notRegisteredIn = (\n      extractors: Array<AbstractExtractor<TransactionType, ObjectLiteral>>,\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, ObjectLiteral>,\n  ): Promise<void> => {\n    const removeFn = (ex: AbstractExtractor<TransactionType, ObjectLiteral>) =>\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.initializeData(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 = (\n      extractors: Array<AbstractExtractor<TransactionType, ObjectLiteral>>,\n    ) => {\n      return extractors.map((extractor) => extractor.getId());\n    };\n    this.logger.debug(`Initializing extractors for block [${block.height}]`);\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    } finally {\n      release();\n    }\n  };\n}\n"]}

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

@@ -0,0 +1,29 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { Block } from '@rosen-bridge/scanner-interfaces';
+import { Mutex } from '@rosen-bridge/semaphore';
+import { AbstractScanner } from './scanner';
+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, releaseMutex: () => void) => 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,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAI5C,uBAAe,gBAAgB,CAC7B,eAAe,CACf,SAAQ,eAAe,CAAC,eAAe,CAAC;IAMtC,SAAS,CAAC,WAAW,EAAE,MAAM;IAG7B,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM;IAR3B,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,EAAE,MAAM,YAAA;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,GAC1B,IAAI,MAAM,OAAO,CAAC,OAAO,CAAC,EAC1B,KAAK,MAAM,EACX,cAAc,MAAM,IAAI,KACvB,OAAO,CAAC,OAAO,CAAC,CAWjB;IAEF;;;;;OAKG;IACH,SAAS,CAAC,WAAW,GACnB,OAAO,KAAK,EACZ,cAAc,KAAK,CAAC,eAAe,CAAC,mBAyCpC;IAEF;;;OAGG;IACH,SAAS,CAAC,YAAY,GAAU,OAAO,KAAK,mBAmB1C;CACH;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/scanner/abstract/webSocketScanner.js

@@ -0,0 +1,90 @@
+import { Mutex } from '@rosen-bridge/semaphore';
+import { AbstractScanner } from './scanner';
+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, releaseMutex) => {
+        for (let tryRound = 1; tryRound <= this.maxTryBlock; tryRound++) {
+            if (await fn())
+                return true;
+        }
+        releaseMutex();
+        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);
+        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);
+        release();
+    };
+}
+export { WebSocketScanner };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webSocketScanner.js","sourceRoot":"","sources":["../../../lib/scanner/abstract/webSocketScanner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC,MAAe,gBAEb,SAAQ,eAAgC;IAM5B;IAGA;IARH,WAAW,CAAS;IAEnB,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;IAE9B,YACY,WAAmB,EAC7B,MAAuB,EACvB,cAAsB,qBAAqB,EACjC,MAAe;QAEzB,KAAK,CAAC,MAAM,CAAC,CAAC;QALJ,gBAAW,GAAX,WAAW,CAAQ;QAGnB,WAAM,GAAN,MAAM,CAAS;QAGzB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;IACD,IAAI,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAK7D,kBAAkB,GAAG,KAAK,EAClC,EAA0B,EAC1B,GAAW,EACX,YAAwB,EACN,EAAE;QACpB,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,QAAQ,IAAI,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,CAAC;YAChE,IAAI,MAAM,EAAE,EAAE;gBAAE,OAAO,IAAI,CAAC;QAC9B,CAAC;QACD,YAAY,EAAE,CAAC;QACf,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,GAAG,GAAG,0BAA0B,IAAI,CAAC,WAAW,uCAAuC,CACxF,CAAC;QACF,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACnB,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF;;;;;OAKG;IACO,WAAW,GAAG,KAAK,EAC3B,KAAY,EACZ,YAAoC,EACpC,EAAE;QACF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3C,MAAM,IAAI,CAAC,kBAAkB,CAC3B,KAAK,IAAI,EAAE;YACT,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAEnC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;gBAC7D,IAAI,cAAc,IAAI,KAAK,CAAC,UAAU,KAAK,cAAc,CAAC,IAAI,EAAE,CAAC;oBAC/D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAC;oBACnE,OAAO,KAAK,CAAC;gBACf,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,CAAC,8BAA8B,CAAC;wBACxC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC;wBACxB,IAAI,EAAE,KAAK,CAAC,UAAU;qBACvB,CAAC,CAAC;oBACH,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAC7C,KAAK,EACL,YAAY,CACb,CAAC;oBACF,IAAI,GAAG,KAAK,KAAK,EAAE,CAAC;wBAClB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,mCAAmC,KAAK,CAAC,MAAM,EAAE,CAClD,CAAC;oBACJ,CAAC;yBAAM,CAAC;wBACN,OAAO,IAAI,CAAC;oBACd,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC;gBAChD,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;oBAClC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,EACD,mBAAmB,KAAK,CAAC,MAAM,EAAE,EACjC,OAAO,CACR,CAAC;QACF,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IAEF;;;OAGG;IACO,YAAY,GAAG,KAAK,EAAE,KAAY,EAAE,EAAE;QAC9C,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3C,MAAM,IAAI,CAAC,kBAAkB,CAC3B,KAAK,IAAI,EAAE;YACT,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;gBACvC,OAAO,IAAI,CAAC;YACd,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC;gBACjD,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;oBAClC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,EACD,2BAA2B,KAAK,CAAC,MAAM,EAAE,EACzC,OAAO,CACR,CAAC;QACF,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;CACH;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport { Block } from '@rosen-bridge/scanner-interfaces';\nimport { Mutex } from '@rosen-bridge/semaphore';\n\nimport { AbstractScanner } from './scanner';\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    releaseMutex: () => void,\n  ): Promise<boolean> => {\n    for (let tryRound = 1; tryRound <= this.maxTryBlock; tryRound++) {\n      if (await fn()) return true;\n    }\n    releaseMutex();\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(\n      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(\n              block,\n              transactions,\n            );\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      },\n      `Block at height ${block.height}`,\n      release,\n    );\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(\n      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      },\n      `Forking block at height ${block.height}`,\n      release,\n    );\n    release();\n  };\n}\n\nexport { WebSocketScanner };\n"]}

package/dist/scanner/action.d.ts

@@ -0,0 +1,83 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource, DeleteResult, Repository } from '@rosen-bridge/extended-typeorm';
+import { Block } from '@rosen-bridge/scanner-interfaces';
+import { BlockEntity } from '../entities/blockEntity';
+import { ExtractorStatusEntity } from '../entities/extractorStatusEntity';
+export declare class BlockDbAction {
+    readonly blockRepository: Repository<BlockEntity>;
+    readonly extractorStatusRepository: Repository<ExtractorStatusEntity>;
+    readonly dataSource: DataSource;
+    readonly scannerName: string;
+    readonly logger: AbstractLogger;
+    constructor(dataSource: DataSource, scannerName: string, logger?: AbstractLogger);
+    readonly name: () => string;
+    /**
+     * get last saved block
+     * @return Promise<BlockEntity or undefined>
+     */
+    getLastSavedBlock: () => Promise<BlockEntity | undefined>;
+    /**
+     * get last n stored blocks in database
+     * @param skip
+     * @param count
+     */
+    getLastSavedBlocks: (skip: number, count: number) => Promise<Array<BlockEntity>>;
+    /**
+     * get first saved block
+     * @return Promise<BlockEntity or undefined>
+     */
+    getFirstSavedBlock: () => Promise<BlockEntity | undefined>;
+    /**
+     * get block hash and height
+     * @param height
+     * @param status
+     * @return Promise<BlockEntity|undefined>
+     */
+    getBlockAtHeight: (height: number, status?: string) => Promise<BlockEntity | undefined>;
+    /**
+     * get block with entered blockhash
+     * @param hash
+     * @param status
+     */
+    getBlockWithHash: (hash: string, status?: string) => Promise<BlockEntity | null>;
+    /**
+     * it deletes every block that more than or equal height
+     * @param height
+     * @return Promise<DeleteResult>
+     */
+    removeBlocksFromHeight: (height: number) => Promise<DeleteResult>;
+    /**
+     * store a block into database.
+     * @param block
+     */
+    saveBlock: (block: Block) => Promise<BlockEntity | boolean>;
+    /**
+     * Update status of a block to proceed
+     * @param height: height of expected block
+     */
+    updateBlockStatus: (height: number, blockHash: string, extractorIds: string[]) => Promise<boolean>;
+    /**
+     * Update status of a block to processing in case of fork
+     * @param height: height of expected block
+     */
+    revertBlockStatus: (height: number, parentHash: string, extractorIds: string[]) => Promise<boolean>;
+    /**
+     * Insert a newly initialized extractor or update an existing extractor status
+     * @param extractorId
+     * @param height
+     * @returns
+     */
+    updateOrInsertExtractorStatus: (extractorId: string, height: number, blockHash: string) => Promise<{
+        scannerId: string;
+        extractorId: string;
+        updateHeight: number;
+        updateBlockHash: string;
+    } & ExtractorStatusEntity>;
+    /**
+     * Return extractors` status specified by id
+     * @param extractorIds
+     * @returns extractors` status
+     */
+    getExtractorsStatus: (extractorIds: string[]) => Promise<ExtractorStatusEntity[]>;
+}
+//# sourceMappingURL=action.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../lib/scanner/action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,UAAU,EACV,YAAY,EAEZ,UAAU,EAEX,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAuB,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAE1E,qBAAa,aAAa;IACxB,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAClD,QAAQ,CAAC,yBAAyB,EAAE,UAAU,CAAC,qBAAqB,CAAC,CAAC;IACtE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;gBAG9B,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,cAAc;IAWzB,QAAQ,CAAC,IAAI,eAA0B;IAEvC;;;OAGG;IACH,iBAAiB,QAAa,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAW5D;IAEF;;;;OAIG;IACH,kBAAkB,GAChB,MAAM,MAAM,EACZ,OAAO,MAAM,KACZ,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAO5B;IAEF;;;OAGG;IACH,kBAAkB,QAAa,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAW7D;IAEF;;;;;OAKG;IACH,gBAAgB,GACd,QAAQ,MAAM,EACd,SAAQ,MAAgB,KACvB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAWjC;IAEF;;;;OAIG;IACH,gBAAgB,GAAU,MAAM,MAAM,EAAE,SAAQ,MAAgB,iCAM9D;IAEF;;;;OAIG;IACH,sBAAsB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,YAAY,CAAC,CAMpE;IAEF;;;OAGG;IACH,SAAS,GAAU,OAAO,KAAK,KAAG,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,CA0C9D;IAEF;;;OAGG;IACH,iBAAiB,GACf,QAAQ,MAAM,EACd,WAAW,MAAM,EACjB,cAAc,MAAM,EAAE,KACrB,OAAO,CAAC,OAAO,CAAC,CAqCjB;IAEF;;;OAGG;IACH,iBAAiB,GACf,QAAQ,MAAM,EACd,YAAY,MAAM,EAClB,cAAc,MAAM,EAAE,KACrB,OAAO,CAAC,OAAO,CAAC,CAsCjB;IAEF;;;;;OAKG;IACH,6BAA6B,GAC3B,aAAa,MAAM,EACnB,QAAQ,MAAM,EACd,WAAW,MAAM;;;;;+BAgBjB;IAEF;;;;OAIG;IACH,mBAAmB,GACjB,cAAc,MAAM,EAAE,KACrB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAKjC;CACH"}