@my-packages-changeit/abstract-observation-extractor 1.0.10

package/CHANGELOG.md

@@ -0,0 +1,169 @@
+# @rosen-bridge/abstract-observation-extractor
+
+## 1.0.10
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.2.3
+
+## 1.0.9
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.2.2
+  - @rosen-bridge/rosen-extractor@12.1.1
+  - @rosen-bridge/tokens@6.0.2
+
+## 1.0.8
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.2.1
+
+## 1.0.7
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.2.0
+  - @rosen-bridge/scanner-interfaces@1.0.0
+
+## 1.0.6
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/rosen-extractor@12.0.2
+
+## 1.0.5
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.1.2
+  - @rosen-bridge/extended-typeorm@1.1.0
+  - @rosen-bridge/rosen-extractor@12.0.1
+  - @rosen-bridge/tokens@6.0.1
+
+## 1.0.4
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.1.1
+
+## 1.0.3
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.1.0
+  - @rosen-bridge/rosen-extractor@11.3.0
+
+## 1.0.2
+
+### Patch Changes
+
+- Update dependencies:
+  - @rosen-bridge/rosen-extractor@11.2.2
+  - @rosen-bridge/tokens@6.0.0
+
+## 1.0.1
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.0.1
+  - @rosen-bridge/rosen-extractor@11.2.1
+  - @rosen-bridge/scanner-interfaces@0.2.2
+  - @rosen-bridge/tokens@5.0.1
+
+## 1.0.0
+
+### Major Changes
+
+- Update AbstractExtractor interface; use `BlockInfo` in `processTransactions` and rename `initializeBoxes` to `initializeData`
+
+### Minor Changes
+
+- Update AbstractExtractor interface; add `createUsedBlocksQuery` method that returns the query for used blocks
+
+### Patch Changes
+
+- Update ObservationEntityAction to considering extractor in storeObservations method
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@3.0.0
+  - @rosen-bridge/abstract-logger@4.0.0
+  - @rosen-bridge/rosen-extractor@11.2.0
+  - @rosen-bridge/tokens@5.0.0
+
+## 0.2.3
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/rosen-extractor@11.1.1
+
+## 0.2.2
+
+### Patch Changes
+
+- Update Dependencies
+  - @rosen-bridge/rosen-extractor@11.1.0
+
+## 0.2.1
+
+### Patch Changes
+
+- Fixed type definitions in entities based migrations
+- Update Dependencies
+  - @rosen-bridge/rosen-extractor@11.0.0
+
+## 0.2.0
+
+### Minor Changes
+
+- Added preprocessTransactions method
+- Add rawData field in ObservationEntity and AbstractObservationExtractor processTransactions method
+
+### Patch Changes
+
+- Fix package-lock and move typescript and types/node into root
+- Update eslint and plugins:
+  - Apply new rules such as sort imports and file name
+- Update dependencies
+  - @rosen-bridge/extended-typeorm@1.0.1
+  - @rosen-clients/rate-limited-axios@1.1.0
+  - @rosen-bridge/rosen-extractor@10.1.1
+  - @rosen-bridge/tokens@4.0.1
+  - @rosen-bridge/abstract-logger@3.0.1
+  - @rosen-bridge/json-bigint@1.1.0
+  - @rosen-clients/ergo-explorer@2.1.0
+  - @rosen-clients/ergo-node@3.1.0
+  - @rosen-bridge/abstract-extractor@2.1.2
+  - @rosen-bridge/scanner-interfaces@0.2.1
+
+## 0.1.2
+
+### Patch Changes
+
+- Update dependencies
+  - @rosen-bridge/abstract-extractor@2.1.1
+  - @rosen-bridge/extended-typeorm@1.0.0
+  - @rosen-bridge/tokens@4.0.0
+  - @rosen-bridge/rosen-extractor@10.0.0
+  - @rosen-bridge/abstract-logger@3.0.0
+
+## 0.1.1
+
+### Patch Changes
+
+- Update @rosen-bridge/rosen-extractor version to 9.0.0
+
+## 0.1.0
+
+- The package has been **renamed** from `@rosen-bridge/observation-extractor`.  
+  You can track the previous history in the changelog of the old package. The latest update is available [here](https://github.com/rosen-bridge/scanner/blob/d4a5539b01c523b101104470b03ff7023a10b70b/packages/observation-extractor/CHANGELOG.md).

package/README.md

@@ -0,0 +1,48 @@
+# Abstract Observation Extractor
+
+### Table of Contents
+
+- [Description](#description)
+- [Related Projects](#related-projects)
+- [How to Use the Observation Extractor](#how-to-use-the-observation-extractor)
+  - [Install](#install)
+  - [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+
+<a name="headers"/>
+
+## Description
+
+Data extractors are modules that are integrated within a scanner. They drive the required information from the scanned blocks and store them in their own database. The observation extractor is designed to fulfill a watcher's main task: observing user payments in source networks. The bridge payment transaction has its own structure, and the observation extractor searches for this pattern occurrence in source chains and stores all needed information for a watcher commitment creation and revealment.
+
+## Related Projects
+
+This module is used within the [Scanner](https://github.com/rosen-bridge/scanner) project. The address scanner is currently used in the [Watcher](https://github.com/rosen-bridge/watcher) service to drive the valid source chain observations.
+
+## How to Use the Observation Extractor
+
+### Install
+
+This project is written in node-js using Esnext module and typeorm database. Extractors are not standalone projects and should be used as scanner modules. You can easily install it using npm with the command:
+
+```shell
+npm install @rosen-bridge/abstract-observation-extractor
+```
+
+Alternatively, you can build and use it manually by cloning the project and running:
+
+```shell
+npm install
+npm run build
+```
+
+### Usage
+
+## Contributing
+
+TBD
+
+## License
+
+TBD

package/dist/actions/db.d.ts

@@ -0,0 +1,28 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource, SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { ObservationEntity } from '../entities/observationEntity';
+import { ExtractedObservation } from '../interfaces/extractedObservation';
+export declare class ObservationEntityAction {
+    readonly logger: AbstractLogger;
+    private readonly datasource;
+    private readonly observationRepository;
+    constructor(dataSource: DataSource, logger?: AbstractLogger);
+    /**
+     * It stores list of observations in the dataSource with block id
+     * @param observations
+     * @param block
+     * @param extractor
+     */
+    storeObservations: (observations: Array<ExtractedObservation>, block: BlockInfo, extractor: string) => Promise<boolean>;
+    deleteBlockObservation: (block: string, extractor: string) => Promise<void>;
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ObservationEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @param extractorId - Identifier of the extractor
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery: (extractorId: string) => SelectQueryBuilder<ObservationEntity>;
+}
+//# sourceMappingURL=db.d.ts.map

package/dist/actions/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../lib/actions/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,UAAU,EAGV,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,qBAAa,uBAAuB;IAClC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAgC;gBAE1D,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,cAAc;IAM3D;;;;;OAKG;IACH,iBAAiB,GACf,cAAc,KAAK,CAAC,oBAAoB,CAAC,EACzC,OAAO,SAAS,EAChB,WAAW,MAAM,sBAmEjB;IAEF,sBAAsB,GAAU,OAAO,MAAM,EAAE,WAAW,MAAM,mBAQ9D;IAEF;;;;;;OAMG;IACH,qBAAqB,GACnB,aAAa,MAAM,KAClB,kBAAkB,CAAC,iBAAiB,CAAC,CAKtC;CACH"}

package/dist/actions/db.js

@@ -0,0 +1,101 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { In, } from '@rosen-bridge/extended-typeorm';
+import { ObservationEntity } from '../entities/observationEntity';
+export class ObservationEntityAction {
+    logger;
+    datasource;
+    observationRepository;
+    constructor(dataSource, logger) {
+        this.datasource = dataSource;
+        this.observationRepository = dataSource.getRepository(ObservationEntity);
+        this.logger = logger ? logger : new DummyLogger();
+    }
+    /**
+     * It stores list of observations in the dataSource with block id
+     * @param observations
+     * @param block
+     * @param extractor
+     */
+    storeObservations = async (observations, block, extractor) => {
+        if (observations.length === 0)
+            return true;
+        const requestIds = observations.map((item) => item.requestId);
+        const savedObservations = await this.observationRepository.findBy({
+            requestId: In(requestIds),
+            extractor: extractor,
+        });
+        let success = true;
+        const queryRunner = this.datasource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        const repository = await queryRunner.manager.getRepository(ObservationEntity);
+        try {
+            for (const observation of observations) {
+                const saved = savedObservations.some((entity) => {
+                    return entity.requestId === observation.requestId;
+                });
+                const entity = {
+                    block: block.hash,
+                    height: block.height,
+                    bridgeFee: observation.bridgeFee,
+                    amount: observation.amount,
+                    fromAddress: observation.fromAddress,
+                    fromChain: observation.fromChain,
+                    networkFee: observation.networkFee,
+                    requestId: observation.requestId,
+                    sourceBlockId: observation.sourceBlockId,
+                    sourceTxId: observation.sourceTxId,
+                    toChain: observation.toChain,
+                    sourceChainTokenId: observation.sourceChainTokenId,
+                    targetChainTokenId: observation.targetChainTokenId,
+                    toAddress: observation.toAddress,
+                    extractor: extractor,
+                    rawData: observation.rawData,
+                };
+                if (!saved) {
+                    this.logger.info(`Storing observation for event ${observation.requestId} in blockHeight ${block.height} and extractor ${extractor}`);
+                    await repository.insert(entity);
+                }
+                else {
+                    this.logger.info(`Updating observation for event ${observation.requestId} in blockHeight ${block.height} and extractor ${extractor}`);
+                    await repository.update({
+                        requestId: observation.requestId,
+                        extractor: extractor,
+                    }, entity);
+                }
+                this.logger.debug(`Entity ${JSON.stringify(entity)}`);
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store observation action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return success;
+    };
+    deleteBlockObservation = async (block, extractor) => {
+        this.logger.info(`Deleting observations in block ${block} and extractor ${extractor}`);
+        await this.observationRepository.delete({
+            block: block,
+            extractor: extractor,
+        });
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ObservationEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @param extractorId - Identifier of the extractor
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = (extractorId) => {
+        return this.observationRepository
+            .createQueryBuilder('observationEntity')
+            .select('observationEntity.block', 'block')
+            .where('observationEntity.extractor = :extractorId', { extractorId });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"db.js","sourceRoot":"","sources":["../../lib/actions/db.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  DataSource,\n  In,\n  Repository,\n  SelectQueryBuilder,\n} from '@rosen-bridge/extended-typeorm';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport { ObservationEntity } from '../entities/observationEntity';\nimport { ExtractedObservation } from '../interfaces/extractedObservation';\n\nexport class ObservationEntityAction {\n  readonly logger: AbstractLogger;\n  private readonly datasource: DataSource;\n  private readonly observationRepository: Repository<ObservationEntity>;\n\n  constructor(dataSource: DataSource, logger?: AbstractLogger) {\n    this.datasource = dataSource;\n    this.observationRepository = dataSource.getRepository(ObservationEntity);\n    this.logger = logger ? logger : new DummyLogger();\n  }\n\n  /**\n   * It stores list of observations in the dataSource with block id\n   * @param observations\n   * @param block\n   * @param extractor\n   */\n  storeObservations = async (\n    observations: Array<ExtractedObservation>,\n    block: BlockInfo,\n    extractor: string,\n  ) => {\n    if (observations.length === 0) return true;\n    const requestIds = observations.map((item) => item.requestId);\n    const savedObservations = await this.observationRepository.findBy({\n      requestId: In(requestIds),\n      extractor: extractor,\n    });\n    let success = true;\n    const queryRunner = this.datasource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    const repository =\n      await queryRunner.manager.getRepository(ObservationEntity);\n    try {\n      for (const observation of observations) {\n        const saved = savedObservations.some((entity) => {\n          return entity.requestId === observation.requestId;\n        });\n        const entity = {\n          block: block.hash,\n          height: block.height,\n          bridgeFee: observation.bridgeFee,\n          amount: observation.amount,\n          fromAddress: observation.fromAddress,\n          fromChain: observation.fromChain,\n          networkFee: observation.networkFee,\n          requestId: observation.requestId,\n          sourceBlockId: observation.sourceBlockId,\n          sourceTxId: observation.sourceTxId,\n          toChain: observation.toChain,\n          sourceChainTokenId: observation.sourceChainTokenId,\n          targetChainTokenId: observation.targetChainTokenId,\n          toAddress: observation.toAddress,\n          extractor: extractor,\n          rawData: observation.rawData,\n        };\n        if (!saved) {\n          this.logger.info(\n            `Storing observation for event ${observation.requestId} in blockHeight ${block.height} and extractor ${extractor}`,\n          );\n          await repository.insert(entity);\n        } else {\n          this.logger.info(\n            `Updating observation for event ${observation.requestId} in blockHeight ${block.height} and extractor ${extractor}`,\n          );\n          await repository.update(\n            {\n              requestId: observation.requestId,\n              extractor: extractor,\n            },\n            entity,\n          );\n        }\n        this.logger.debug(`Entity ${JSON.stringify(entity)}`);\n      }\n      await queryRunner.commitTransaction();\n    } catch (e) {\n      this.logger.error(\n        `An error occurred during store observation action: ${e}`,\n      );\n      await queryRunner.rollbackTransaction();\n      success = false;\n    } finally {\n      await queryRunner.release();\n    }\n    return success;\n  };\n\n  deleteBlockObservation = async (block: string, extractor: string) => {\n    this.logger.info(\n      `Deleting observations in block ${block} and extractor ${extractor}`,\n    );\n    await this.observationRepository.delete({\n      block: block,\n      extractor: extractor,\n    });\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `ObservationEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @param extractorId - Identifier of the extractor\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (\n    extractorId: string,\n  ): SelectQueryBuilder<ObservationEntity> => {\n    return this.observationRepository\n      .createQueryBuilder('observationEntity')\n      .select('observationEntity.block', 'block')\n      .where('observationEntity.extractor = :extractorId', { extractorId });\n  };\n}\n"]}

package/dist/entities/observationEntity.d.ts

@@ -0,0 +1,20 @@
+export declare class ObservationEntity {
+    id: number;
+    fromChain: string;
+    toChain: string;
+    fromAddress: string;
+    toAddress: string;
+    height: number;
+    amount: string;
+    networkFee: string;
+    bridgeFee: string;
+    sourceChainTokenId: string;
+    targetChainTokenId: string;
+    sourceTxId: string;
+    sourceBlockId: string;
+    requestId: string;
+    block: string;
+    extractor: string;
+    rawData: string;
+}
+//# sourceMappingURL=observationEntity.d.ts.map

package/dist/entities/observationEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observationEntity.d.ts","sourceRoot":"","sources":["../../lib/entities/observationEntity.ts"],"names":[],"mappings":"AAOA,qBAEa,iBAAiB;IAE5B,EAAE,EAAE,MAAM,CAAC;IAEX,SAAS,EAAE,MAAM,CAAC;IAGlB,OAAO,EAAE,MAAM,CAAC;IAGhB,WAAW,EAAE,MAAM,CAAC;IAGpB,SAAS,EAAE,MAAM,CAAC;IAGlB,MAAM,EAAE,MAAM,CAAC;IAGf,MAAM,EAAE,MAAM,CAAC;IAGf,UAAU,EAAE,MAAM,CAAC;IAGnB,SAAS,EAAE,MAAM,CAAC;IAGlB,kBAAkB,EAAE,MAAM,CAAC;IAG3B,kBAAkB,EAAE,MAAM,CAAC;IAG3B,UAAU,EAAE,MAAM,CAAC;IAGnB,aAAa,EAAE,MAAM,CAAC;IAGtB,SAAS,EAAE,MAAM,CAAC;IAGlB,KAAK,EAAE,MAAM,CAAC;IAGd,SAAS,EAAE,MAAM,CAAC;IAGlB,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/entities/observationEntity.js

@@ -0,0 +1,103 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Column, Entity, PrimaryGeneratedColumn, Unique, } from '@rosen-bridge/extended-typeorm';
+let ObservationEntity = class ObservationEntity {
+    id;
+    fromChain;
+    toChain;
+    fromAddress;
+    toAddress;
+    height;
+    amount;
+    networkFee;
+    bridgeFee;
+    sourceChainTokenId;
+    targetChainTokenId;
+    sourceTxId;
+    sourceBlockId;
+    requestId;
+    block;
+    extractor;
+    rawData;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], ObservationEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 30 }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "fromChain", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 30 }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "toChain", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "fromAddress", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "toAddress", void 0);
+__decorate([
+    Column({ type: 'int' }),
+    __metadata("design:type", Number)
+], ObservationEntity.prototype, "height", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "amount", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "networkFee", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "bridgeFee", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "sourceChainTokenId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "targetChainTokenId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "sourceTxId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "sourceBlockId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "requestId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "block", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "extractor", void 0);
+__decorate([
+    Column({ type: 'varchar', default: '' }),
+    __metadata("design:type", String)
+], ObservationEntity.prototype, "rawData", void 0);
+ObservationEntity = __decorate([
+    Entity('observation_entity'),
+    Unique(['requestId', 'extractor'])
+], ObservationEntity);
+export { ObservationEntity };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/extractor/abstractObservationExtractor.d.ts

@@ -0,0 +1,56 @@
+import { AbstractExtractor } from '@rosen-bridge/abstract-extractor';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource, SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';
+import { AbstractRosenDataExtractor } from '@rosen-bridge/rosen-extractor';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { TokenMap } from '@rosen-bridge/tokens';
+import { ObservationEntityAction } from '../actions/db';
+import { ObservationEntity } from '../entities/observationEntity';
+export declare abstract class AbstractObservationExtractor<TransactionType> extends AbstractExtractor<TransactionType, ObservationEntity> {
+    protected readonly logger: AbstractLogger;
+    protected readonly dataSource: DataSource;
+    protected readonly tokens: TokenMap;
+    protected readonly actions: ObservationEntityAction;
+    protected extractor: AbstractRosenDataExtractor<TransactionType>;
+    abstract readonly FROM_CHAIN: string;
+    constructor(dataSource: DataSource, tokens: TokenMap, extractor: AbstractRosenDataExtractor<TransactionType>, logger?: AbstractLogger);
+    /**
+     * gets Id for current extractor
+     */
+    abstract getId: () => string;
+    /**
+     * gets transaction id from TransactionType
+     */
+    abstract getTxId: (tx: TransactionType) => string;
+    /**
+     * manipulate transactions before processing
+     * @param txs
+     * @param block
+     */
+    protected preprocessTransactions: (txs: Array<TransactionType>, block: BlockInfo) => TransactionType[];
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param txs
+     * @param block
+     */
+    processTransactions: (txs: Array<TransactionType>, block: BlockInfo) => Promise<boolean>;
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash: block hash
+     */
+    forkBlock: (hash: string) => Promise<void>;
+    /**
+     * Extractor box initialization
+     * No action needed in observation extractors
+     */
+    initializeData: () => Promise<void>;
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ObservationEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery: () => SelectQueryBuilder<ObservationEntity>;
+}
+//# sourceMappingURL=abstractObservationExtractor.d.ts.map

package/dist/extractor/abstractObservationExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractObservationExtractor.d.ts","sourceRoot":"","sources":["../../lib/extractor/abstractObservationExtractor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGlE,8BAAsB,4BAA4B,CAChD,eAAe,CACf,SAAQ,iBAAiB,CAAC,eAAe,EAAE,iBAAiB,CAAC;IAC7D,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAC1C,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAC1C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IACpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;IACpD,SAAS,CAAC,SAAS,EAAE,0BAA0B,CAAC,eAAe,CAAC,CAAC;IACjE,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAGnC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,EAChB,SAAS,EAAE,0BAA0B,CAAC,eAAe,CAAC,EACtD,MAAM,CAAC,EAAE,cAAc;IAazB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,MAAM,CAAC;IAElD;;;;OAIG;IACH,SAAS,CAAC,sBAAsB,GAC9B,KAAK,KAAK,CAAC,eAAe,CAAC,EAC3B,OAAO,SAAS,uBACT;IAET;;;;;OAKG;IACH,mBAAmB,GACjB,KAAK,KAAK,CAAC,eAAe,CAAC,EAC3B,OAAO,SAAS,KACf,OAAO,CAAC,OAAO,CAAC,CA2BjB;IAEF;;;OAGG;IACH,SAAS,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CAE7C;IAEF;;;OAGG;IACH,cAAc,sBAEZ;IAEF;;;;;OAKG;IACH,qBAAqB,QAAO,kBAAkB,CAAC,iBAAiB,CAAC,CACd;CACpD"}

package/dist/extractor/abstractObservationExtractor.js

@@ -0,0 +1,80 @@
+import { blake2b } from 'blakejs';
+import { Buffer } from 'buffer';
+import { AbstractExtractor } from '@rosen-bridge/abstract-extractor';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { ObservationEntityAction } from '../actions/db';
+export class AbstractObservationExtractor extends AbstractExtractor {
+    logger;
+    dataSource;
+    tokens;
+    actions;
+    extractor;
+    constructor(dataSource, tokens, extractor, logger) {
+        super();
+        this.dataSource = dataSource;
+        this.tokens = tokens;
+        this.logger = logger ? logger : new DummyLogger();
+        this.actions = new ObservationEntityAction(dataSource, this.logger.child('ObservationEntityAction'));
+        this.extractor = extractor;
+    }
+    /**
+     * manipulate transactions before processing
+     * @param txs
+     * @param block
+     */
+    preprocessTransactions = (txs, block) => txs;
+    /**
+     * gets block id and transactions corresponding to the block and saves if they are valid rosen
+     *  transactions and in case of success return true and in case of failure returns false
+     * @param txs
+     * @param block
+     */
+    processTransactions = (txs, block) => {
+        const observations = [];
+        const filteredTxs = this.preprocessTransactions(txs, block);
+        filteredTxs.forEach((transaction) => {
+            const data = this.extractor.get(transaction);
+            if (data) {
+                const requestId = Buffer.from(blake2b(this.getTxId(transaction), undefined, 32)).toString('hex');
+                observations.push({
+                    fromChain: this.FROM_CHAIN,
+                    toChain: data.toChain,
+                    amount: data.amount,
+                    sourceChainTokenId: data.sourceChainTokenId,
+                    targetChainTokenId: data.targetChainTokenId,
+                    sourceTxId: data.sourceTxId,
+                    bridgeFee: data.bridgeFee,
+                    networkFee: data.networkFee,
+                    sourceBlockId: block.hash,
+                    requestId: requestId,
+                    toAddress: data.toAddress,
+                    fromAddress: data.fromAddress,
+                    rawData: data.rawData,
+                });
+            }
+        });
+        return this.actions.storeObservations(observations, block, this.getId());
+    };
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash: block hash
+     */
+    forkBlock = async (hash) => {
+        await this.actions.deleteBlockObservation(hash, this.getId());
+    };
+    /**
+     * Extractor box initialization
+     * No action needed in observation extractors
+     */
+    initializeData = async () => {
+        return;
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ObservationEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = () => this.actions.createUsedBlocksQuery(this.getId());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractObservationExtractor.js","sourceRoot":"","sources":["../../lib/extractor/abstractObservationExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { blake2b } from 'blakejs';\nimport { Buffer } from 'buffer';\n\nimport { AbstractExtractor } from '@rosen-bridge/abstract-extractor';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { DataSource, SelectQueryBuilder } from '@rosen-bridge/extended-typeorm';\nimport { AbstractRosenDataExtractor } from '@rosen-bridge/rosen-extractor';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\nimport { TokenMap } from '@rosen-bridge/tokens';\n\nimport { ObservationEntityAction } from '../actions/db';\nimport { ObservationEntity } from '../entities/observationEntity';\nimport { ExtractedObservation } from '../interfaces/extractedObservation';\n\nexport abstract class AbstractObservationExtractor<\n  TransactionType,\n> extends AbstractExtractor<TransactionType, ObservationEntity> {\n  protected readonly logger: AbstractLogger;\n  protected readonly dataSource: DataSource;\n  protected readonly tokens: TokenMap;\n  protected readonly actions: ObservationEntityAction;\n  protected extractor: AbstractRosenDataExtractor<TransactionType>;\n  abstract readonly FROM_CHAIN: string;\n\n  constructor(\n    dataSource: DataSource,\n    tokens: TokenMap,\n    extractor: AbstractRosenDataExtractor<TransactionType>,\n    logger?: AbstractLogger,\n  ) {\n    super();\n    this.dataSource = dataSource;\n    this.tokens = tokens;\n    this.logger = logger ? logger : new DummyLogger();\n    this.actions = new ObservationEntityAction(\n      dataSource,\n      this.logger.child('ObservationEntityAction'),\n    );\n    this.extractor = extractor;\n  }\n\n  /**\n   * gets Id for current extractor\n   */\n  abstract getId: () => string;\n\n  /**\n   * gets transaction id from TransactionType\n   */\n  abstract getTxId: (tx: TransactionType) => string;\n\n  /**\n   * manipulate transactions before processing\n   * @param txs\n   * @param block\n   */\n  protected preprocessTransactions = (\n    txs: Array<TransactionType>,\n    block: BlockInfo, // eslint-disable-line @typescript-eslint/no-unused-vars\n  ) => txs;\n\n  /**\n   * gets block id and transactions corresponding to the block and saves if they are valid rosen\n   *  transactions and in case of success return true and in case of failure returns false\n   * @param txs\n   * @param block\n   */\n  processTransactions = (\n    txs: Array<TransactionType>,\n    block: BlockInfo,\n  ): Promise<boolean> => {\n    const observations: Array<ExtractedObservation> = [];\n    const filteredTxs = this.preprocessTransactions(txs, block);\n    filteredTxs.forEach((transaction) => {\n      const data = this.extractor.get(transaction);\n      if (data) {\n        const requestId = Buffer.from(\n          blake2b(this.getTxId(transaction), undefined, 32),\n        ).toString('hex');\n        observations.push({\n          fromChain: this.FROM_CHAIN,\n          toChain: data.toChain,\n          amount: data.amount,\n          sourceChainTokenId: data.sourceChainTokenId,\n          targetChainTokenId: data.targetChainTokenId,\n          sourceTxId: data.sourceTxId,\n          bridgeFee: data.bridgeFee,\n          networkFee: data.networkFee,\n          sourceBlockId: block.hash,\n          requestId: requestId,\n          toAddress: data.toAddress,\n          fromAddress: data.fromAddress,\n          rawData: data.rawData,\n        });\n      }\n    });\n    return this.actions.storeObservations(observations, block, this.getId());\n  };\n\n  /**\n   * fork one block and remove all stored information for this block\n   * @param hash: block hash\n   */\n  forkBlock = async (hash: string): Promise<void> => {\n    await this.actions.deleteBlockObservation(hash, this.getId());\n  };\n\n  /**\n   * Extractor box initialization\n   * No action needed in observation extractors\n   */\n  initializeData = async () => {\n    return;\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `ObservationEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (): SelectQueryBuilder<ObservationEntity> =>\n    this.actions.createUsedBlocksQuery(this.getId());\n}\n"]}