@rosen-bridge/abstract-extractor 0.3.0 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @rosen-bridge/abstract-extractor
 
+## 1.0.0
+
+### Major Changes
+
+- Move database action shared logic to abstract class
+- Add callback support to abstract ergo extractor and update abstract db action interface
+
+### Patch Changes
+
+- Ensure initialization with the node is stateful and resilient to network issues
+- Fix `processTransaction` to return false if data insertion encounters error
+- Modify the initialization procedure to retry upon failure
+
+## 0.3.1
+
+### Patch Changes
+
+- Remove unnecessary properties from abstract extracted data type
+- Add extras field to store extra information for spending
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/ergo/AbstractErgoExtractor.d.ts

@@ -1,22 +1,45 @@
-import { DataSource } from 'typeorm';
 import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';
 import { AbstractExtractor } from '../AbstractExtractor';
 import { AbstractErgoExtractorAction } from './AbstractErgoExtractorAction';
 import { BlockInfo } from '../interfaces';
-import { Transaction, OutputBox, ErgoExtractedData } from './interfaces';
-export declare abstract class AbstractErgoExtractor<ExtractedData extends ErgoExtractedData> extends AbstractExtractor<Transaction> {
-    protected readonly dataSource: DataSource;
-    protected abstract actions: AbstractErgoExtractorAction<ExtractedData>;
+import { Transaction, OutputBox, AbstractBoxData, CallbackType, CallbackMap, CallbackDataMap } from './interfaces';
+import { AbstractErgoExtractorEntity } from './AbstractErgoExtractorEntity';
+export declare abstract class AbstractErgoExtractor<ExtractedData extends AbstractBoxData, ExtractorEntity extends AbstractErgoExtractorEntity> extends AbstractExtractor<Transaction> {
+    protected abstract actions: AbstractErgoExtractorAction<ExtractedData, ExtractorEntity>;
     protected logger: AbstractLogger;
+    protected callbacks: {
+        [K in CallbackType]: Map<string, CallbackMap<ExtractedData>[K]>;
+    };
+    private callbackMutex;
     constructor(logger?: DummyLogger);
+    /**
+     * hook a new callback on a callback type
+     * @param type
+     * @param id
+     * @param callback
+     * @returns callback registered id
+     */
+    hook: <T extends CallbackType>(type: T, callback: CallbackMap<ExtractedData>[T]) => Promise<string>;
+    /**
+     * unhook a callback on a type
+     * returns false if there is no registered callback with the id
+     * @param type
+     * @param id
+     * @returns success status
+     */
+    unhook: (type: CallbackType, id: string) => Promise<boolean>;
+    /**
+     * trigger all callbacks registered on a specific type with the provided data
+     * @param type
+     * @param data
+     */
+    protected triggerCallbacks<T extends CallbackType>(type: T, data: CallbackDataMap<ExtractedData>[T]): void;
     /**
      * extract box data to proper format (not including spending information)
      * @param box
-     * @param blockId box inclusion block hash
-     * @param height box inclusion block height
      * @return extracted data in proper format
      */
-    abstract extractBoxData: (box: OutputBox, blockId: string, height: number) => Omit<ExtractedData, 'spendBlock' | 'spendHeight'> | undefined;
+    abstract extractBoxData: (box: OutputBox) => ExtractedData | undefined;
     /**
      * check proper data format in the box
      * @param box

package/dist/ergo/AbstractErgoExtractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractErgoExtractor.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EACL,WAAW,EACX,SAAS,EACT,iBAAiB,EAElB,MAAM,cAAc,CAAC;AAEtB,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,iBAAiB,CACvC,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAC1C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC,aAAa,CAAC,CAAC;IACvE,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,cAAoB;IAKtC;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,KACX,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,aAAa,CAAC,GAAG,SAAS,CAAC;IAEnE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAE9C;;;;;OAKG;IACH,mBAAmB,QACZ,WAAW,EAAE,SACX,SAAS,KACf,QAAQ,OAAO,CAAC,CAyCjB;IAEF;;;OAGG;IACH,SAAS,SAAgB,MAAM,KAAG,QAAQ,IAAI,CAAC,CAE7C;CACH"}
+{"version":3,"file":"AbstractErgoExtractor.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EACL,WAAW,EACX,SAAS,EACT,eAAe,EAEf,YAAY,EACZ,WAAW,EACX,eAAe,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,eAAe,EACrC,eAAe,SAAS,2BAA2B,CACnD,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CACrD,aAAa,EACb,eAAe,CAChB,CAAC;IACF,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;IACjC,SAAS,CAAC,SAAS,EAAE;SAClB,CAAC,IAAI,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;KAChE,CAKC;IACF,OAAO,CAAC,aAAa,CAAe;gBAExB,MAAM,cAAoB;IAKtC;;;;;;OAMG;IACH,IAAI,iCACI,CAAC,YACG,YAAY,aAAa,CAAC,CAAC,CAAC,CAAC,KACtC,QAAQ,MAAM,CAAC,CAOhB;IAEF;;;;;;OAMG;IACH,MAAM,SAAgB,YAAY,MAAM,MAAM,KAAG,QAAQ,OAAO,CAAC,CAY/D;IAEF;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,SAAS,YAAY,EAC/C,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GACtC,IAAI;IAOP;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,aAAa,GAAG,SAAS,CAAC;IAEvE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAE9C;;;;;OAKG;IACH,mBAAmB,QACZ,WAAW,EAAE,SACX,SAAS,KACf,QAAQ,OAAO,CAAC,CAuDjB;IAEF;;;OAGG;IACH,SAAS,SAAgB,MAAM,KAAG,QAAQ,IAAI,CAAC,CAM7C;CACH"}

package/dist/ergo/AbstractErgoExtractor.js

@@ -1,13 +1,66 @@
 import { DummyLogger } from '@rosen-bridge/abstract-logger';
 import JsonBigInt from '@rosen-bridge/json-bigint';
+import { Mutex } from 'await-semaphore';
+import { v4 as uuidv4 } from 'uuid';
 import { AbstractExtractor } from '../AbstractExtractor';
+import { CallbackType, } from './interfaces';
 export class AbstractErgoExtractor extends AbstractExtractor {
-    dataSource;
     logger;
+    callbacks = {
+        [CallbackType.Update]: new Map(),
+        [CallbackType.Insert]: new Map(),
+        [CallbackType.Delete]: new Map(),
+        [CallbackType.Spend]: new Map(),
+    };
+    callbackMutex = new Mutex();
     constructor(logger = new DummyLogger()) {
         super();
         this.logger = logger;
     }
+    /**
+     * hook a new callback on a callback type
+     * @param type
+     * @param id
+     * @param callback
+     * @returns callback registered id
+     */
+    hook = async (type, callback) => {
+        const release = await this.callbackMutex.acquire();
+        const callbackMap = this.callbacks[type];
+        const id = uuidv4();
+        callbackMap.set(id, callback);
+        release();
+        return id;
+    };
+    /**
+     * unhook a callback on a type
+     * returns false if there is no registered callback with the id
+     * @param type
+     * @param id
+     * @returns success status
+     */
+    unhook = async (type, id) => {
+        const release = await this.callbackMutex.acquire();
+        const callbackMap = this.callbacks[type];
+        if (!callbackMap.has(id)) {
+            this.logger.warn(`Callback with Id [${id}] is not registered for type [${type}].`);
+            return false;
+        }
+        callbackMap.delete(id);
+        release();
+        return true;
+    };
+    /**
+     * trigger all callbacks registered on a specific type with the provided data
+     * @param type
+     * @param data
+     */
+    triggerCallbacks(type, data) {
+        const callbackMap = this.callbacks[type];
+        callbackMap.forEach((callback) => {
+            callback(data);
+        });
+    }
     /**
      * process a list of transactions in a block and store required information
      * @param txs list of transactions in the block
@@ -24,7 +77,7 @@ export class AbstractErgoExtractor extends AbstractExtractor {
                         continue;
                     }
                     this.logger.debug(`Trying to extract data from box ${output.boxId}`);
-                    const extractedData = this.extractBoxData(output, block.hash, block.height);
+                    const extractedData = this.extractBoxData(output);
                     if (extractedData) {
                         this.logger.debug(`Extracted data ${JsonBigInt.stringify(extractedData)} from box ${output.boxId}`);
                         boxes.push(extractedData);
@@ -36,12 +89,20 @@ export class AbstractErgoExtractor extends AbstractExtractor {
                     boxIndex += 1;
                 }
             }
-            if (boxes.length > 0)
-                await this.actions.insertBoxes(boxes, this.getId());
-            await this.actions.spendBoxes(spentInfos, block, this.getId());
+            if (boxes.length > 0) {
+                if (!(await this.actions.storeBoxes(boxes, block, this.getId()))) {
+                    this.logger.warn(`Data insertion failed for ${this.getId()} at the block ${block.height}`);
+                    return false;
+                }
+                this.triggerCallbacks(CallbackType.Insert, boxes);
+            }
+            const spentData = await this.actions.spendBoxes(spentInfos, block, this.getId());
+            if (spentData.length > 0) {
+                this.triggerCallbacks(CallbackType.Spend, spentData);
+            }
         }
         catch (e) {
-            this.logger.error(`Error in storing data in ${this.getId()} of the block ${block}: ${e}`);
+            this.logger.error(`Processing transactions failed for ${this.getId()} at the block ${block.height} with error: ${e}`);
             return false;
         }
         return true;
@@ -51,7 +112,11 @@ export class AbstractErgoExtractor extends AbstractExtractor {
      * @param hash block hash
      */
     forkBlock = async (hash) => {
-        await this.actions.deleteBlockBoxes(hash, this.getId());
+        const result = await this.actions.deleteBlockBoxes(hash, this.getId());
+        if (result.deletedData.length > 0)
+            this.triggerCallbacks(CallbackType.Delete, result.deletedData);
+        if (result.updatedData.length > 0)
+            this.triggerCallbacks(CallbackType.Update, result.updatedData);
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractErgoExtractor.js","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { Mutex } from 'await-semaphore';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport { AbstractExtractor } from '../AbstractExtractor';\nimport { AbstractErgoExtractorAction } from './AbstractErgoExtractorAction';\nimport { BlockInfo } from '../interfaces';\nimport {\n  Transaction,\n  OutputBox,\n  AbstractBoxData,\n  SpendInfo,\n  CallbackType,\n  CallbackMap,\n  CallbackDataMap,\n} from './interfaces';\nimport { AbstractErgoExtractorEntity } from './AbstractErgoExtractorEntity';\n\nexport abstract class AbstractErgoExtractor<\n  ExtractedData extends AbstractBoxData,\n  ExtractorEntity extends AbstractErgoExtractorEntity\n> extends AbstractExtractor<Transaction> {\n  protected abstract actions: AbstractErgoExtractorAction<\n    ExtractedData,\n    ExtractorEntity\n  >;\n  protected logger: AbstractLogger;\n  protected callbacks: {\n    [K in CallbackType]: Map<string, CallbackMap<ExtractedData>[K]>;\n  } = {\n    [CallbackType.Update]: new Map(),\n    [CallbackType.Insert]: new Map(),\n    [CallbackType.Delete]: new Map(),\n    [CallbackType.Spend]: new Map(),\n  };\n  private callbackMutex = new Mutex();\n\n  constructor(logger = new DummyLogger()) {\n    super();\n    this.logger = logger;\n  }\n\n  /**\n   * hook a new callback on a callback type\n   * @param type\n   * @param id\n   * @param callback\n   * @returns callback registered id\n   */\n  hook = async <T extends CallbackType>(\n    type: T,\n    callback: CallbackMap<ExtractedData>[T]\n  ): Promise<string> => {\n    const release = await this.callbackMutex.acquire();\n    const callbackMap = this.callbacks[type];\n    const id = uuidv4();\n    callbackMap.set(id, callback);\n    release();\n    return id;\n  };\n\n  /**\n   * unhook a callback on a type\n   * returns false if there is no registered callback with the id\n   * @param type\n   * @param id\n   * @returns success status\n   */\n  unhook = async (type: CallbackType, id: string): Promise<boolean> => {\n    const release = await this.callbackMutex.acquire();\n    const callbackMap = this.callbacks[type];\n    if (!callbackMap.has(id)) {\n      this.logger.warn(\n        `Callback with Id [${id}] is not registered for type [${type}].`\n      );\n      return false;\n    }\n    callbackMap.delete(id);\n    release();\n    return true;\n  };\n\n  /**\n   * trigger all callbacks registered on a specific type with the provided data\n   * @param type\n   * @param data\n   */\n  protected triggerCallbacks<T extends CallbackType>(\n    type: T,\n    data: CallbackDataMap<ExtractedData>[T]\n  ): void {\n    const callbackMap = this.callbacks[type];\n    callbackMap.forEach((callback) => {\n      callback(data);\n    });\n  }\n\n  /**\n   * extract box data to proper format (not including spending information)\n   * @param box\n   * @return extracted data in proper format\n   */\n  abstract extractBoxData: (box: OutputBox) => ExtractedData | undefined;\n\n  /**\n   * check proper data format in the box\n   * @param box\n   * @return true if the box has the required data and false otherwise\n   */\n  abstract hasData: (box: OutputBox) => boolean;\n\n  /**\n   * process a list of transactions in a block and store required information\n   * @param txs list of transactions in the block\n   * @param block\n   * @return true if the process is completed successfully and false otherwise\n   */\n  processTransactions = async (\n    txs: Transaction[],\n    block: BlockInfo\n  ): Promise<boolean> => {\n    try {\n      const boxes: Array<ExtractedData> = [];\n      const spentInfos: Array<SpendInfo> = [];\n      for (const tx of txs) {\n        for (const output of tx.outputs) {\n          if (!this.hasData(output)) {\n            continue;\n          }\n          this.logger.debug(`Trying to extract data from box ${output.boxId}`);\n          const extractedData = this.extractBoxData(output);\n          if (extractedData) {\n            this.logger.debug(\n              `Extracted data ${JsonBigInt.stringify(extractedData)} from box ${\n                output.boxId\n              }`\n            );\n            boxes.push(extractedData);\n          }\n        }\n        let boxIndex = 1;\n        for (const input of tx.inputs) {\n          spentInfos.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });\n          boxIndex += 1;\n        }\n      }\n\n      if (boxes.length > 0) {\n        if (!(await this.actions.storeBoxes(boxes, block, this.getId()))) {\n          this.logger.warn(\n            `Data insertion failed for ${this.getId()} at the block ${\n              block.height\n            }`\n          );\n          return false;\n        }\n        this.triggerCallbacks(CallbackType.Insert, boxes);\n      }\n      const spentData = await this.actions.spendBoxes(\n        spentInfos,\n        block,\n        this.getId()\n      );\n      if (spentData.length > 0) {\n        this.triggerCallbacks(CallbackType.Spend, spentData);\n      }\n    } catch (e) {\n      this.logger.error(\n        `Processing transactions failed for ${this.getId()} at the block ${\n          block.height\n        } with error: ${e}`\n      );\n      return false;\n    }\n    return true;\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    const result = await this.actions.deleteBlockBoxes(hash, this.getId());\n    if (result.deletedData.length > 0)\n      this.triggerCallbacks(CallbackType.Delete, result.deletedData);\n    if (result.updatedData.length > 0)\n      this.triggerCallbacks(CallbackType.Update, result.updatedData);\n  };\n}\n"]}

package/dist/ergo/AbstractErgoExtractorAction.d.ts

@@ -1,27 +1,55 @@
+import { DataSource, Repository, EntityTarget } from 'typeorm';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { BlockInfo } from '../interfaces';
-import { SpendInfo } from './interfaces';
-export declare abstract class AbstractErgoExtractorAction<ExtractedData> {
+import { AbstractBoxData, BoxInfo, SpendInfo } from './interfaces';
+import { AbstractErgoExtractorEntity } from './AbstractErgoExtractorEntity';
+export declare abstract class AbstractErgoExtractorAction<ExtractedData extends AbstractBoxData, ExtractorEntity extends AbstractErgoExtractorEntity> {
+    private readonly datasource;
+    readonly logger: AbstractLogger;
+    protected readonly repository: Repository<ExtractorEntity>;
+    private repo;
+    constructor(dataSource: DataSource, repo: EntityTarget<ExtractorEntity>, logger?: AbstractLogger);
+    /**
+     * create the database entity from extracted data and block information
+     */
+    protected abstract createEntity: (data: ExtractedData[], block: BlockInfo, extractor: string) => Array<Omit<ExtractorEntity, 'id'>>;
+    /**
+     * convert the database entity back to raw data
+     */
+    protected abstract convertEntityToData: (entities: ExtractorEntity[]) => ExtractedData[];
     /**
      * insert all extracted box data in an atomic transaction
-     * @param data
-     * @param extractorId
-     * @return process success
+     * update the data if a box with the same id is already stored in db
+     * @param boxes
+     * @param block
+     * @param extractor
+     * @return inserted items and updated box ids
+     * returns undefined in case of any problem
      */
-    abstract insertBoxes: (data: ExtractedData[], extractorId: string) => Promise<boolean>;
+    storeBoxes: (boxes: Array<ExtractedData>, block: BlockInfo, extractor: string) => Promise<boolean>;
     /**
      * update spending information of stored boxes
+     * chunk spendInfos to prevent large database queries
+     * Note: It only updates the spendHeight and spendBlock fields. If updating
+     * anything else is required, override this implementation to include the
+     * additional fields.
      * @param spendInfos
      * @param block
-     * @param extractorId
+     * @param extractor
+     * @returns spent box ids
      */
-    abstract spendBoxes: (spendInfos: SpendInfo[], block: BlockInfo, extractorId: string) => Promise<void>;
+    spendBoxes: (spendInfos: Array<SpendInfo>, block: BlockInfo, extractor: string) => Promise<BoxInfo[]>;
     /**
      * delete extracted data from a specific block
      * if a box is spend in this block mark it as unspent
      * if a box is created in this block remove it from database
      * @param block
-     * @param extractorId
+     * @param extractor
+     * @return deleted items and updated box ids
      */
-    abstract deleteBlockBoxes: (block: string, extractorId: string) => Promise<void>;
+    deleteBlockBoxes: (block: string, extractor: string) => Promise<{
+        deletedData: ExtractedData[];
+        updatedData: BoxInfo[];
+    }>;
 }
 //# sourceMappingURL=AbstractErgoExtractorAction.d.ts.map

package/dist/ergo/AbstractErgoExtractorAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractErgoExtractorAction.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,8BAAsB,2BAA2B,CAAC,aAAa;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,CACpB,IAAI,EAAE,aAAa,EAAE,EACrB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,CACnB,UAAU,EAAE,SAAS,EAAE,EACvB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnB;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CACzB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB"}
+{"version":3,"file":"AbstractErgoExtractorAction.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAEV,UAAU,EAEV,YAAY,EAEb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,8BAAsB,2BAA2B,CAC/C,aAAa,SAAS,eAAe,EACrC,eAAe,SAAS,2BAA2B;IAEnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;IAC3D,OAAO,CAAC,IAAI,CAAgC;gBAG1C,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,YAAY,CAAC,eAAe,CAAC,EACnC,MAAM,CAAC,EAAE,cAAc;IAQzB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,CAC/B,IAAI,EAAE,aAAa,EAAE,EACrB,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,KACd,KAAK,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAC;IAExC;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CACtC,QAAQ,EAAE,eAAe,EAAE,KACxB,aAAa,EAAE,CAAC;IAErB;;;;;;;;OAQG;IACH,UAAU,UACD,MAAM,aAAa,CAAC,SACpB,SAAS,aACL,MAAM,KAChB,QAAQ,OAAO,CAAC,CAsDjB;IAEF;;;;;;;;;;OAUG;IACH,UAAU,eACI,MAAM,SAAS,CAAC,SACrB,SAAS,aACL,MAAM,KAChB,QAAQ,OAAO,EAAE,CAAC,CA2BnB;IAEF;;;;;;;OAOG;IACH,gBAAgB,UACP,MAAM,aACF,MAAM,KAChB,QAAQ;QAAE,WAAW,EAAE,aAAa,EAAE,CAAC;QAAC,WAAW,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CA6BlE;CACH"}

package/dist/ergo/AbstractErgoExtractorAction.js

@@ -1,3 +1,136 @@
+import { In, Not, } from 'typeorm';
+import { chunk, difference, pick } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+import { DB_CHUNK_SIZE } from '../constants';
 export class AbstractErgoExtractorAction {
+    datasource;
+    logger;
+    repository;
+    repo;
+    constructor(dataSource, repo, logger) {
+        this.datasource = dataSource;
+        this.logger = logger ? logger : new DummyLogger();
+        this.repository = this.datasource.getRepository(repo);
+        this.repo = repo;
+    }
+    /**
+     * insert all extracted box data in an atomic transaction
+     * update the data if a box with the same id is already stored in db
+     * @param boxes
+     * @param block
+     * @param extractor
+     * @return inserted items and updated box ids
+     * returns undefined in case of any problem
+     */
+    storeBoxes = async (boxes, block, extractor) => {
+        let success = true;
+        let boxesToInsert = [], boxesToUpdate = [];
+        const queryRunner = this.datasource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const repository = queryRunner.manager.getRepository(this.repo);
+            const dbBoxIds = (await repository.findBy({
+                boxId: In(boxes.map((item) => item.boxId)),
+                extractor: extractor,
+            })).map((box) => box.boxId);
+            if (dbBoxIds.length > 0)
+                this.logger.debug(`Found stored boxes with same boxId`, dbBoxIds);
+            boxesToUpdate = boxes.filter((box) => dbBoxIds.includes(box.boxId));
+            boxesToInsert = difference(boxes, boxesToUpdate);
+            if (boxesToInsert.length > 0) {
+                this.logger.debug(`Inserting boxes`);
+                await repository.insert(this.createEntity(boxesToInsert, block, extractor));
+            }
+            if (boxesToUpdate.length > 0)
+                this.logger.info(`Updating boxes with following Ids in the database: [${boxesToUpdate
+                    .map((col) => col.boxId)
+                    .join(', ')}]`);
+            for (const box of this.createEntity(boxesToUpdate, block, extractor)) {
+                this.logger.debug(`Updating boxes in database [${JsonBigInt.stringify(box)}]`);
+                await repository.update({
+                    boxId: box.boxId,
+                    extractor: extractor,
+                }, box);
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store boxes action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            success = false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+        return success;
+    };
+    /**
+     * update spending information of stored boxes
+     * chunk spendInfos to prevent large database queries
+     * Note: It only updates the spendHeight and spendBlock fields. If updating
+     * anything else is required, override this implementation to include the
+     * additional fields.
+     * @param spendInfos
+     * @param block
+     * @param extractor
+     * @returns spent box ids
+     */
+    spendBoxes = async (spendInfos, block, extractor) => {
+        const spentData = [];
+        const spendInfoChunks = chunk(spendInfos, DB_CHUNK_SIZE);
+        for (const spendInfoChunk of spendInfoChunks) {
+            const boxIds = spendInfoChunk.map((info) => info.boxId);
+            const updateResult = await this.repository.update({
+                boxId: In(boxIds),
+                extractor: extractor,
+            }, { spendBlock: block.hash, spendHeight: block.height });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const spentRows = await this.repository.findBy({
+                    boxId: In(boxIds),
+                    spendBlock: block.hash,
+                });
+                spentData.push(...spentRows);
+                for (const row of spentRows) {
+                    this.logger.debug(`Spent box with boxId [${row.boxId}] at height ${block.height}`);
+                }
+            }
+        }
+        return spentData.map((data) => pick(data, 'boxId'));
+    };
+    /**
+     * delete extracted data from a specific block
+     * if a box is spend in this block mark it as unspent
+     * if a box is created in this block remove it from database
+     * @param block
+     * @param extractor
+     * @return deleted items and updated box ids
+     */
+    deleteBlockBoxes = async (block, extractor) => {
+        this.logger.info(`Deleting boxes in block ${block} and extractor ${extractor}`);
+        const deletedData = await this.repository.find({
+            where: { extractor: extractor, block: block },
+        });
+        const updatedData = await this.repository.find({
+            where: {
+                extractor: extractor,
+                spendBlock: block,
+                block: Not(block),
+            },
+        });
+        await this.repository.delete({
+            extractor: extractor,
+            block: block,
+        });
+        await this.repository.update({
+            spendBlock: block,
+            extractor: extractor,
+        }, { spendBlock: null, spendHeight: 0 });
+        return {
+            deletedData: this.convertEntityToData(deletedData),
+            updatedData: updatedData.map((data) => pick(data, 'boxId')),
+        };
+    };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2VyZ28vQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBZ0IsMkJBQTJCO0NBbUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJsb2NrSW5mbyB9IGZyb20gJy4uL2ludGVyZmFjZXMnO1xuaW1wb3J0IHsgU3BlbmRJbmZvIH0gZnJvbSAnLi9pbnRlcmZhY2VzJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0RXJnb0V4dHJhY3RvckFjdGlvbjxFeHRyYWN0ZWREYXRhPiB7XG4gIC8qKlxuICAgKiBpbnNlcnQgYWxsIGV4dHJhY3RlZCBib3ggZGF0YSBpbiBhbiBhdG9taWMgdHJhbnNhY3Rpb25cbiAgICogQHBhcmFtIGRhdGFcbiAgICogQHBhcmFtIGV4dHJhY3RvcklkXG4gICAqIEByZXR1cm4gcHJvY2VzcyBzdWNjZXNzXG4gICAqL1xuICBhYnN0cmFjdCBpbnNlcnRCb3hlczogKFxuICAgIGRhdGE6IEV4dHJhY3RlZERhdGFbXSxcbiAgICBleHRyYWN0b3JJZDogc3RyaW5nXG4gICkgPT4gUHJvbWlzZTxib29sZWFuPjtcblxuICAvKipcbiAgICogdXBkYXRlIHNwZW5kaW5nIGluZm9ybWF0aW9uIG9mIHN0b3JlZCBib3hlc1xuICAgKiBAcGFyYW0gc3BlbmRJbmZvc1xuICAgKiBAcGFyYW0gYmxvY2tcbiAgICogQHBhcmFtIGV4dHJhY3RvcklkXG4gICAqL1xuICBhYnN0cmFjdCBzcGVuZEJveGVzOiAoXG4gICAgc3BlbmRJbmZvczogU3BlbmRJbmZvW10sXG4gICAgYmxvY2s6IEJsb2NrSW5mbyxcbiAgICBleHRyYWN0b3JJZDogc3RyaW5nXG4gICkgPT4gUHJvbWlzZTx2b2lkPjtcblxuICAvKipcbiAgICogZGVsZXRlIGV4dHJhY3RlZCBkYXRhIGZyb20gYSBzcGVjaWZpYyBibG9ja1xuICAgKiBpZiBhIGJveCBpcyBzcGVuZCBpbiB0aGlzIGJsb2NrIG1hcmsgaXQgYXMgdW5zcGVudFxuICAgKiBpZiBhIGJveCBpcyBjcmVhdGVkIGluIHRoaXMgYmxvY2sgcmVtb3ZlIGl0IGZyb20gZGF0YWJhc2VcbiAgICogQHBhcmFtIGJsb2NrXG4gICAqIEBwYXJhbSBleHRyYWN0b3JJZFxuICAgKi9cbiAgYWJzdHJhY3QgZGVsZXRlQmxvY2tCb3hlczogKFxuICAgIGJsb2NrOiBzdHJpbmcsXG4gICAgZXh0cmFjdG9ySWQ6IHN0cmluZ1xuICApID0+IFByb21pc2U8dm9pZD47XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractErgoExtractorAction.js","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DataSource,\n  In,\n  Repository,\n  Not,\n  EntityTarget,\n  FindOptionsWhere,\n} from 'typeorm';\nimport { chunk, difference, pick } from 'lodash-es';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\n\nimport { BlockInfo } from '../interfaces';\nimport { AbstractBoxData, BoxInfo, SpendInfo } from './interfaces';\nimport { DB_CHUNK_SIZE } from '../constants';\nimport { AbstractErgoExtractorEntity } from './AbstractErgoExtractorEntity';\n\nexport abstract class AbstractErgoExtractorAction<\n  ExtractedData extends AbstractBoxData,\n  ExtractorEntity extends AbstractErgoExtractorEntity\n> {\n  private readonly datasource: DataSource;\n  readonly logger: AbstractLogger;\n  protected readonly repository: Repository<ExtractorEntity>;\n  private repo: EntityTarget<ExtractorEntity>;\n\n  constructor(\n    dataSource: DataSource,\n    repo: EntityTarget<ExtractorEntity>,\n    logger?: AbstractLogger\n  ) {\n    this.datasource = dataSource;\n    this.logger = logger ? logger : new DummyLogger();\n    this.repository = this.datasource.getRepository(repo);\n    this.repo = repo;\n  }\n\n  /**\n   * create the database entity from extracted data and block information\n   */\n  protected abstract createEntity: (\n    data: ExtractedData[],\n    block: BlockInfo,\n    extractor: string\n  ) => Array<Omit<ExtractorEntity, 'id'>>;\n\n  /**\n   * convert the database entity back to raw data\n   */\n  protected abstract convertEntityToData: (\n    entities: ExtractorEntity[]\n  ) => ExtractedData[];\n\n  /**\n   * insert all extracted box data in an atomic transaction\n   * update the data if a box with the same id is already stored in db\n   * @param boxes\n   * @param block\n   * @param extractor\n   * @return inserted items and updated box ids\n   * returns undefined in case of any problem\n   */\n  storeBoxes = async (\n    boxes: Array<ExtractedData>,\n    block: BlockInfo,\n    extractor: string\n  ): Promise<boolean> => {\n    let success = true;\n    let boxesToInsert: ExtractedData[] = [],\n      boxesToUpdate: ExtractedData[] = [];\n    const queryRunner = this.datasource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    try {\n      const repository = queryRunner.manager.getRepository(this.repo);\n      const dbBoxIds = (\n        await repository.findBy({\n          boxId: In(boxes.map((item) => item.boxId)),\n          extractor: extractor,\n        } as FindOptionsWhere<ExtractorEntity>)\n      ).map((box) => box.boxId);\n      if (dbBoxIds.length > 0)\n        this.logger.debug(`Found stored boxes with same boxId`, dbBoxIds);\n\n      boxesToUpdate = boxes.filter((box) => dbBoxIds.includes(box.boxId));\n      boxesToInsert = difference(boxes, boxesToUpdate);\n\n      if (boxesToInsert.length > 0) {\n        this.logger.debug(`Inserting boxes`);\n        await repository.insert(\n          this.createEntity(boxesToInsert, block, extractor) as any\n        );\n      }\n      if (boxesToUpdate.length > 0)\n        this.logger.info(\n          `Updating boxes with following Ids in the database: [${boxesToUpdate\n            .map((col) => col.boxId)\n            .join(', ')}]`\n        );\n      for (const box of this.createEntity(boxesToUpdate, block, extractor)) {\n        this.logger.debug(\n          `Updating boxes in database [${JsonBigInt.stringify(box)}]`\n        );\n        await repository.update(\n          {\n            boxId: box.boxId,\n            extractor: extractor,\n          } as FindOptionsWhere<ExtractorEntity>,\n          box as any\n        );\n      }\n      await queryRunner.commitTransaction();\n    } catch (e) {\n      this.logger.error(`An error occurred during store boxes action: ${e}`);\n      await queryRunner.rollbackTransaction();\n      success = false;\n    } finally {\n      await queryRunner.release();\n    }\n    return success;\n  };\n\n  /**\n   * update spending information of stored boxes\n   * chunk spendInfos to prevent large database queries\n   * Note: It only updates the spendHeight and spendBlock fields. If updating\n   * anything else is required, override this implementation to include the\n   * additional fields.\n   * @param spendInfos\n   * @param block\n   * @param extractor\n   * @returns spent box ids\n   */\n  spendBoxes = async (\n    spendInfos: Array<SpendInfo>,\n    block: BlockInfo,\n    extractor: string\n  ): Promise<BoxInfo[]> => {\n    const spentData = [];\n    const spendInfoChunks = chunk(spendInfos, DB_CHUNK_SIZE);\n    for (const spendInfoChunk of spendInfoChunks) {\n      const boxIds = spendInfoChunk.map((info) => info.boxId);\n      const updateResult = await this.repository.update(\n        {\n          boxId: In(boxIds),\n          extractor: extractor,\n        } as FindOptionsWhere<ExtractorEntity>,\n        { spendBlock: block.hash, spendHeight: block.height } as any\n      );\n\n      if (updateResult.affected && updateResult.affected > 0) {\n        const spentRows = await this.repository.findBy({\n          boxId: In(boxIds),\n          spendBlock: block.hash,\n        } as FindOptionsWhere<ExtractorEntity>);\n        spentData.push(...spentRows);\n        for (const row of spentRows) {\n          this.logger.debug(\n            `Spent box with boxId [${row.boxId}] at height ${block.height}`\n          );\n        }\n      }\n    }\n    return spentData.map((data) => pick(data, 'boxId'));\n  };\n\n  /**\n   * delete extracted data from a specific block\n   * if a box is spend in this block mark it as unspent\n   * if a box is created in this block remove it from database\n   * @param block\n   * @param extractor\n   * @return deleted items and updated box ids\n   */\n  deleteBlockBoxes = async (\n    block: string,\n    extractor: string\n  ): Promise<{ deletedData: ExtractedData[]; updatedData: BoxInfo[] }> => {\n    this.logger.info(\n      `Deleting boxes in block ${block} and extractor ${extractor}`\n    );\n    const deletedData = await this.repository.find({\n      where: { extractor: extractor, block: block } as any,\n    });\n    const updatedData = await this.repository.find({\n      where: {\n        extractor: extractor,\n        spendBlock: block,\n        block: Not(block),\n      } as any,\n    });\n    await this.repository.delete({\n      extractor: extractor,\n      block: block,\n    } as any);\n    await this.repository.update(\n      {\n        spendBlock: block,\n        extractor: extractor,\n      } as FindOptionsWhere<ExtractorEntity>,\n      { spendBlock: null, spendHeight: 0 } as any\n    );\n    return {\n      deletedData: this.convertEntityToData(deletedData),\n      updatedData: updatedData.map((data) => pick(data, 'boxId')),\n    };\n  };\n}\n"]}

package/dist/ergo/AbstractErgoExtractorEntity.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class AbstractErgoExtractorEntity {
+    id: number;
+    boxId: string;
+    block: string;
+    height: number;
+    spendBlock?: string | null;
+    spendHeight?: number | null;
+    extractor: string;
+    serialized: string;
+}
+//# sourceMappingURL=AbstractErgoExtractorEntity.d.ts.map

package/dist/ergo/AbstractErgoExtractorEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractErgoExtractorEntity.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractorEntity.ts"],"names":[],"mappings":"AAEA,8BACsB,2BAA2B;IAE/C,EAAE,EAAE,MAAM,CAAC;IAGX,KAAK,EAAE,MAAM,CAAC;IAGd,KAAK,EAAE,MAAM,CAAC;IAGd,MAAM,EAAE,MAAM,CAAC;IAGf,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG5B,SAAS,EAAE,MAAM,CAAC;IAGlB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/ergo/AbstractErgoExtractorEntity.js

@@ -0,0 +1,57 @@
+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, PrimaryGeneratedColumn, Unique } from 'typeorm';
+let AbstractErgoExtractorEntity = class AbstractErgoExtractorEntity {
+    id;
+    boxId;
+    block;
+    height;
+    spendBlock;
+    spendHeight;
+    extractor;
+    serialized;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], AbstractErgoExtractorEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "boxId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "block", void 0);
+__decorate([
+    Column({ type: 'int' }),
+    __metadata("design:type", Number)
+], AbstractErgoExtractorEntity.prototype, "height", void 0);
+__decorate([
+    Column({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], AbstractErgoExtractorEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true, type: 'int' }),
+    __metadata("design:type", Object)
+], AbstractErgoExtractorEntity.prototype, "spendHeight", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "extractor", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoExtractorEntity.prototype, "serialized", void 0);
+AbstractErgoExtractorEntity = __decorate([
+    Unique(['boxId', 'extractor'])
+], AbstractErgoExtractorEntity);
+export { AbstractErgoExtractorEntity };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ergo/index.d.ts

