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

package/dist/scanner/action.d.ts

@@ -0,0 +1,83 @@
+import { BlockEntity } from '../entities/blockEntity';
+import { DataSource, DeleteResult, Repository } from '@rosen-bridge/extended-typeorm';
+import { Block } from '@rosen-bridge/scanner-interfaces';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+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,WAAW,EAAuB,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EACL,UAAU,EACV,YAAY,EAEZ,UAAU,EAEX,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AACzD,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,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,QAAQ,WAAW,GAAG,SAAS,CAAC,CAW5D;IAEF;;;;OAIG;IACH,kBAAkB,SACV,MAAM,SACL,MAAM,KACZ,QAAQ,MAAM,WAAW,CAAC,CAAC,CAO5B;IAEF;;;OAGG;IACH,kBAAkB,QAAa,QAAQ,WAAW,GAAG,SAAS,CAAC,CAW7D;IAEF;;;;;OAKG;IACH,gBAAgB,WACN,MAAM,WACN,MAAM,KACb,QAAQ,WAAW,GAAG,SAAS,CAAC,CAWjC;IAEF;;;;OAIG;IACH,gBAAgB,SAAgB,MAAM,WAAU,MAAM,iCAMpD;IAEF;;;;OAIG;IACH,sBAAsB,WAAkB,MAAM,KAAG,QAAQ,YAAY,CAAC,CAMpE;IAEF;;;OAGG;IACH,SAAS,UAAiB,KAAK,KAAG,QAAQ,WAAW,GAAG,OAAO,CAAC,CA0C9D;IAEF;;;OAGG;IACH,iBAAiB,WACP,MAAM,aACH,MAAM,gBACH,MAAM,EAAE,KACrB,QAAQ,OAAO,CAAC,CAqCjB;IAEF;;;OAGG;IACH,iBAAiB,WACP,MAAM,cACF,MAAM,gBACJ,MAAM,EAAE,KACrB,QAAQ,OAAO,CAAC,CAsCjB;IAEF;;;;;OAKG;IACH,6BAA6B,gBACd,MAAM,UACX,MAAM,aACH,MAAM;;;;;+BAgBjB;IAEF;;;;OAIG;IACH,mBAAmB,iBACH,MAAM,EAAE,KACrB,QAAQ,qBAAqB,EAAE,CAAC,CAKjC;CACH"}

package/dist/scanner/action.js

