@my-packages-changeit/abstract-scanner 2.0.3

package/dist/scanner/action.js

@@ -0,0 +1,251 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { MoreThanOrEqual, In, } from '@rosen-bridge/extended-typeorm';
+import { BlockEntity, PROCEED, PROCESSING } from '../entities/blockEntity';
+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 {
+            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 { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  DataSource,\n  DeleteResult,\n  MoreThanOrEqual,\n  Repository,\n  In,\n} from '@rosen-bridge/extended-typeorm';\nimport { Block } from '@rosen-bridge/scanner-interfaces';\n\nimport { BlockEntity, PROCEED, PROCESSING } from '../entities/blockEntity';\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 {\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,13 @@
+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;
+    heightGap?: number;
+    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,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB"}

package/dist/scanner/interfaces.js

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

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,65 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { AbstractNetworkConnector, Block } from '@rosen-bridge/scanner-interfaces';
+import { ConnectorSelectionStrategy } from './connectorSelectionStrategies';
+/**
+ * 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
+     * @param height The height of the block to get transactions from
+     * @returns Array of transactions in the block
+     */
+    getBlockTxs: (blockHash: string, height: number) => 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,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,wBAAwB,EACxB,KAAK,EACN,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,0BAA0B,EAE3B,MAAM,gCAAgC,CAAC;AAExC;;;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,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC,CAIvD;IAEF;;;OAGG;IACH,gBAAgB,QAAa,OAAO,CAAC,MAAM,CAAC,CAI1C;IAEF;;;;;OAKG;IACH,WAAW,GACT,WAAW,MAAM,EACjB,QAAQ,MAAM,KACb,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAIhC;IAEF;;;OAGG;IACI,iBAAiB,IAAI,MAAM;IAMlC;;;OAGG;IACI,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAU5C"}

package/dist/scanner/network/networkConnectorManager.js

@@ -0,0 +1,126 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { FailoverStrategy, } from './connectorSelectionStrategies';
+/**
+ * Network connector manager that can handle multiple connectors
+ * for a single network with pluggable selection strategy
+ */
+export class NetworkConnectorManager {
+    strategy;
+    logger;
+    connectors;
+    currentConnectorIndex;
+    constructor(strategy = new FailoverStrategy(), logger = new DummyLogger()) {
+        this.strategy = strategy;
+        this.logger = logger;
+        this.connectors = [];
+        this.currentConnectorIndex = 0;
+        this.strategy = strategy;
+        this.logger.debug('NetworkConnectorManager initialized');
+    }
+    /**
+     * Add a new connector to the manager
+     * @param connector The network connector instance
+     */
+    addConnector(connector) {
+        this.connectors.push(connector);
+        this.logger.info(`Added new connector. Total connectors: ${this.connectors.length}`);
+    }
+    /**
+     * Get the current active connector
+     * @returns The current network connector instance
+     * @throws Error if no connectors are available
+     */
+    getCurrentConnector() {
+        if (this.connectors.length === 0) {
+            throw new Error('No connectors available');
+        }
+        this.logger.debug(`Using connector at index ${this.currentConnectorIndex}`);
+        return this.connectors[this.currentConnectorIndex];
+    }
+    /**
+     * Execute an operation using the configured strategy
+     * @param operation The operation to execute
+     * @returns The result of the operation
+     */
+    async executeWithStrategy(operation) {
+        if (this.connectors.length === 0) {
+            throw new Error('No connectors available for operation');
+        }
+        let lastError;
+        let attempts = 0;
+        const maxAttempts = this.connectors.length;
+        while (attempts < maxAttempts) {
+            try {
+                const connector = this.connectors[this.currentConnectorIndex];
+                this.logger.debug(`Attempt ${attempts + 1}/${maxAttempts} with connector at index ${this.currentConnectorIndex}`);
+                const result = await operation(connector);
+                this.currentConnectorIndex = this.strategy.selectNextConnector(this.connectors, this.currentConnectorIndex);
+                this.logger.debug(`Operation successful, next connector index: ${this.currentConnectorIndex}`);
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.warn(`Operation failed with connector at index ${this.currentConnectorIndex}: ${lastError.message}`);
+                this.currentConnectorIndex = this.strategy.selectNextConnector(this.connectors, this.currentConnectorIndex, lastError);
+                attempts++;
+            }
+        }
+        throw lastError || new Error('All connectors failed');
+    }
+    /**
+     * Set the strategy to use for connector selection
+     * @param strategy The strategy to use
+     */
+    setStrategy(strategy) {
+        this.logger.info('Setting new connector selection strategy');
+        this.strategy = strategy;
+    }
+    /**
+     * Get a block at a specific height
+     * @param height The height of the block to get
+     * @returns The block at the specified height
+     */
+    getBlockAtHeight = async (height) => {
+        return this.executeWithStrategy((connector) => connector.getBlockAtHeight(height));
+    };
+    /**
+     * Get the current height of the blockchain
+     * @returns The current height
+     */
+    getCurrentHeight = async () => {
+        return this.executeWithStrategy((connector) => connector.getCurrentHeight());
+    };
+    /**
+     * Get all transactions in a block
+     * @param blockHash The hash of the block to get transactions from
+     * @param height The height of the block to get transactions from
+     * @returns Array of transactions in the block
+     */
+    getBlockTxs = async (blockHash, height) => {
+        return this.executeWithStrategy((connector) => connector.getBlockTxs(blockHash, height));
+    };
+    /**
+     * Get the number of available connectors
+     * @returns The number of connectors
+     */
+    getConnectorCount() {
+        const count = this.connectors.length;
+        this.logger.debug(`Current connector count: ${count}`);
+        return count;
+    }
+    /**
+     * Remove a connector at the specified index
+     * @param index The index of the connector to remove
+     */
+    removeConnector(index) {
+        if (index < 0 || index >= this.connectors.length) {
+            throw new Error('Invalid connector index');
+        }
+        this.logger.info(`Removing connector at index ${index}`);
+        this.connectors.splice(index, 1);
+        if (this.currentConnectorIndex >= this.connectors.length) {
+            this.currentConnectorIndex = 0;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkConnectorManager.js","sourceRoot":"","sources":["../../../lib/scanner/network/networkConnectorManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAM5E,OAAO,EAEL,gBAAgB,GACjB,MAAM,gCAAgC,CAAC;AAExC;;;GAGG;AACH,MAAM,OAAO,uBAAuB;IAOxB;IACA;IALF,UAAU,CAAmD;IAC7D,qBAAqB,CAAS;IAEtC,YACU,WAAwD,IAAI,gBAAgB,EAAmB,EAC/F,SAAyB,IAAI,WAAW,EAAE;QAD1C,aAAQ,GAAR,QAAQ,CAAuF;QAC/F,WAAM,GAAN,MAAM,CAAoC;QAElD,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAC3D,CAAC;IAED;;;OAGG;IACI,YAAY,CACjB,SAAoD;QAEpD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,0CAA0C,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CACnE,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,mBAAmB;QACjB,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,IAAI,CAAC,qBAAqB,EAAE,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,mBAAmB,CAC/B,SAEe;QAEf,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,SAA4B,CAAC;QACjC,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QAE3C,OAAO,QAAQ,GAAG,WAAW,EAAE,CAAC;YAC9B,IAAI,CAAC;gBACH,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;gBAC9D,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,WAAW,QAAQ,GAAG,CAAC,IAAI,WAAW,4BACpC,IAAI,CAAC,qBACP,EAAE,CACH,CAAC;gBACF,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,SAAS,CAAC,CAAC;gBAC1C,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAC5D,IAAI,CAAC,UAAU,EACf,IAAI,CAAC,qBAAqB,CAC3B,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,+CAA+C,IAAI,CAAC,qBAAqB,EAAE,CAC5E,CAAC;gBACF,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAc,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,4CAA4C,IAAI,CAAC,qBAAqB,KAAK,SAAS,CAAC,OAAO,EAAE,CAC/F,CAAC;gBACF,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAC5D,IAAI,CAAC,UAAU,EACf,IAAI,CAAC,qBAAqB,EAC1B,SAAS,CACV,CAAC;gBACF,QAAQ,EAAE,CAAC;YACb,CAAC;QACH,CAAC;QACD,MAAM,SAAS,IAAI,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACI,WAAW,CAChB,QAAqD;QAErD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;QAC7D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,gBAAgB,GAAG,KAAK,EAAE,MAAc,EAAkB,EAAE;QAC1D,OAAO,IAAI,CAAC,mBAAmB,CAAC,CAAC,SAAS,EAAE,EAAE,CAC5C,SAAS,CAAC,gBAAgB,CAAC,MAAM,CAAC,CACnC,CAAC;IACJ,CAAC,CAAC;IAEF;;;OAGG;IACH,gBAAgB,GAAG,KAAK,IAAqB,EAAE;QAC7C,OAAO,IAAI,CAAC,mBAAmB,CAAC,CAAC,SAAS,EAAE,EAAE,CAC5C,SAAS,CAAC,gBAAgB,EAAE,CAC7B,CAAC;IACJ,CAAC,CAAC;IAEF;;;;;OAKG;IACH,WAAW,GAAG,KAAK,EACjB,SAAiB,EACjB,MAAc,EACmB,EAAE;QACnC,OAAO,IAAI,CAAC,mBAAmB,CAAC,CAAC,SAAS,EAAE,EAAE,CAC5C,SAAS,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CACzC,CAAC;IACJ,CAAC,CAAC;IAEF;;;OAGG;IACI,iBAAiB;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,KAAK,EAAE,CAAC,CAAC;QACvD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACI,eAAe,CAAC,KAAa;QAClC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,+BAA+B,KAAK,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACjC,IAAI,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YACzD,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;CACF","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  AbstractNetworkConnector,\n  Block,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport {\n  ConnectorSelectionStrategy,\n  FailoverStrategy,\n} from './connectorSelectionStrategies';\n\n/**\n * Network connector manager that can handle multiple connectors\n * for a single network with pluggable selection strategy\n */\nexport class NetworkConnectorManager<TransactionType>\n  implements AbstractNetworkConnector<TransactionType>\n{\n  private connectors: Array<AbstractNetworkConnector<TransactionType>>;\n  private currentConnectorIndex: number;\n\n  constructor(\n    private strategy: ConnectorSelectionStrategy<TransactionType> = new FailoverStrategy<TransactionType>(),\n    private logger: AbstractLogger = new DummyLogger(),\n  ) {\n    this.connectors = [];\n    this.currentConnectorIndex = 0;\n    this.strategy = strategy;\n    this.logger.debug('NetworkConnectorManager initialized');\n  }\n\n  /**\n   * Add a new connector to the manager\n   * @param connector The network connector instance\n   */\n  public addConnector(\n    connector: AbstractNetworkConnector<TransactionType>,\n  ): void {\n    this.connectors.push(connector);\n    this.logger.info(\n      `Added new connector. Total connectors: ${this.connectors.length}`,\n    );\n  }\n\n  /**\n   * Get the current active connector\n   * @returns The current network connector instance\n   * @throws Error if no connectors are available\n   */\n  getCurrentConnector(): AbstractNetworkConnector<TransactionType> {\n    if (this.connectors.length === 0) {\n      throw new Error('No connectors available');\n    }\n    this.logger.debug(`Using connector at index ${this.currentConnectorIndex}`);\n    return this.connectors[this.currentConnectorIndex];\n  }\n\n  /**\n   * Execute an operation using the configured strategy\n   * @param operation The operation to execute\n   * @returns The result of the operation\n   */\n  private async executeWithStrategy<T>(\n    operation: (\n      connector: AbstractNetworkConnector<TransactionType>,\n    ) => Promise<T>,\n  ): Promise<T> {\n    if (this.connectors.length === 0) {\n      throw new Error('No connectors available for operation');\n    }\n\n    let lastError: Error | undefined;\n    let attempts = 0;\n    const maxAttempts = this.connectors.length;\n\n    while (attempts < maxAttempts) {\n      try {\n        const connector = this.connectors[this.currentConnectorIndex];\n        this.logger.debug(\n          `Attempt ${attempts + 1}/${maxAttempts} with connector at index ${\n            this.currentConnectorIndex\n          }`,\n        );\n        const result = await operation(connector);\n        this.currentConnectorIndex = this.strategy.selectNextConnector(\n          this.connectors,\n          this.currentConnectorIndex,\n        );\n        this.logger.debug(\n          `Operation successful, next connector index: ${this.currentConnectorIndex}`,\n        );\n        return result;\n      } catch (error) {\n        lastError = error as Error;\n        this.logger.warn(\n          `Operation failed with connector at index ${this.currentConnectorIndex}: ${lastError.message}`,\n        );\n        this.currentConnectorIndex = this.strategy.selectNextConnector(\n          this.connectors,\n          this.currentConnectorIndex,\n          lastError,\n        );\n        attempts++;\n      }\n    }\n    throw lastError || new Error('All connectors failed');\n  }\n\n  /**\n   * Set the strategy to use for connector selection\n   * @param strategy The strategy to use\n   */\n  public setStrategy(\n    strategy: ConnectorSelectionStrategy<TransactionType>,\n  ): void {\n    this.logger.info('Setting new connector selection strategy');\n    this.strategy = strategy;\n  }\n\n  /**\n   * Get a block at a specific height\n   * @param height The height of the block to get\n   * @returns The block at the specified height\n   */\n  getBlockAtHeight = async (height: number): Promise<Block> => {\n    return this.executeWithStrategy((connector) =>\n      connector.getBlockAtHeight(height),\n    );\n  };\n\n  /**\n   * Get the current height of the blockchain\n   * @returns The current height\n   */\n  getCurrentHeight = async (): Promise<number> => {\n    return this.executeWithStrategy((connector) =>\n      connector.getCurrentHeight(),\n    );\n  };\n\n  /**\n   * Get all transactions in a block\n   * @param blockHash The hash of the block to get transactions from\n   * @param height The height of the block to get transactions from\n   * @returns Array of transactions in the block\n   */\n  getBlockTxs = async (\n    blockHash: string,\n    height: number,\n  ): Promise<Array<TransactionType>> => {\n    return this.executeWithStrategy((connector) =>\n      connector.getBlockTxs(blockHash, height),\n    );\n  };\n\n  /**\n   * Get the number of available connectors\n   * @returns The number of connectors\n   */\n  public getConnectorCount(): number {\n    const count = this.connectors.length;\n    this.logger.debug(`Current connector count: ${count}`);\n    return count;\n  }\n\n  /**\n   * Remove a connector at the specified index\n   * @param index The index of the connector to remove\n   */\n  public removeConnector(index: number): void {\n    if (index < 0 || index >= this.connectors.length) {\n      throw new Error('Invalid connector index');\n    }\n    this.logger.info(`Removing connector at index ${index}`);\n    this.connectors.splice(index, 1);\n    if (this.currentConnectorIndex >= this.connectors.length) {\n      this.currentConnectorIndex = 0;\n    }\n  }\n}\n"]}