@@ -6,4 +6,5 @@ export * from './network/NodeNetwork';
 export * from './network/AbstractNetwork';
 export * from './initializable';
 export * from './utils';
+export * from './AbstractErgoExtractorEntity';
 //# sourceMappingURL=index.d.ts.map

package/dist/ergo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/ergo/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/ergo/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,+BAA+B,CAAC"}

package/dist/ergo/index.js

@@ -6,4 +6,5 @@ export * from './network/NodeNetwork';
 export * from './network/AbstractNetwork';
 export * from './initializable';
 export * from './utils';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vQWJzdHJhY3RFcmdvRXh0cmFjdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL25ldHdvcmsvRXhwbG9yZXJOZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9Ob2RlTmV0d29yayc7XG5leHBvcnQgKiBmcm9tICcuL25ldHdvcmsvQWJzdHJhY3ROZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vaW5pdGlhbGl6YWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbiJdfQ==
+export * from './AbstractErgoExtractorEntity';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3JBY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9FeHBsb3Jlck5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrL05vZGVOZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9BYnN0cmFjdE5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9pbml0aWFsaXphYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3JFbnRpdHknO1xuIl19

package/dist/ergo/initializable/AbstractInitializable.d.ts

@@ -1,12 +1,13 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { ErgoExtractedData, ErgoNetworkType } from '../interfaces';
+import { AbstractBoxData, ErgoNetworkType } from '../interfaces';
 import { AbstractErgoExtractor } from '../AbstractErgoExtractor';
 import { AbstractInitializableErgoExtractorAction } from './AbstractInitializableAction';
 import { BlockInfo } from '../../interfaces';
