@rosen-bridge/raw-data-provider 0.1.0-0022763f → 0.1.0

package/CHANGELOG.md

@@ -1,7 +1,7 @@
 # @rosen-bridge/raw-data-provider
 
-## 0.1.0-0022763f
+## 0.1.0
 
 ### Minor Changes
 
-- Initialized raw-data-provider package
+- Initialize raw-data-provider package

package/dist/abstractRawDataProvider.d.ts

@@ -1,14 +1,15 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';
+import { AbstractObservationExtractor, ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';
 import { DataSource } from '@rosen-bridge/extended-typeorm';
 import { RawDataProviderStateEntityAction } from './actions/rawDataProviderStateEntityAction';
 import { RawDataProviderStateEntity } from './entities';
-export declare abstract class AbstractRawDataProvider {
+export declare abstract class AbstractRawDataProvider<TxType> {
     protected chain: string;
     protected dataSource: DataSource;
+    protected extractor: AbstractObservationExtractor<TxType>;
     protected logger: AbstractLogger;
     protected action: RawDataProviderStateEntityAction;
-    constructor(chain: string, dataSource: DataSource, logger?: AbstractLogger);
+    constructor(chain: string, dataSource: DataSource, extractor: AbstractObservationExtractor<TxType>, logger?: AbstractLogger);
     /**
      * Retrieves the current RawDataProviderStateEntity for the configured chain.
      *
@@ -22,13 +23,20 @@ export declare abstract class AbstractRawDataProvider {
      * @returns void
      */
     fillRawData: () => Promise<void>;
+    /**
+     * fetch transactions related to the input observation parameter
+     *
+     * @param observation
+     * @returns { Promise<TxType[]> }
+     */
+    protected abstract fetchObservationTxs: (observation: ObservationEntity) => Promise<TxType[] | undefined>;
     /**
      * Process observation and write rawData
      *
      * @param observation
      * @return {boolean} determining result of process done successfully or no
      */
-    protected abstract processObservation: (observation: ObservationEntity) => Promise<boolean>;
+    protected processObservation: (observation: ObservationEntity) => Promise<boolean>;
     /**
      * Fills the raw data field for all ObservationEntity records of the current chain of input RawDataProviderStateEntity
      *

package/dist/abstractRawDataProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstractRawDataProvider.d.ts","sourceRoot":"","sources":["../lib/abstractRawDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE5D,OAAO,EAAE,gCAAgC,EAAE,MAAM,4CAA4C,CAAC;AAC9F,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAExD,8BAAsB,uBAAuB;IAIzC,SAAS,CAAC,KAAK,EAAE,MAAM;IACvB,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,MAAM,EAAE,cAAc;IALlC,SAAS,CAAC,MAAM,EAAE,gCAAgC,CAAC;gBAGvC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,UAAU,EACtB,MAAM,GAAE,cAAkC;IAKtD;;;;OAIG;IACH,SAAS,CAAC,0BAA0B,QACxB,OAAO,CAAC,0BAA0B,CAAC,CAuB3C;IAEJ;;;;;OAKG;IACH,WAAW,QAAa,OAAO,CAAC,IAAI,CAAC,CAwBnC;IAEF;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CACrC,WAAW,EAAE,iBAAiB,KAC3B,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB;;;;;OAKG;IACH,SAAS,CAAC,uBAAuB,GAC/B,OAAO,0BAA0B,KAChC,OAAO,CAAC,0BAA0B,CAAC,CAgCpC;CACH"}
+{"version":3,"file":"abstractRawDataProvider.d.ts","sourceRoot":"","sources":["../lib/abstractRawDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,4BAA4B,EAC5B,iBAAiB,EAClB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE5D,OAAO,EAAE,gCAAgC,EAAE,MAAM,4CAA4C,CAAC;AAC9F,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAExD,8BAAsB,uBAAuB,CAAC,MAAM;IAIhD,SAAS,CAAC,KAAK,EAAE,MAAM;IACvB,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EAAE,4BAA4B,CAAC,MAAM,CAAC;IACzD,SAAS,CAAC,MAAM,EAAE,cAAc;IANlC,SAAS,CAAC,MAAM,EAAE,gCAAgC,CAAC;gBAGvC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,4BAA4B,CAAC,MAAM,CAAC,EAC/C,MAAM,GAAE,cAAkC;IAQtD;;;;OAIG;IACH,SAAS,CAAC,0BAA0B,QACxB,OAAO,CAAC,0BAA0B,CAAC,CAuB3C;IAEJ;;;;;OAKG;IACH,WAAW,QAAa,OAAO,CAAC,IAAI,CAAC,CAwBnC;IAEF;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CACtC,WAAW,EAAE,iBAAiB,KAC3B,OAAO,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IACnC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAAU,aAAa,iBAAiB,sBAgBlE;IAEF;;;;;OAKG;IACH,SAAS,CAAC,uBAAuB,GAC/B,OAAO,0BAA0B,KAChC,OAAO,CAAC,0BAA0B,CAAC,CAiCpC;CACH"}

package/dist/abstractRawDataProvider.js

@@ -3,13 +3,15 @@ import { RawDataProviderStateEntityAction } from './actions/rawDataProviderState
 export class AbstractRawDataProvider {
     chain;
     dataSource;
+    extractor;
     logger;
     action;
-    constructor(chain, dataSource, logger = new DummyLogger()) {
+    constructor(chain, dataSource, extractor, logger = new DummyLogger()) {
         this.chain = chain;
         this.dataSource = dataSource;
+        this.extractor = extractor;
         this.logger = logger;
-        this.action = new RawDataProviderStateEntityAction(dataSource, logger);
+        this.action = new RawDataProviderStateEntityAction(dataSource, logger.child('RawDataProviderStateEntityAction'));
     }
     /**
      * Retrieves the current RawDataProviderStateEntity for the configured chain.
@@ -60,6 +62,26 @@ export class AbstractRawDataProvider {
         }
         this.logger.info(`RawDataProvider Finished filling raw-data for [${this.chain}] chain`);
     };
+    /**
+     * Process observation and write rawData
+     *
+     * @param observation
+     * @return {boolean} determining result of process done successfully or no
+     */
+    processObservation = async (observation) => {
+        try {
+            const block = { height: observation.height, hash: observation.block };
+            const txs = await this.fetchObservationTxs(observation);
+            if (!txs)
+                throw new Error(`Transaction [${observation.sourceTxId}] not found or invalid response from ${this.chain} chain.`);
+            this.extractor.processTransactions(txs, block);
+        }
+        catch (err) {
+            this.logger.error(`Processing of observation for ${this.chain} failed: ${err}`);
+            return false;
+        }
+        return true;
+    };
     /**
      * Fills the raw data field for all ObservationEntity records of the current chain of input RawDataProviderStateEntity
      *
@@ -67,7 +89,7 @@ export class AbstractRawDataProvider {
      * @returns
      */
     fillObservationsRawData = async (state) => {
-        const observations = await this.action.fetchChainObservations(this.chain, state.syncedHeight);
+        const observations = await this.action.fetchChainObservations(this.chain, state.syncedHeight, this.extractor.getId());
         if (observations.length === 0)
             throw new Error(`ImpossibleBehavior: No more observations found for [${this.chain}] chain`);
         for (const observation of observations) {
@@ -86,4 +108,4 @@ export class AbstractRawDataProvider {
         return state;
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractRawDataProvider.js","sourceRoot":"","sources":["../lib/abstractRawDataProvider.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';\nimport { DataSource } from '@rosen-bridge/extended-typeorm';\n\nimport { RawDataProviderStateEntityAction } from './actions/rawDataProviderStateEntityAction';\nimport { RawDataProviderStateEntity } from './entities';\n\nexport abstract class AbstractRawDataProvider {\n  protected action: RawDataProviderStateEntityAction;\n\n  constructor(\n    protected chain: string,\n    protected dataSource: DataSource,\n    protected logger: AbstractLogger = new DummyLogger(),\n  ) {\n    this.action = new RawDataProviderStateEntityAction(dataSource, logger);\n  }\n\n  /**\n   * Retrieves the current RawDataProviderStateEntity for the configured chain.\n   *\n   * @returns The existing or newly created RawDataProviderStateEntity\n   */\n  protected fetchOrCreateStateForChain =\n    async (): Promise<RawDataProviderStateEntity> => {\n      let state = await this.action.fetchByChain(this.chain);\n      if (!state) {\n        const latestChainObservation =\n          await this.action.fetchLatestObservationByChain(this.chain);\n        let lastHeight = 0;\n        if (!latestChainObservation) {\n          this.logger.warn(\n            `Not find any ObservationEntity for the ${this.chain} chain`,\n          );\n        } else {\n          lastHeight = latestChainObservation.height;\n        }\n        state = await this.action.store({\n          chain: this.chain,\n          lastHeight: lastHeight,\n          syncedHeight: 0,\n        });\n        this.logger.debug(\n          `Created RawDataProviderStateEntity on [${this.chain}] chain at height ${lastHeight}`,\n        );\n      }\n      return state;\n    };\n\n  /**\n   * Iterates through observations of the current chain and fills their rawData field.\n   * Updates the syncedHeight after each processed observation until the chain is fully synced.\n   *\n   * @returns void\n   */\n  fillRawData = async (): Promise<void> => {\n    this.logger.info(\n      `RawDataProvider Starting raw-data filling for [${this.chain}] chain`,\n    );\n\n    let state: RawDataProviderStateEntity =\n      await this.fetchOrCreateStateForChain();\n    while (state.syncedHeight < state.lastHeight) {\n      this.logger.debug(\n        `RawDataProvider Fetching observations for [${this.chain}] chain from height > ${state.syncedHeight}`,\n      );\n      try {\n        const result = await this.fillObservationsRawData(state);\n        state = result;\n      } catch (err) {\n        this.logger.error(`RawDataProvider Error: ${err}`);\n        if (err instanceof Error && err.stack) this.logger.error(err.stack);\n        break;\n      }\n    }\n\n    this.logger.info(\n      `RawDataProvider Finished filling raw-data for [${this.chain}] chain`,\n    );\n  };\n\n  /**\n   * Process observation and write rawData\n   *\n   * @param observation\n   * @return {boolean} determining result of process done successfully or no\n   */\n  protected abstract processObservation: (\n    observation: ObservationEntity,\n  ) => Promise<boolean>;\n\n  /**\n   * Fills the raw data field for all ObservationEntity records of the current chain of input RawDataProviderStateEntity\n   *\n   * @param state\n   * @returns\n   */\n  protected fillObservationsRawData = async (\n    state: RawDataProviderStateEntity,\n  ): Promise<RawDataProviderStateEntity> => {\n    const observations = await this.action.fetchChainObservations(\n      this.chain,\n      state.syncedHeight,\n    );\n\n    if (observations.length === 0)\n      throw new Error(\n        `ImpossibleBehavior: No more observations found for [${this.chain}] chain`,\n      );\n\n    for (const observation of observations) {\n      this.logger.debug(\n        `RawDataProvider Updating rawData for observation at height ${observation.height} for [${this.chain}] chain`,\n      );\n      const isSuccess = await this.processObservation(observation);\n      if (isSuccess) {\n        this.logger.debug(\n          `RawDataProvider successfully processed observation at height ${observation.height} for [${this.chain}] chain`,\n        );\n      } else {\n        throw new Error(\n          `RawDataProvider failed to process observation at height ${observation.height} for [${this.chain}] chain`,\n        );\n      }\n      state.syncedHeight = observation.height;\n      await this.action.store(state);\n      this.logger.debug(\n        `RawDataProvider syncedHeight updated to ${observation.height} for [${this.chain}] chain`,\n      );\n    }\n    return state;\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractRawDataProvider.js","sourceRoot":"","sources":["../lib/abstractRawDataProvider.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  AbstractObservationExtractor,\n  ObservationEntity,\n} from '@rosen-bridge/abstract-observation-extractor';\nimport { DataSource } from '@rosen-bridge/extended-typeorm';\n\nimport { RawDataProviderStateEntityAction } from './actions/rawDataProviderStateEntityAction';\nimport { RawDataProviderStateEntity } from './entities';\n\nexport abstract class AbstractRawDataProvider<TxType> {\n  protected action: RawDataProviderStateEntityAction;\n\n  constructor(\n    protected chain: string,\n    protected dataSource: DataSource,\n    protected extractor: AbstractObservationExtractor<TxType>,\n    protected logger: AbstractLogger = new DummyLogger(),\n  ) {\n    this.action = new RawDataProviderStateEntityAction(\n      dataSource,\n      logger.child('RawDataProviderStateEntityAction'),\n    );\n  }\n\n  /**\n   * Retrieves the current RawDataProviderStateEntity for the configured chain.\n   *\n   * @returns The existing or newly created RawDataProviderStateEntity\n   */\n  protected fetchOrCreateStateForChain =\n    async (): Promise<RawDataProviderStateEntity> => {\n      let state = await this.action.fetchByChain(this.chain);\n      if (!state) {\n        const latestChainObservation =\n          await this.action.fetchLatestObservationByChain(this.chain);\n        let lastHeight = 0;\n        if (!latestChainObservation) {\n          this.logger.warn(\n            `Not find any ObservationEntity for the ${this.chain} chain`,\n          );\n        } else {\n          lastHeight = latestChainObservation.height;\n        }\n        state = await this.action.store({\n          chain: this.chain,\n          lastHeight: lastHeight,\n          syncedHeight: 0,\n        });\n        this.logger.debug(\n          `Created RawDataProviderStateEntity on [${this.chain}] chain at height ${lastHeight}`,\n        );\n      }\n      return state;\n    };\n\n  /**\n   * Iterates through observations of the current chain and fills their rawData field.\n   * Updates the syncedHeight after each processed observation until the chain is fully synced.\n   *\n   * @returns void\n   */\n  fillRawData = async (): Promise<void> => {\n    this.logger.info(\n      `RawDataProvider Starting raw-data filling for [${this.chain}] chain`,\n    );\n\n    let state: RawDataProviderStateEntity =\n      await this.fetchOrCreateStateForChain();\n    while (state.syncedHeight < state.lastHeight) {\n      this.logger.debug(\n        `RawDataProvider Fetching observations for [${this.chain}] chain from height > ${state.syncedHeight}`,\n      );\n      try {\n        const result = await this.fillObservationsRawData(state);\n        state = result;\n      } catch (err) {\n        this.logger.error(`RawDataProvider Error: ${err}`);\n        if (err instanceof Error && err.stack) this.logger.error(err.stack);\n        break;\n      }\n    }\n\n    this.logger.info(\n      `RawDataProvider Finished filling raw-data for [${this.chain}] chain`,\n    );\n  };\n\n  /**\n   * fetch transactions related to the input observation parameter\n   *\n   * @param observation\n   * @returns { Promise<TxType[]> }\n   */\n  protected abstract fetchObservationTxs: (\n    observation: ObservationEntity,\n  ) => Promise<TxType[] | undefined>;\n  /**\n   * Process observation and write rawData\n   *\n   * @param observation\n   * @return {boolean} determining result of process done successfully or no\n   */\n  protected processObservation = async (observation: ObservationEntity) => {\n    try {\n      const block = { height: observation.height, hash: observation.block };\n      const txs = await this.fetchObservationTxs(observation);\n      if (!txs)\n        throw new Error(\n          `Transaction [${observation.sourceTxId}] not found or invalid response from ${this.chain} chain.`,\n        );\n      this.extractor.processTransactions(txs, block);\n    } catch (err) {\n      this.logger.error(\n        `Processing of observation for ${this.chain} failed: ${err}`,\n      );\n      return false;\n    }\n    return true;\n  };\n\n  /**\n   * Fills the raw data field for all ObservationEntity records of the current chain of input RawDataProviderStateEntity\n   *\n   * @param state\n   * @returns\n   */\n  protected fillObservationsRawData = async (\n    state: RawDataProviderStateEntity,\n  ): Promise<RawDataProviderStateEntity> => {\n    const observations = await this.action.fetchChainObservations(\n      this.chain,\n      state.syncedHeight,\n      this.extractor.getId(),\n    );\n\n    if (observations.length === 0)\n      throw new Error(\n        `ImpossibleBehavior: No more observations found for [${this.chain}] chain`,\n      );\n\n    for (const observation of observations) {\n      this.logger.debug(\n        `RawDataProvider Updating rawData for observation at height ${observation.height} for [${this.chain}] chain`,\n      );\n      const isSuccess = await this.processObservation(observation);\n      if (isSuccess) {\n        this.logger.debug(\n          `RawDataProvider successfully processed observation at height ${observation.height} for [${this.chain}] chain`,\n        );\n      } else {\n        throw new Error(\n          `RawDataProvider failed to process observation at height ${observation.height} for [${this.chain}] chain`,\n        );\n      }\n      state.syncedHeight = observation.height;\n      await this.action.store(state);\n      this.logger.debug(\n        `RawDataProvider syncedHeight updated to ${observation.height} for [${this.chain}] chain`,\n      );\n    }\n    return state;\n  };\n}\n"]}

package/dist/actions/rawDataProviderStateEntityAction.d.ts

@@ -1,11 +1,13 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';
+import { BlockEntity } from '@rosen-bridge/abstract-scanner';
 import { DataSource, Repository } from '@rosen-bridge/extended-typeorm';
 import { RawDataProviderStateEntity } from '../entities';
 export declare class RawDataProviderStateEntityAction {
     protected dataSource: DataSource;
     protected logger: AbstractLogger;
     protected readonly repository: Repository<RawDataProviderStateEntity>;
+    protected readonly blockRepository: Repository<BlockEntity>;
     protected readonly observationRepository: Repository<ObservationEntity>;
     constructor(dataSource: DataSource, logger?: AbstractLogger);
     /**
@@ -37,6 +39,21 @@ export declare class RawDataProviderStateEntityAction {
      * @param length
      * @returns {ObservationEntity[]} Chain-related observations
      */
-    fetchChainObservations: (chain: string, offsetHeight: number, length?: number) => Promise<ObservationEntity[]>;
+    fetchChainObservations: (chain: string, offsetHeight: number, extractorId: string, length?: number) => Promise<ObservationEntity[]>;
+    /**
+     * return saved block by scannerName & height if exists
+     *
+     * @param scannerName
+     * @param height
+     * @return Promise<BlockEntity or undefined>
+     */
+    getBlockOfHeight: (scannerName: string, height: number) => Promise<BlockEntity | undefined>;
+    /**
+     * return lowest height of saved block by chain if exists
+     *
+     * @param chain
+     * @return Promise<BlockEntity or undefined>
+     */
+    getFirstBlockOfChain: (chain: string) => Promise<BlockEntity | undefined>;
 }
 //# sourceMappingURL=rawDataProviderStateEntityAction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rawDataProviderStateEntityAction.d.ts","sourceRoot":"","sources":["../../lib/actions/rawDataProviderStateEntityAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EACL,UAAU,EAEV,UAAU,EACX,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAEzD,qBAAa,gCAAgC;IAKzC,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,MAAM,EAAE,cAAc;IALlC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,0BAA0B,CAAC,CAAC;IACtE,SAAS,CAAC,QAAQ,CAAC,qBAAqB,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC;gBAG5D,UAAU,EAAE,UAAU,EACtB,MAAM,GAAE,cAAkC;IAMtD;;;;;OAKG;IACH,KAAK,GACH,uBAAuB,0BAA0B,KAChD,OAAO,CAAC,0BAA0B,CAAC,CAMpC;IAEF;;;;;OAKG;IACH,YAAY,GACV,OAAO,MAAM,KACZ,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAE3C;IAEF;;;;;OAKG;IACH,6BAA6B,GAC3B,OAAO,MAAM,KACZ,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAKlC;IAEF;;;;;;;OAOG;IACH,sBAAsB,GACpB,OAAO,MAAM,EACb,cAAc,MAAM,EACpB,SAAQ,MAA+B,KACtC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAM7B;CACH"}
+{"version":3,"file":"rawDataProviderStateEntityAction.d.ts","sourceRoot":"","sources":["../../lib/actions/rawDataProviderStateEntityAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,WAAW,EAAW,MAAM,gCAAgC,CAAC;AACtE,OAAO,EACL,UAAU,EAEV,UAAU,EACX,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAEzD,qBAAa,gCAAgC;IAMzC,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,MAAM,EAAE,cAAc;IANlC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,0BAA0B,CAAC,CAAC;IACtE,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAC5D,SAAS,CAAC,QAAQ,CAAC,qBAAqB,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC;gBAG5D,UAAU,EAAE,UAAU,EACtB,MAAM,GAAE,cAAkC;IAOtD;;;;;OAKG;IACH,KAAK,GACH,uBAAuB,0BAA0B,KAChD,OAAO,CAAC,0BAA0B,CAAC,CAMpC;IAEF;;;;;OAKG;IACH,YAAY,GACV,OAAO,MAAM,KACZ,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAE3C;IAEF;;;;;OAKG;IACH,6BAA6B,GAC3B,OAAO,MAAM,KACZ,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAKlC;IAEF;;;;;;;OAOG;IACH,sBAAsB,GACpB,OAAO,MAAM,EACb,cAAc,MAAM,EACpB,aAAa,MAAM,EACnB,SAAQ,MAA+B,KACtC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAU7B;IAEF;;;;;;OAMG;IACH,gBAAgB,GACd,aAAa,MAAM,EACnB,QAAQ,MAAM,KACb,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAKjC;IAEF;;;;;OAKG;IACH,oBAAoB,GAClB,OAAO,MAAM,KACZ,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAMjC;CACH"}

package/dist/actions/rawDataProviderStateEntityAction.js

@@ -1,5 +1,6 @@
 import { DummyLogger } from '@rosen-bridge/abstract-logger';
 import { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';
+import { BlockEntity, PROCEED } from '@rosen-bridge/abstract-scanner';
 import { MoreThan, } from '@rosen-bridge/extended-typeorm';
 import { OBSERVATION_BATCH_SIZE } from '../constants';
 import { RawDataProviderStateEntity } from '../entities';
@@ -7,11 +8,13 @@ export class RawDataProviderStateEntityAction {
     dataSource;
     logger;
     repository;
+    blockRepository;
     observationRepository;
     constructor(dataSource, logger = new DummyLogger()) {
         this.dataSource = dataSource;
         this.logger = logger;
         this.repository = dataSource.getRepository(RawDataProviderStateEntity);
+        this.blockRepository = dataSource.getRepository(BlockEntity);
         this.observationRepository = dataSource.getRepository(ObservationEntity);
     }
     /**
@@ -54,12 +57,42 @@ export class RawDataProviderStateEntityAction {
      * @param length
      * @returns {ObservationEntity[]} Chain-related observations
      */
-    fetchChainObservations = async (chain, offsetHeight, length = OBSERVATION_BATCH_SIZE) => {
+    fetchChainObservations = async (chain, offsetHeight, extractorId, length = OBSERVATION_BATCH_SIZE) => {
         return await this.observationRepository.find({
-            where: { fromChain: chain, height: MoreThan(offsetHeight) },
+            where: {
+                fromChain: chain,
+                height: MoreThan(offsetHeight),
+                extractor: extractorId,
+            },
             order: { height: 'ASC' },
             take: length,
         });
     };
+    /**
+     * return saved block by scannerName & height if exists
+     *
+     * @param scannerName
+     * @param height
+     * @return Promise<BlockEntity or undefined>
+     */
+    getBlockOfHeight = async (scannerName, height) => {
+        const block = await this.blockRepository.findOne({
+            where: { status: PROCEED, scanner: scannerName, height: height },
+        });
+        return block || undefined;
+    };
+    /**
+     * return lowest height of saved block by chain if exists
+     *
+     * @param chain
+     * @return Promise<BlockEntity or undefined>
+     */
+    getFirstBlockOfChain = async (chain) => {
+        const block = await this.blockRepository.findOne({
+            where: { status: PROCEED, scanner: chain },
+            order: { height: 'ASC' },
+        });
+        return block || undefined;
+    };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rawDataProviderStateEntityAction.js","sourceRoot":"","sources":["../../lib/actions/rawDataProviderStateEntityAction.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';\nimport { BlockEntity, PROCEED } from '@rosen-bridge/abstract-scanner';\nimport {\n  DataSource,\n  MoreThan,\n  Repository,\n} from '@rosen-bridge/extended-typeorm';\n\nimport { OBSERVATION_BATCH_SIZE } from '../constants';\nimport { RawDataProviderStateEntity } from '../entities';\n\nexport class RawDataProviderStateEntityAction {\n  protected readonly repository: Repository<RawDataProviderStateEntity>;\n  protected readonly blockRepository: Repository<BlockEntity>;\n  protected readonly observationRepository: Repository<ObservationEntity>;\n\n  constructor(\n    protected dataSource: DataSource,\n    protected logger: AbstractLogger = new DummyLogger(),\n  ) {\n    this.repository = dataSource.getRepository(RawDataProviderStateEntity);\n    this.blockRepository = dataSource.getRepository(BlockEntity);\n    this.observationRepository = dataSource.getRepository(ObservationEntity);\n  }\n\n  /**\n   * Stores one RawDataProviderStateEntity in the database\n   *\n   * @param rawDataProviderEntities\n   * @returns {RawDataProviderStateEntity} saved instance\n   */\n  store = async (\n    rawDataProviderEntity: RawDataProviderStateEntity,\n  ): Promise<RawDataProviderStateEntity> => {\n    const state = await this.repository.save(rawDataProviderEntity);\n    this.logger.debug(\n      `raw-data for chain state [${JSON.stringify(rawDataProviderEntity)}] stored in database`,\n    );\n    return state;\n  };\n\n  /**\n   * Retrieves the RawDataProviderStateEntity of specific chain\n   *\n   * @param chain\n   * @returns {RawDataProviderStateEntity | null} Chain-related state, or null if not found\n   */\n  fetchByChain = async (\n    chain: string,\n  ): Promise<RawDataProviderStateEntity | null> => {\n    return await this.repository.findOne({ where: { chain: chain } });\n  };\n\n  /**\n   * Retrieves the latest ObservationEntity for the specified chain\n   *\n   * @param chain\n   * @returns {ObservationEntity | null} Latest related observation, or null if not found\n   */\n  fetchLatestObservationByChain = async (\n    chain: string,\n  ): Promise<ObservationEntity | null> => {\n    return await this.observationRepository.findOne({\n      where: { fromChain: chain, rawData: '' },\n      order: { height: 'DESC' },\n    });\n  };\n\n  /**\n   * Fetches a batch of ObservationEntity records for the given chain\n   *\n   * @param chain\n   * @param offsetHeight\n   * @param length\n   * @returns {ObservationEntity[]} Chain-related observations\n   */\n  fetchChainObservations = async (\n    chain: string,\n    offsetHeight: number,\n    extractorId: string,\n    length: number = OBSERVATION_BATCH_SIZE,\n  ): Promise<ObservationEntity[]> => {\n    return await this.observationRepository.find({\n      where: {\n        fromChain: chain,\n        height: MoreThan(offsetHeight),\n        extractor: extractorId,\n      },\n      order: { height: 'ASC' },\n      take: length,\n    });\n  };\n\n  /**\n   * return saved block by scannerName & height if exists\n   *\n   * @param scannerName\n   * @param height\n   * @return Promise<BlockEntity or undefined>\n   */\n  getBlockOfHeight = async (\n    scannerName: string,\n    height: number,\n  ): Promise<BlockEntity | undefined> => {\n    const block = await this.blockRepository.findOne({\n      where: { status: PROCEED, scanner: scannerName, height: height },\n    });\n    return block || undefined;\n  };\n\n  /**\n   * return lowest height of saved block by chain if exists\n   *\n   * @param chain\n   * @return Promise<BlockEntity or undefined>\n   */\n  getFirstBlockOfChain = async (\n    chain: string,\n  ): Promise<BlockEntity | undefined> => {\n    const block = await this.blockRepository.findOne({\n      where: { status: PROCEED, scanner: chain },\n      order: { height: 'ASC' },\n    });\n    return block || undefined;\n  };\n}\n"]}

package/dist/providers/bitcoin/bitcoinEsploraRawDataProvider.d.ts

@@ -1,20 +1,25 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';
 import { BitcoinEsploraObservationExtractor } from '@rosen-bridge/bitcoin-observation-extractor';
+import { BitcoinRunesEsploraObservationExtractor } from '@rosen-bridge/bitcoin-runes-observation-extractor';
+import { BitcoinEsploraTransaction } from '@rosen-bridge/bitcoin-scanner';
 import { DataSource } from '@rosen-bridge/extended-typeorm';
 import { AbstractRawDataProvider } from '../../abstractRawDataProvider';
-export declare class BitcoinEsploraRawDataProvider extends AbstractRawDataProvider {
+import { EsploraConnectionInfoInterface } from '../../types';
+export declare class BitcoinEsploraRawDataProvider extends AbstractRawDataProvider<BitcoinEsploraTransaction> {
     protected dataSource: DataSource;
-    protected extractor: BitcoinEsploraObservationExtractor;
+    protected extractor: BitcoinEsploraObservationExtractor | BitcoinRunesEsploraObservationExtractor;
+    protected esploraConnectionInfo: EsploraConnectionInfoInterface;
     protected logger: AbstractLogger;
+    ESPLORA_BLOCK_TXS_LIMIT: number;
     protected client: import("@rosen-clients/rate-limited-axios").Axios;
-    constructor(dataSource: DataSource, extractor: BitcoinEsploraObservationExtractor, esploraBaseUrl: string, logger: AbstractLogger);
+    constructor(dataSource: DataSource, extractor: BitcoinEsploraObservationExtractor | BitcoinRunesEsploraObservationExtractor, esploraConnectionInfo: EsploraConnectionInfoInterface, logger: AbstractLogger);
     /**
-     * Process observation and write rawData
+     * fetch bitcoin transactions related to the input observation parameter
      *
      * @param observation
-     * @return {boolean} determining result of process done successfully or no
+     * @returns { Promise<BitcoinEsploraTransaction[]> }
      */
-    protected processObservation: (observation: ObservationEntity) => Promise<boolean>;
+    protected fetchObservationTxs: (observation: ObservationEntity) => Promise<BitcoinEsploraTransaction[] | undefined>;
 }
 //# sourceMappingURL=bitcoinEsploraRawDataProvider.d.ts.map

package/dist/providers/bitcoin/bitcoinEsploraRawDataProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitcoinEsploraRawDataProvider.d.ts","sourceRoot":"","sources":["../../../lib/providers/bitcoin/bitcoinEsploraRawDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AACjG,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAI5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAExE,qBAAa,6BAA8B,SAAQ,uBAAuB;IAItE,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EAAE,kCAAkC;IAEvD,SAAS,CAAC,MAAM,EAAE,cAAc;IANlC,SAAS,CAAC,MAAM,oDAAC;gBAGL,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,kCAAkC,EACvD,cAAc,EAAE,MAAM,EACZ,MAAM,EAAE,cAAc;IAMlC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAAU,aAAa,iBAAiB,sBAgBlE;CACH"}
+{"version":3,"file":"bitcoinEsploraRawDataProvider.d.ts","sourceRoot":"","sources":["../../../lib/providers/bitcoin/bitcoinEsploraRawDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AACjG,OAAO,EAAE,uCAAuC,EAAE,MAAM,mDAAmD,CAAC;AAC5G,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAG5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAE7D,qBAAa,6BAA8B,SAAQ,uBAAuB,CAAC,yBAAyB,CAAC;IAMjG,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EACf,kCAAkC,GAClC,uCAAuC;IAC3C,SAAS,CAAC,qBAAqB,EAAE,8BAA8B;IAC/D,SAAS,CAAC,MAAM,EAAE,cAAc;IAVlC,uBAAuB,SAAM;IAE7B,SAAS,CAAC,MAAM,oDAAC;gBAGL,UAAU,EAAE,UAAU,EACtB,SAAS,EACf,kCAAkC,GAClC,uCAAuC,EACjC,qBAAqB,EAAE,8BAA8B,EACrD,MAAM,EAAE,cAAc;IAclC;;;;;OAKG;IACH,SAAS,CAAC,mBAAmB,GAC3B,aAAa,iBAAiB,KAC7B,OAAO,CAAC,yBAAyB,EAAE,GAAG,SAAS,CAAC,CA6BjD;CACH"}

package/dist/providers/bitcoin/bitcoinEsploraRawDataProvider.js

@@ -1,38 +1,52 @@
+import { BitcoinRunesEsploraObservationExtractor } from '@rosen-bridge/bitcoin-runes-observation-extractor';
 import axios from '@rosen-clients/rate-limited-axios';
 import { AbstractRawDataProvider } from '../../abstractRawDataProvider';
 export class BitcoinEsploraRawDataProvider extends AbstractRawDataProvider {
     dataSource;
     extractor;
+    esploraConnectionInfo;
     logger;
+    ESPLORA_BLOCK_TXS_LIMIT = 25;
     client;
-    constructor(dataSource, extractor, esploraBaseUrl, logger) {
-        super('bitcoin', dataSource, logger);
+    constructor(dataSource, extractor, esploraConnectionInfo, logger) {
+        const chain = extractor instanceof BitcoinRunesEsploraObservationExtractor
+            ? 'bitcoin-runes'
+            : 'bitcoin';
+        super(chain, dataSource, extractor, logger);
         this.dataSource = dataSource;
         this.extractor = extractor;
+        this.esploraConnectionInfo = esploraConnectionInfo;
         this.logger = logger;
-        this.client = axios.create({ baseURL: esploraBaseUrl });
+        this.client = axios.create({
+            baseURL: esploraConnectionInfo.url,
+            timeout: (esploraConnectionInfo.timeout ?? 0) * 1000,
+            headers: { 'Content-Type': 'application/json' },
+        });
     }
     /**
-     * Process observation and write rawData
+     * fetch bitcoin transactions related to the input observation parameter
      *
      * @param observation
-     * @return {boolean} determining result of process done successfully or no
+     * @returns { Promise<BitcoinEsploraTransaction[]> }
      */
-    processObservation = async (observation) => {
+    fetchObservationTxs = async (observation) => {
         try {
-            const block = { height: observation.height, hash: observation.block };
-            const tx = await this.client.post(`/tx/${observation.sourceTxId}`, {
-                method: 'getrawtransaction',
-                id: 0,
-                params: [observation.sourceTxId, true],
-            });
-            this.extractor.processTransactions([tx.data], block);
+            const blockHash = observation.block;
+            const txCount = (await this.client.get(`${this.esploraConnectionInfo.prefix ?? '/api'}/block/${blockHash}`)).data.tx_count;
+            let offset = 0;
+            while (offset < txCount) {
+                const txs = (await this.client.get(`${this.esploraConnectionInfo.prefix ?? '/api'}/block/${blockHash}/txs/${offset}`)).data;
+                const tx = txs
+                    .filter((item) => item.txid == observation.sourceTxId)
+                    .at(0);
+                if (tx)
+                    return [tx];
+                offset += this.ESPLORA_BLOCK_TXS_LIMIT;
+            }
         }
         catch (err) {
-            this.logger.error(`Processing of observation for bitcoin-esplora failed: ${err}`);
-            return false;
+            throw new Error(`Fetch transactions by [${observation.sourceTxId}] id of related observation for [${this.chain}] chain failed: ${err}`);
         }
-        return true;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/bitcoin/bitcoinRpcRawDataProvider.d.ts

@@ -1,21 +1,23 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor';
 import { BitcoinRpcObservationExtractor } from '@rosen-bridge/bitcoin-observation-extractor';
+import { BitcoinRunesRpcObservationExtractor } from '@rosen-bridge/bitcoin-runes-observation-extractor';
+import { BitcoinRpcTransaction } from '@rosen-bridge/bitcoin-scanner';
 import { DataSource } from '@rosen-bridge/extended-typeorm';
 import { AbstractRawDataProvider } from '../../abstractRawDataProvider';
 import { RpcConnectionInfoInterface } from '../../types';
-export declare class BitcoinRpcRawDataProvider extends AbstractRawDataProvider {
+export declare class BitcoinRpcRawDataProvider extends AbstractRawDataProvider<BitcoinRpcTransaction> {
     protected dataSource: DataSource;
-    protected extractor: BitcoinRpcObservationExtractor;
+    protected extractor: BitcoinRpcObservationExtractor | BitcoinRunesRpcObservationExtractor;
     protected logger: AbstractLogger;
     protected client: import("@rosen-clients/rate-limited-axios").Axios;
-    constructor(dataSource: DataSource, extractor: BitcoinRpcObservationExtractor, rpcConnectionInfo: RpcConnectionInfoInterface, logger: AbstractLogger);
+    constructor(dataSource: DataSource, extractor: BitcoinRpcObservationExtractor | BitcoinRunesRpcObservationExtractor, rpcConnectionInfo: RpcConnectionInfoInterface, logger: AbstractLogger);
     /**
-     * Process observation and write rawData
+     * fetch bitcoin transactions related to the input observation parameter
      *
      * @param observation
-     * @return {boolean} determining result of process done successfully or no
+     * @returns { Promise<BitcoinRpcTransaction[]> }
      */
-    protected processObservation: (observation: ObservationEntity) => Promise<boolean>;
+    protected fetchObservationTxs: (observation: ObservationEntity) => Promise<BitcoinRpcTransaction[]>;
 }
 //# sourceMappingURL=bitcoinRpcRawDataProvider.d.ts.map

package/dist/providers/bitcoin/bitcoinRpcRawDataProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitcoinRpcRawDataProvider.d.ts","sourceRoot":"","sources":["../../../lib/providers/bitcoin/bitcoinRpcRawDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAI5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAEzD,qBAAa,yBAA0B,SAAQ,uBAAuB;IAIlE,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EAAE,8BAA8B;IAEnD,SAAS,CAAC,MAAM,EAAE,cAAc;IANlC,SAAS,CAAC,MAAM,oDAAC;gBAGL,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,8BAA8B,EACnD,iBAAiB,EAAE,0BAA0B,EACnC,MAAM,EAAE,cAAc;IAkBlC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAAU,aAAa,iBAAiB,sBAgBlE;CACH"}
+{"version":3,"file":"bitcoinRpcRawDataProvider.d.ts","sourceRoot":"","sources":["../../../lib/providers/bitcoin/bitcoinRpcRawDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,mCAAmC,EAAE,MAAM,mDAAmD,CAAC;AACxG,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAG5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAEzD,qBAAa,yBAA0B,SAAQ,uBAAuB,CAAC,qBAAqB,CAAC;IAIzF,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EACf,8BAA8B,GAC9B,mCAAmC;IAEvC,SAAS,CAAC,MAAM,EAAE,cAAc;IARlC,SAAS,CAAC,MAAM,oDAAC;gBAGL,UAAU,EAAE,UAAU,EACtB,SAAS,EACf,8BAA8B,GAC9B,mCAAmC,EACvC,iBAAiB,EAAE,0BAA0B,EACnC,MAAM,EAAE,cAAc;IAsBlC;;;;;OAKG;IACH,SAAS,CAAC,mBAAmB,GAC3B,aAAa,iBAAiB,KAC7B,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAcjC;CACH"}

package/dist/providers/bitcoin/bitcoinRpcRawDataProvider.js

@@ -1,3 +1,4 @@
+import { BitcoinRunesRpcObservationExtractor } from '@rosen-bridge/bitcoin-runes-observation-extractor';
 import axios from '@rosen-clients/rate-limited-axios';
 import { AbstractRawDataProvider } from '../../abstractRawDataProvider';
 export class BitcoinRpcRawDataProvider extends AbstractRawDataProvider {
@@ -6,7 +7,10 @@ export class BitcoinRpcRawDataProvider extends AbstractRawDataProvider {
     logger;
     client;
     constructor(dataSource, extractor, rpcConnectionInfo, logger) {
-        super('bitcoin', dataSource, logger);
+        const chain = extractor instanceof BitcoinRunesRpcObservationExtractor
+            ? 'bitcoin-runes'
+            : 'bitcoin';
+        super(chain, dataSource, extractor, logger);
         this.dataSource = dataSource;
         this.extractor = extractor;
         this.logger = logger;
@@ -24,26 +28,22 @@ export class BitcoinRpcRawDataProvider extends AbstractRawDataProvider {
         });
     }
     /**
-     * Process observation and write rawData
+     * fetch bitcoin transactions related to the input observation parameter
      *
      * @param observation
-     * @return {boolean} determining result of process done successfully or no
+     * @returns { Promise<BitcoinRpcTransaction[]> }
      */
-    processObservation = async (observation) => {
+    fetchObservationTxs = async (observation) => {
         try {
-            const block = { height: observation.height, hash: observation.block };
-            const tx = await this.client.post('', {
+            return (await this.client.post('', {
                 method: 'getrawtransaction',
                 id: 0,
                 params: [observation.sourceTxId, true],
-            });
-            this.extractor.processTransactions([tx.data], block);
+            })).data?.result;
         }
         catch (err) {
-            this.logger.error(`Processing of observation for bitcoin-rpc failed: ${err}`);
-            return false;
+            throw new Error(`Fetch transactions by [${observation.sourceTxId}] id of related observation for [${this.chain}] chain failed: ${err}`);
         }
-        return true;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/bitcoin/index.d.ts

@@ -1,2 +1,3 @@
 export { BitcoinRpcRawDataProvider } from './bitcoinRpcRawDataProvider';
+export { BitcoinEsploraRawDataProvider } from './bitcoinEsploraRawDataProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/providers/bitcoin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/providers/bitcoin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/providers/bitcoin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/providers/bitcoin/index.js

@@ -1,2 +1,3 @@
 export { BitcoinRpcRawDataProvider } from './bitcoinRpcRawDataProvider';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvcHJvdmlkZXJzL2JpdGNvaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBCaXRjb2luUnBjUmF3RGF0YVByb3ZpZGVyIH0gZnJvbSAnLi9iaXRjb2luUnBjUmF3RGF0YVByb3ZpZGVyJztcbiJdfQ==
+export { BitcoinEsploraRawDataProvider } from './bitcoinEsploraRawDataProvider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvcHJvdmlkZXJzL2JpdGNvaW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDeEUsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0saUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBCaXRjb2luUnBjUmF3RGF0YVByb3ZpZGVyIH0gZnJvbSAnLi9iaXRjb2luUnBjUmF3RGF0YVByb3ZpZGVyJztcbmV4cG9ydCB7IEJpdGNvaW5Fc3Bsb3JhUmF3RGF0YVByb3ZpZGVyIH0gZnJvbSAnLi9iaXRjb2luRXNwbG9yYVJhd0RhdGFQcm92aWRlcic7XG4iXX0=

package/dist/providers/cardano/cardanoKoiosRawDataProvider.d.ts

@@ -3,8 +3,8 @@ import { ObservationEntity } from '@rosen-bridge/abstract-observation-extractor'
 import { CardanoKoiosObservationExtractor } from '@rosen-bridge/cardano-observation-extractor';
 import { DataSource } from '@rosen-bridge/extended-typeorm';
 import { AbstractRawDataProvider } from '../../abstractRawDataProvider';
-import { ConnectionByAuthInfoInterface } from '../../types';
-export declare class CardanoKoiosRawDataProvider extends AbstractRawDataProvider {
+import { ConnectionByAuthInfoInterface, KoiosTransaction } from '../../types';
+export declare class CardanoKoiosRawDataProvider extends AbstractRawDataProvider<KoiosTransaction> {
     protected dataSource: DataSource;
     protected extractor: CardanoKoiosObservationExtractor;
     protected logger: AbstractLogger;
@@ -98,11 +98,11 @@ export declare class CardanoKoiosRawDataProvider extends AbstractRawDataProvider
     };
     constructor(dataSource: DataSource, extractor: CardanoKoiosObservationExtractor, koiosConnectionInfo: ConnectionByAuthInfoInterface, logger: AbstractLogger);
     /**
-     * Process observation and write rawData
+     * fetch cardano-koios transactions related to the input observation parameter
      *
      * @param observation
-     * @return {boolean} determining result of process done successfully or no
+     * @returns { Promise<KoiosTransaction[]> }
      */
-    protected processObservation: (observation: ObservationEntity) => Promise<boolean>;
+    protected fetchObservationTxs: (observation: ObservationEntity) => Promise<KoiosTransaction[] | undefined>;
 }
 //# sourceMappingURL=cardanoKoiosRawDataProvider.d.ts.map

package/dist/providers/cardano/cardanoKoiosRawDataProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cardanoKoiosRawDataProvider.d.ts","sourceRoot":"","sources":["../../../lib/providers/cardano/cardanoKoiosRawDataProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAK5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC;AAE5D,qBAAa,2BAA4B,SAAQ,uBAAuB;IAIpE,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EAAE,gCAAgC;IAErD,SAAS,CAAC,MAAM,EAAE,cAAc;IANlC,SAAS,CAAC,MAAM;;;uBAXkD,CAAC;;;;;0BAO/B,CAAC;4BAGhC,CAAA;oCAIG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8CuwG,CAAC;;;;4BAAuY,CAAC;4BAA0G,CAAC;;;;+BAAuY,CAAC;;;;;;;;;;;;4BAAmwC,CAAC;kCAAgH,CAAC;gCAA0H,CAAC;;;;;;;;;;;MAjD3mL;gBAGL,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,gCAAgC,EACrD,mBAAmB,EAAE,6BAA6B,EACxC,MAAM,EAAE,cAAc;IASlC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAAU,aAAa,iBAAiB,sBA0BlE;CACH"}
+{"version":3,"file":"cardanoKoiosRawDataProvider.d.ts","sourceRoot":"","sources":["../../../lib/providers/cardano/cardanoKoiosRawDataProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAI5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE9E,qBAAa,2BAA4B,SAAQ,uBAAuB,CAAC,gBAAgB,CAAC;IAItF,SAAS,CAAC,UAAU,EAAE,UAAU;IAChC,SAAS,CAAC,SAAS,EAAE,gCAAgC;IAErD,SAAS,CAAC,MAAM,EAAE,cAAc;IANlC,SAAS,CAAC,MAAM;;;uBAVkD,CAAC;;;;;0BAO9C,CAAC;4BAEsB,CAAC;oCAIf,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwCw8G,CAAC;;;;4BAAuY,CAAC;4BAA0G,CAAC;;;;+BAAuY,CAAC;;;;;;;;;;;;4BAAmwC,CAAC;kCAAgH,CAAC;gCAA0H,CAAC;;;;;;;;;;;MA3Cl0L;gBAGL,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,gCAAgC,EACrD,mBAAmB,EAAE,6BAA6B,EACxC,MAAM,EAAE,cAAc;IASlC;;;;;OAKG;IACH,SAAS,CAAC,mBAAmB,GAC3B,aAAa,iBAAiB,KAC7B,OAAO,CAAC,gBAAgB,EAAE,GAAG,SAAS,CAAC,CAkBxC;CACH"}