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

package/dist/scanner/network/NetworkConnectorManager.js

@@ -0,0 +1,125 @@
+import { FailoverStrategy, } from './ConnectorSelectionStrategies';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+/**
+ * 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
+     * @returns Array of transactions in the block
+     */
+    getBlockTxs = async (blockHash) => {
+        return this.executeWithStrategy((connector) => connector.getBlockTxs(blockHash));
+    };
+    /**
+     * 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":"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","sourcesContent":["import {\n  AbstractNetworkConnector,\n  Block,\n} from '@rosen-bridge/scanner-interfaces';\nimport {\n  ConnectorSelectionStrategy,\n  FailoverStrategy,\n} from './ConnectorSelectionStrategies';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\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   * @returns Array of transactions in the block\n   */\n  getBlockTxs = async (blockHash: string): Promise<Array<TransactionType>> => {\n    return this.executeWithStrategy((connector) =>\n      connector.getBlockTxs(blockHash)\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"]}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@rosen-bridge/abstract-scanner",
+  "version": "0.1.0-52fc0239",
+  "description": "Abstract scanner toolkit for blockchain scanning with logging.",
+  "author": "Rosen Team",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prettify": "prettier --write . --ignore-path ../../.gitignore",
+    "lint": "eslint --fix . && npm run prettify",
+    "test": "jest",
+    "coverage": "jest --detectOpenHandles --coverage",
+    "build": "tsc --build",
+    "type-check": "tsc --noEmit",
+    "release": "npm run test && npm run build && npm publish --access public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rosen-bridge/scanner"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@rosen-bridge/abstract-extractor": "^2.0.3-52fc0239",
+    "@rosen-bridge/abstract-logger": "^2.0.1",
+    "@rosen-bridge/json-bigint": "^0.1.0",
+    "@rosen-bridge/scanner-interfaces": "^0.1.1-52fc0239",
+    "await-semaphore": "^0.1.3",
+    "lodash-es": "^4.17.21",
+    "reflect-metadata": "^0.1.13",
+    "sqlite3": "^5.1.7",
+    "@rosen-bridge/extended-typeorm": "^0.2.1"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@babel/preset-env": "^7.19.0",
+    "@types/jest": "^28.1.6",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^22.18.0",
+    "@typescript-eslint/eslint-plugin": "^5.30.7",
+    "@typescript-eslint/parser": "^5.26.0",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.5.0",
+    "jest": "^28.1.3",
+    "prettier": "2.7.1",
+    "ts-jest": "^28.0.7",
+    "typescript": "^4.7.4"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  }
+}