-export declare abstract class AbstractInitializableErgoExtractor<ExtractedData extends ErgoExtractedData> extends AbstractErgoExtractor<ExtractedData> {
+import { AbstractErgoExtractorEntity } from '../AbstractErgoExtractorEntity';
+export declare abstract class AbstractInitializableErgoExtractor<ExtractedData extends AbstractBoxData, ExtractorEntity extends AbstractErgoExtractorEntity> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {
     protected initialize: boolean;
     private address;
-    protected abstract actions: AbstractInitializableErgoExtractorAction<ExtractedData>;
+    protected abstract actions: AbstractInitializableErgoExtractorAction<ExtractedData, ExtractorEntity>;
     private network;
     constructor(type: ErgoNetworkType, url: string, address: string, logger?: AbstractLogger, initialize?: boolean);
     /**

package/dist/ergo/initializable/AbstractInitializable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractInitializable.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,iBAAiB,EACjB,eAAe,EAEhB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C,8BAAsB,kCAAkC,CACtD,aAAa,SAAS,iBAAiB,CACvC,SAAQ,qBAAqB,CAAC,aAAa,CAAC;IAC5C,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wCAAwC,CAAC,aAAa,CAAC,CAAC;IAEpF,OAAO,CAAC,OAAO,CAAgC;gBAG7C,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,UAAO;IAkBnB;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CA6C5B;IAEF;;;OAGG;IACH,OAAO,CAAC,eAAe,CAKrB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAoCxB;IAEF;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CAgB7B;IAEF;;;;OAIG;IACH,OAAO,CAAC,eAAe,CA+BrB;IAEF;;;;;OAKG;IACH,eAAe,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D"}
+{"version":3,"file":"AbstractInitializable.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,eAAe,EACf,eAAe,EAEhB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAE7E,8BAAsB,kCAAkC,CACtD,aAAa,SAAS,eAAe,EACrC,eAAe,SAAS,2BAA2B,CACnD,SAAQ,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;IAC7D,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wCAAwC,CAClE,aAAa,EACb,eAAe,CAChB,CAAC;IAEF,OAAO,CAAC,OAAO,CAAgC;gBAG7C,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,UAAO;IAkBnB;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CA6C5B;IAEF;;;OAGG;IACH,OAAO,CAAC,eAAe,CAKrB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAuCxB;IAEF;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CAoB7B;IAEF;;;;OAIG;IACH,OAAO,CAAC,eAAe,CA+BrB;IAEF;;;;;OAKG;IACH,eAAe,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D"}