@@ -0,0 +1,251 @@
+import { BlockEntity, PROCEED, PROCESSING } from '../entities/blockEntity';
+import { MoreThanOrEqual, In, } from '@rosen-bridge/extended-typeorm';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { ExtractorStatusEntity } from '../entities/extractorStatusEntity';
+export class BlockDbAction {
+    blockRepository;
+    extractorStatusRepository;
+    dataSource;
+    scannerName;
+    logger;
+    constructor(dataSource, scannerName, logger) {
+        this.blockRepository = dataSource.getRepository(BlockEntity);
+        this.extractorStatusRepository = dataSource.getRepository(ExtractorStatusEntity);
+        this.dataSource = dataSource;
+        this.scannerName = scannerName;
+        this.logger = logger ? logger : new DummyLogger();
+    }
+    name = () => this.scannerName;
+    /**
+     * get last saved block
+     * @return Promise<BlockEntity or undefined>
+     */
+    getLastSavedBlock = async () => {
+        const lastBlock = await this.blockRepository.find({
+            where: { status: PROCEED, scanner: this.name() },
+            order: { height: 'DESC' },
+            take: 1,
+        });
+        if (lastBlock.length !== 0) {
+            return lastBlock[0];
+        }
+        else {
+            return undefined;
+        }
+    };
+    /**
+     * get last n stored blocks in database
+     * @param skip
+     * @param count
+     */
+    getLastSavedBlocks = async (skip, count) => {
+        return await this.blockRepository.find({
+            where: { status: PROCEED, scanner: this.name() },
+            order: { height: 'DESC' },
+            skip: skip,
+            take: count,
+        });
+    };
+    /**
+     * get first saved block
+     * @return Promise<BlockEntity or undefined>
+     */
+    getFirstSavedBlock = async () => {
+        const lastBlock = await this.blockRepository.find({
+            where: { status: PROCEED, scanner: this.name() },
+            order: { height: 'ASC' },
+            take: 1,
+        });
+        if (lastBlock.length !== 0) {
+            return lastBlock[0];
+        }
+        else {
+            return undefined;
+        }
+    };
+    /**
+     * get block hash and height
+     * @param height
+     * @param status
+     * @return Promise<BlockEntity|undefined>
+     */
+    getBlockAtHeight = async (height, status = PROCEED) => {
+        const block = await this.blockRepository.findOneBy({
+            status: status,
+            height: height,
+            scanner: this.name(),
+        });
+        if (block !== null) {
+            return block;
+        }
+        else {
+            return undefined;
+        }
+    };
+    /**
+     * get block with entered blockhash
+     * @param hash
+     * @param status
+     */
+    getBlockWithHash = async (hash, status = PROCEED) => {
+        return this.blockRepository.findOneBy({
+            hash: hash,
+            status: status,
+            scanner: this.name(),
+        });
+    };
+    /**
+     * it deletes every block that more than or equal height
+     * @param height
+     * @return Promise<DeleteResult>
+     */
+    removeBlocksFromHeight = async (height) => {
+        this.logger.debug(`Removing blocks from height ${height}`);
+        return await this.blockRepository.delete({
+            height: MoreThanOrEqual(height),
+            scanner: this.name(),
+        });
+    };
+    /**
+     * store a block into database.
+     * @param block
+     */
+    saveBlock = async (block) => {
+        try {
+            const instance = await this.blockRepository.findOneBy({
+                height: block.height,
+                scanner: this.name(),
+            });
+            const date = new Date(block.timestamp * 1000);
+            const blockInfo = {
+                height: block.height,
+                hash: block.hash,
+                parentHash: block.parentHash,
+                status: PROCESSING,
+                scanner: this.name(),
+                extra: block.extra,
+                timestamp: block.timestamp,
+                year: date.getFullYear(),
+                month: date.getMonth() + 1,
+                day: date.getDate(),
+            };
+            if (!instance) {
+                this.logger.debug(`Inserting block with info: ${JSON.stringify(blockInfo)}`);
+                await this.blockRepository.insert(blockInfo);
+            }
+            else {
+                this.logger.debug(`Updating block with info: ${JSON.stringify(blockInfo)}`);
+                await this.blockRepository.update({ height: block.height, scanner: this.name() }, blockInfo);
+            }
+            const res = await this.blockRepository.findOneBy({
+                height: block.height,
+                scanner: this.name(),
+            });
+            return res ? res : false;
+        }
+        catch (exp) {
+            this.logger.error(`An error occurred during save new block: ${exp}`);
+            return false;
+        }
+    };
+    /**
+     * Update status of a block to proceed
+     * @param height: height of expected block
+     */
+    updateBlockStatus = async (height, blockHash, extractorIds) => {
+        let success = true;
+        this.logger.debug(`Block at height ${height} has been proceed in scanner ${this.name()}, updating status`);
+        const runner = this.dataSource.createQueryRunner();
+        await runner.connect();
+        await runner.startTransaction();
+        try {
+            await runner.manager.getRepository(BlockEntity).update({
+                height: height,
+                status: PROCESSING,
+                scanner: this.name(),
+            }, {
+                status: PROCEED,
+            });
+            this.logger.debug('Updating extractors status', {
+                extractorIds,
+            });
+            await runner.manager
+                .getRepository(ExtractorStatusEntity)
+                .update({ extractorId: In(extractorIds), scannerId: this.name() }, { updateHeight: height, updateBlockHash: blockHash });
+            await runner.commitTransaction();
+        }
+        catch (e) {
+            await runner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await runner.release();
+        }
+        return success;
+    };
+    /**
+     * Update status of a block to processing in case of fork
+     * @param height: height of expected block
+     */
+    revertBlockStatus = async (height, parentHash, extractorIds) => {
+        let success = true;
+        const runner = this.dataSource.createQueryRunner();
+        await runner.connect();
+        await runner.startTransaction();
+        try {
+            this.logger.debug(`Reverting block status at height ${height}`);
+            await runner.manager.getRepository(BlockEntity).update({
+                height: height,
+                status: PROCEED,
+                scanner: this.name(),
+            }, {
+                status: PROCESSING,
+            });
+            this.logger.debug(`Reverting extractors update height to previous block at height ${height - 1}`);
+            await runner.manager
+                .getRepository(ExtractorStatusEntity)
+                .update({ extractorId: In(extractorIds), scannerId: this.name() }, { updateHeight: height - 1, updateBlockHash: parentHash });
+            await runner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.warn(`An Error occurred while reverting block status: ${e}`);
+            await runner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await runner.release();
+        }
+        return success;
+    };
+    /**
+     * Insert a newly initialized extractor or update an existing extractor status
+     * @param extractorId
+     * @param height
+     * @returns
+     */
+    updateOrInsertExtractorStatus = async (extractorId, height, blockHash) => {
+        this.logger.debug('Inserting new extractor status or Updating existing resynced extractor status', {
+            extractorId,
+            height,
+            blockHash,
+        });
+        return await this.extractorStatusRepository.save({
+            scannerId: this.name(),
+            extractorId,
+            updateHeight: height,
+            updateBlockHash: blockHash,
+        });
+    };
+    /**
+     * Return extractors` status specified by id
+     * @param extractorIds
+     * @returns extractors` status
+     */
+    getExtractorsStatus = async (extractorIds) => {
+        return await this.extractorStatusRepository.findBy({
+            scannerId: this.name(),
+            extractorId: In(extractorIds),
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.js","sourceRoot":"","sources":["../../lib/scanner/action.ts"],"names":[],"mappings":"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","sourcesContent":["import { BlockEntity, PROCEED, PROCESSING } from '../entities/blockEntity';\nimport {\n  DataSource,\n  DeleteResult,\n  MoreThanOrEqual,\n  Repository,\n  In,\n} from '@rosen-bridge/extended-typeorm';\nimport { Block } from '@rosen-bridge/scanner-interfaces';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { ExtractorStatusEntity } from '../entities/extractorStatusEntity';\n\nexport class BlockDbAction {\n  readonly blockRepository: Repository<BlockEntity>;\n  readonly extractorStatusRepository: Repository<ExtractorStatusEntity>;\n  readonly dataSource: DataSource;\n  readonly scannerName: string;\n  readonly logger: AbstractLogger;\n\n  constructor(\n    dataSource: DataSource,\n    scannerName: string,\n    logger?: AbstractLogger\n  ) {\n    this.blockRepository = dataSource.getRepository(BlockEntity);\n    this.extractorStatusRepository = dataSource.getRepository(\n      ExtractorStatusEntity\n    );\n    this.dataSource = dataSource;\n    this.scannerName = scannerName;\n    this.logger = logger ? logger : new DummyLogger();\n  }\n\n  readonly name = () => this.scannerName;\n\n  /**\n   * get last saved block\n   * @return Promise<BlockEntity or undefined>\n   */\n  getLastSavedBlock = async (): Promise<BlockEntity | undefined> => {\n    const lastBlock = await this.blockRepository.find({\n      where: { status: PROCEED, scanner: this.name() },\n      order: { height: 'DESC' },\n      take: 1,\n    });\n    if (lastBlock.length !== 0) {\n      return lastBlock[0];\n    } else {\n      return undefined;\n    }\n  };\n\n  /**\n   * get last n stored blocks in database\n   * @param skip\n   * @param count\n   */\n  getLastSavedBlocks = async (\n    skip: number,\n    count: number\n  ): Promise<Array<BlockEntity>> => {\n    return await this.blockRepository.find({\n      where: { status: PROCEED, scanner: this.name() },\n      order: { height: 'DESC' },\n      skip: skip,\n      take: count,\n    });\n  };\n\n  /**\n   * get first saved block\n   * @return Promise<BlockEntity or undefined>\n   */\n  getFirstSavedBlock = async (): Promise<BlockEntity | undefined> => {\n    const lastBlock = await this.blockRepository.find({\n      where: { status: PROCEED, scanner: this.name() },\n      order: { height: 'ASC' },\n      take: 1,\n    });\n    if (lastBlock.length !== 0) {\n      return lastBlock[0];\n    } else {\n      return undefined;\n    }\n  };\n\n  /**\n   * get block hash and height\n   * @param height\n   * @param status\n   * @return Promise<BlockEntity|undefined>\n   */\n  getBlockAtHeight = async (\n    height: number,\n    status: string = PROCEED\n  ): Promise<BlockEntity | undefined> => {\n    const block = await this.blockRepository.findOneBy({\n      status: status,\n      height: height,\n      scanner: this.name(),\n    });\n    if (block !== null) {\n      return block;\n    } else {\n      return undefined;\n    }\n  };\n\n  /**\n   * get block with entered blockhash\n   * @param hash\n   * @param status\n   */\n  getBlockWithHash = async (hash: string, status: string = PROCEED) => {\n    return this.blockRepository.findOneBy({\n      hash: hash,\n      status: status,\n      scanner: this.name(),\n    });\n  };\n\n  /**\n   * it deletes every block that more than or equal height\n   * @param height\n   * @return Promise<DeleteResult>\n   */\n  removeBlocksFromHeight = async (height: number): Promise<DeleteResult> => {\n    this.logger.debug(`Removing blocks from height ${height}`);\n    return await this.blockRepository.delete({\n      height: MoreThanOrEqual(height),\n      scanner: this.name(),\n    });\n  };\n\n  /**\n   * store a block into database.\n   * @param block\n   */\n  saveBlock = async (block: Block): Promise<BlockEntity | boolean> => {\n    try {\n      const instance = await this.blockRepository.findOneBy({\n        height: block.height,\n        scanner: this.name(),\n      });\n      const date = new Date(block.timestamp * 1000);\n      const blockInfo = {\n        height: block.height,\n        hash: block.hash,\n        parentHash: block.parentHash,\n        status: PROCESSING,\n        scanner: this.name(),\n        extra: block.extra,\n        timestamp: block.timestamp,\n        year: date.getFullYear(),\n        month: date.getMonth() + 1,\n        day: date.getDate(),\n      };\n      if (!instance) {\n        this.logger.debug(\n          `Inserting block with info: ${JSON.stringify(blockInfo)}`\n        );\n        await this.blockRepository.insert(blockInfo);\n      } else {\n        this.logger.debug(\n          `Updating block with info: ${JSON.stringify(blockInfo)}`\n        );\n        await this.blockRepository.update(\n          { height: block.height, scanner: this.name() },\n          blockInfo\n        );\n      }\n      const res = await this.blockRepository.findOneBy({\n        height: block.height,\n        scanner: this.name(),\n      });\n      return res ? res : false;\n    } catch (exp) {\n      this.logger.error(`An error occurred during save new block: ${exp}`);\n      return false;\n    }\n  };\n\n  /**\n   * Update status of a block to proceed\n   * @param height: height of expected block\n   */\n  updateBlockStatus = async (\n    height: number,\n    blockHash: string,\n    extractorIds: string[]\n  ): Promise<boolean> => {\n    let success = true;\n    this.logger.debug(\n      `Block at height ${height} has been proceed in scanner ${this.name()}, updating status`\n    );\n    const runner = this.dataSource.createQueryRunner();\n    await runner.connect();\n    await runner.startTransaction();\n    try {\n      await runner.manager.getRepository(BlockEntity).update(\n        {\n          height: height,\n          status: PROCESSING,\n          scanner: this.name(),\n        },\n        {\n          status: PROCEED,\n        }\n      );\n\n      this.logger.debug('Updating extractors status', {\n        extractorIds,\n      });\n      await runner.manager\n        .getRepository(ExtractorStatusEntity)\n        .update(\n          { extractorId: In(extractorIds), scannerId: this.name() },\n          { updateHeight: height, updateBlockHash: blockHash }\n        );\n      await runner.commitTransaction();\n    } catch (e) {\n      await runner.rollbackTransaction();\n      success = false;\n    } finally {\n      await runner.release();\n    }\n    return success;\n  };\n\n  /**\n   * Update status of a block to processing in case of fork\n   * @param height: height of expected block\n   */\n  revertBlockStatus = async (\n    height: number,\n    parentHash: string,\n    extractorIds: string[]\n  ): Promise<boolean> => {\n    let success = true;\n    const runner = this.dataSource.createQueryRunner();\n    await runner.connect();\n    await runner.startTransaction();\n    try {\n      this.logger.debug(`Reverting block status at height ${height}`);\n      await runner.manager.getRepository(BlockEntity).update(\n        {\n          height: height,\n          status: PROCEED,\n          scanner: this.name(),\n        },\n        {\n          status: PROCESSING,\n        }\n      );\n\n      this.logger.debug(\n        `Reverting extractors update height to previous block at height ${\n          height - 1\n        }`\n      );\n      await runner.manager\n        .getRepository(ExtractorStatusEntity)\n        .update(\n          { extractorId: In(extractorIds), scannerId: this.name() },\n          { updateHeight: height - 1, updateBlockHash: parentHash }\n        );\n      await runner.commitTransaction();\n    } catch (e) {\n      this.logger.warn(`An Error occurred while reverting block status: ${e}`);\n      await runner.rollbackTransaction();\n      success = false;\n    } finally {\n      await runner.release();\n    }\n    return success;\n  };\n\n  /**\n   * Insert a newly initialized extractor or update an existing extractor status\n   * @param extractorId\n   * @param height\n   * @returns\n   */\n  updateOrInsertExtractorStatus = async (\n    extractorId: string,\n    height: number,\n    blockHash: string\n  ) => {\n    this.logger.debug(\n      'Inserting new extractor status or Updating existing resynced extractor status',\n      {\n        extractorId,\n        height,\n        blockHash,\n      }\n    );\n    return await this.extractorStatusRepository.save({\n      scannerId: this.name(),\n      extractorId,\n      updateHeight: height,\n      updateBlockHash: blockHash,\n    });\n  };\n\n  /**\n   * Return extractors` status specified by id\n   * @param extractorIds\n   * @returns extractors` status\n   */\n  getExtractorsStatus = async (\n    extractorIds: string[]\n  ): Promise<ExtractorStatusEntity[]> => {\n    return await this.extractorStatusRepository.findBy({\n      scannerId: this.name(),\n      extractorId: In(extractorIds),\n    });\n  };\n}\n"]}

package/dist/scanner/interfaces.d.ts

@@ -0,0 +1,12 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+import { AbstractNetworkConnector } from '@rosen-bridge/scanner-interfaces';
+export interface ScannerConfig<TransactionType> {
+    dataSource: DataSource;
+    initialHeight: number;
+    network: AbstractNetworkConnector<TransactionType>;
+    blockRetrieveGap?: number;
+    suffix?: string;
+    logger?: AbstractLogger;
+}
+//# sourceMappingURL=interfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../lib/scanner/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E,MAAM,WAAW,aAAa,CAAC,eAAe;IAC5C,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,wBAAwB,CAAC,eAAe,CAAC,CAAC;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB"}

package/dist/scanner/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9zY2FubmVyL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFic3RyYWN0TG9nZ2VyIH0gZnJvbSAnQHJvc2VuLWJyaWRnZS9hYnN0cmFjdC1sb2dnZXInO1xuaW1wb3J0IHsgRGF0YVNvdXJjZSB9IGZyb20gJ0Byb3Nlbi1icmlkZ2UvZXh0ZW5kZWQtdHlwZW9ybSc7XG5pbXBvcnQgeyBBYnN0cmFjdE5ldHdvcmtDb25uZWN0b3IgfSBmcm9tICdAcm9zZW4tYnJpZGdlL3NjYW5uZXItaW50ZXJmYWNlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2Nhbm5lckNvbmZpZzxUcmFuc2FjdGlvblR5cGU+IHtcbiAgZGF0YVNvdXJjZTogRGF0YVNvdXJjZTtcbiAgaW5pdGlhbEhlaWdodDogbnVtYmVyO1xuICBuZXR3b3JrOiBBYnN0cmFjdE5ldHdvcmtDb25uZWN0b3I8VHJhbnNhY3Rpb25UeXBlPjtcbiAgYmxvY2tSZXRyaWV2ZUdhcD86IG51bWJlcjtcbiAgc3VmZml4Pzogc3RyaW5nO1xuICBsb2dnZXI/OiBBYnN0cmFjdExvZ2dlcjtcbn1cbiJdfQ==

package/dist/scanner/network/ConnectorSelectionStrategies.d.ts

@@ -0,0 +1,27 @@
+import { AbstractNetworkConnector } from '@rosen-bridge/scanner-interfaces';
+/**
+ * Interface for connector selection strategies
+ */
+export interface ConnectorSelectionStrategy<TransactionType> {
+    /**
+     * Select the next connector to use
+     * @param connectors Array of available connectors
+     * @param currentIndex Current connector index
+     * @param lastError Error from the last operation, if any
+     * @returns The index of the next connector to use
+     */
+    selectNextConnector(connectors: Array<AbstractNetworkConnector<TransactionType>>, currentIndex: number, lastError?: Error): number;
+}
+/**
+ * Failover strategy - switches to next connector only on failure
+ */
+export declare class FailoverStrategy<TransactionType> implements ConnectorSelectionStrategy<TransactionType> {
+    selectNextConnector(connectors: Array<AbstractNetworkConnector<TransactionType>>, currentIndex: number, lastError?: Error): number;
+}
+/**
+ * Round-robin strategy - switches to next connector after each operation
+ */
+export declare class RoundRobinStrategy<TransactionType> implements ConnectorSelectionStrategy<TransactionType> {
+    selectNextConnector(connectors: Array<AbstractNetworkConnector<TransactionType>>, currentIndex: number): number;
+}
+//# sourceMappingURL=ConnectorSelectionStrategies.d.ts.map

package/dist/scanner/network/ConnectorSelectionStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectorSelectionStrategies.d.ts","sourceRoot":"","sources":["../../../lib/scanner/network/ConnectorSelectionStrategies.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;;GAEG;AACH,MAAM,WAAW,0BAA0B,CAAC,eAAe;IACzD;;;;;;OAMG;IACH,mBAAmB,CACjB,UAAU,EAAE,KAAK,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC,EAC5D,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,KAAK,GAChB,MAAM,CAAC;CACX;AAED;;GAEG;AACH,qBAAa,gBAAgB,CAAC,eAAe,CAC3C,YAAW,0BAA0B,CAAC,eAAe,CAAC;IAEtD,mBAAmB,CACjB,UAAU,EAAE,KAAK,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC,EAC5D,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,KAAK,GAChB,MAAM;CAQV;AAED;;GAEG;AACH,qBAAa,kBAAkB,CAAC,eAAe,CAC7C,YAAW,0BAA0B,CAAC,eAAe,CAAC;IAEtD,mBAAmB,CACjB,UAAU,EAAE,KAAK,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC,EAC5D,YAAY,EAAE,MAAM,GACnB,MAAM;CAGV"}

package/dist/scanner/network/ConnectorSelectionStrategies.js

@@ -0,0 +1,22 @@
+/**
+ * Failover strategy - switches to next connector only on failure
+ */
+export class FailoverStrategy {
+    selectNextConnector(connectors, currentIndex, lastError) {
+        // If there was an error, try the next connector
+        if (lastError) {
+            return (currentIndex + 1) % connectors.length;
+        }
+        // Otherwise stay with current connector
+        return currentIndex;
+    }
+}
+/**
+ * Round-robin strategy - switches to next connector after each operation
+ */
+export class RoundRobinStrategy {
+    selectNextConnector(connectors, currentIndex) {
+        return (currentIndex + 1) % connectors.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/scanner/network/NetworkConnectorManager.d.ts

@@ -0,0 +1,64 @@
+import { AbstractNetworkConnector, Block } from '@rosen-bridge/scanner-interfaces';
+import { ConnectorSelectionStrategy } from './ConnectorSelectionStrategies';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+/**
+ * Network connector manager that can handle multiple connectors
+ * for a single network with pluggable selection strategy
+ */
+export declare class NetworkConnectorManager<TransactionType> implements AbstractNetworkConnector<TransactionType> {
+    private strategy;
+    private logger;
+    private connectors;
+    private currentConnectorIndex;
+    constructor(strategy?: ConnectorSelectionStrategy<TransactionType>, logger?: AbstractLogger);
+    /**
+     * Add a new connector to the manager
+     * @param connector The network connector instance
+     */
+    addConnector(connector: AbstractNetworkConnector<TransactionType>): void;
+    /**
+     * Get the current active connector
+     * @returns The current network connector instance
+     * @throws Error if no connectors are available
+     */
+    getCurrentConnector(): AbstractNetworkConnector<TransactionType>;
+    /**
+     * Execute an operation using the configured strategy
+     * @param operation The operation to execute
+     * @returns The result of the operation
+     */
+    private executeWithStrategy;
+    /**
+     * Set the strategy to use for connector selection
+     * @param strategy The strategy to use
+     */
+    setStrategy(strategy: ConnectorSelectionStrategy<TransactionType>): void;
+    /**
+     * Get a block at a specific height
+     * @param height The height of the block to get
+     * @returns The block at the specified height
+     */
+    getBlockAtHeight: (height: number) => Promise<Block>;
+    /**
+     * Get the current height of the blockchain
+     * @returns The current height
+     */
+    getCurrentHeight: () => Promise<number>;
+    /**
+     * Get all transactions in a block
+     * @param blockHash The hash of the block to get transactions from
+     * @returns Array of transactions in the block
+     */
+    getBlockTxs: (blockHash: string) => Promise<Array<TransactionType>>;
+    /**
+     * Get the number of available connectors
+     * @returns The number of connectors
+     */
+    getConnectorCount(): number;
+    /**
+     * Remove a connector at the specified index
+     * @param index The index of the connector to remove
+     */
+    removeConnector(index: number): void;
+}
+//# sourceMappingURL=NetworkConnectorManager.d.ts.map

package/dist/scanner/network/NetworkConnectorManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkConnectorManager.d.ts","sourceRoot":"","sources":["../../../lib/scanner/network/NetworkConnectorManager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,KAAK,EACN,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,0BAA0B,EAE3B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAE5E;;;GAGG;AACH,qBAAa,uBAAuB,CAAC,eAAe,CAClD,YAAW,wBAAwB,CAAC,eAAe,CAAC;IAMlD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,MAAM;IALhB,OAAO,CAAC,UAAU,CAAmD;IACrE,OAAO,CAAC,qBAAqB,CAAS;gBAG5B,QAAQ,GAAE,0BAA0B,CAAC,eAAe,CAA2C,EAC/F,MAAM,GAAE,cAAkC;IAQpD;;;OAGG;IACI,YAAY,CACjB,SAAS,EAAE,wBAAwB,CAAC,eAAe,CAAC,GACnD,IAAI;IAOP;;;;OAIG;IACH,mBAAmB,IAAI,wBAAwB,CAAC,eAAe,CAAC;IAQhE;;;;OAIG;YACW,mBAAmB;IA8CjC;;;OAGG;IACI,WAAW,CAChB,QAAQ,EAAE,0BAA0B,CAAC,eAAe,CAAC,GACpD,IAAI;IAKP;;;;OAIG;IACH,gBAAgB,WAAkB,MAAM,KAAG,QAAQ,KAAK,CAAC,CAIvD;IAEF;;;OAGG;IACH,gBAAgB,QAAa,QAAQ,MAAM,CAAC,CAI1C;IAEF;;;;OAIG;IACH,WAAW,cAAqB,MAAM,KAAG,QAAQ,MAAM,eAAe,CAAC,CAAC,CAItE;IAEF;;;OAGG;IACI,iBAAiB,IAAI,MAAM;IAMlC;;;OAGG;IACI,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAU5C"}