@rosen-bridge/abstract-extractor 2.0.1 → 2.0.3-52fc0239

package/dist/lib/ergo/AbstractErgoExtractor.js

@@ -0,0 +1,143 @@
+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 {
+    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);
+        });
+    }
+    /**
+     * create spend info array for the transaction
+     * @param tx
+     * @returns spend info array of the transaction
+     */
+    getTransactionSpendInfo = (tx) => {
+        let boxIndex = 1;
+        const spendInfoArray = [];
+        for (const input of tx.inputs) {
+            spendInfoArray.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });
+            boxIndex += 1;
+        }
+        return spendInfoArray;
+    };
+    /**
+     * extract transaction extra information
+     * override this function if there is extra needed information
+     * @param tx
+     * @returns
+     */
+    getTransactionExtraData = (tx // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => {
+        return {};
+    };
+    /**
+     * process a list of transactions in a block and store required information
+     * @param txs list of transactions in the block
+     * @param block
+     * @return true if the process is completed successfully and false otherwise
+     */
+    processTransactions = async (txs, block) => {
+        try {
+            const boxes = [];
+            const spentInfos = [];
+            for (const tx of txs) {
+                const inputExtensions = tx.inputs.map((input) => input.extension || {});
+                for (const output of tx.outputs) {
+                    if (!this.hasData(output)) {
+                        continue;
+                    }
+                    this.logger.debug(`Trying to extract data from box ${output.boxId}`);
+                    const extractedData = this.extractBoxData(output, inputExtensions, this.getTransactionExtraData(tx));
+                    if (extractedData) {
+                        this.logger.debug(`Extracted data ${JsonBigInt.stringify(extractedData)} from box ${output.boxId}`);
+                        boxes.push(extractedData);
+                    }
+                }
+                spentInfos.push(...this.getTransactionSpendInfo(tx));
+            }
+            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(`Processing transactions failed for ${this.getId()} at the block ${block.height} with error: ${e}`);
+            return false;
+        }
+        return true;
+    };
+    /**
+     * fork one block and remove all stored information for this block
+     * @param hash block hash
+     */
+    forkBlock = async (hash) => {
+        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,{"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';\nimport {\n  Transaction,\n  OutputBox,\n  InputExtension,\n  BlockInfo,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractExtractor } from '../abstractExtractor';\nimport { AbstractErgoExtractorAction } from './AbstractErgoExtractorAction';\nimport {\n  AbstractBoxData,\n  SpendInfo,\n  CallbackType,\n  CallbackMap,\n  CallbackDataMap,\n  TxExtra,\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   * @param inputExtensions all input box extensions in transaction\n   * @return extracted data in proper format\n   */\n  abstract extractBoxData: (\n    box: OutputBox,\n    inputExtensions: InputExtension[],\n    txExtra?: TxExtra\n  ) => 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   * create spend info array for the transaction\n   * @param tx\n   * @returns spend info array of the transaction\n   */\n  getTransactionSpendInfo = (tx: Transaction) => {\n    let boxIndex = 1;\n    const spendInfoArray = [];\n    for (const input of tx.inputs) {\n      spendInfoArray.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });\n      boxIndex += 1;\n    }\n    return spendInfoArray;\n  };\n\n  /**\n   * extract transaction extra information\n   * override this function if there is extra needed information\n   * @param tx\n   * @returns\n   */\n  getTransactionExtraData = (\n    tx: Transaction // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): TxExtra => {\n    return {};\n  };\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        const inputExtensions = tx.inputs.map((input) => input.extension || {});\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(\n            output,\n            inputExtensions,\n            this.getTransactionExtraData(tx)\n          );\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        spentInfos.push(...this.getTransactionSpendInfo(tx));\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/lib/ergo/AbstractErgoExtractorAction.d.ts

@@ -0,0 +1,87 @@
+import { DataSource, Repository, EntityTarget, QueryRunner } from '@rosen-bridge/extended-typeorm';
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+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 createEntity: (data: ExtractedData[], block: BlockInfo, extractor: string) => Array<Omit<ExtractorEntity, 'id'>>;
+    /**
+     * convert the database entity back to raw data
+     */
+    protected convertEntityToData: (entities: ExtractorEntity[]) => ExtractedData[];
+    /**
+     * insert entities extracted from a block to database
+     * @param queryRunner
+     * @param boxesToInsert
+     * @param block
+     * @param extractor
+     */
+    protected insertEntities: (queryRunner: QueryRunner, boxesToInsert: Array<ExtractedData>, block: BlockInfo, extractor: string) => Promise<void>;
+    /**
+     * update entities related to a box
+     * @param queryRunner
+     * @param updateBox
+     * @param block
+     * @param extractor
+     */
+    protected updateEntity: (queryRunner: QueryRunner, updateBox: ExtractedData, block: BlockInfo, extractor: string) => Promise<void>;
+    /**
+     * delete all data extracted from a block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    protected deleteBlockEntities: (queryRunner: QueryRunner, extractor: string, block: string) => Promise<ExtractedData[]>;
+    /**
+     * delete all data extracted from a block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    protected updateBlockEntities: (queryRunner: QueryRunner, extractor: string, block: string) => Promise<ExtractorEntity[]>;
+    /**
+     * 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: (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 extractor
+     * @returns spent box ids
+     */
+    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 extractor
+     * @return deleted items and updated box ids
+     */
+    deleteBlockBoxes: (block: string, extractor: string) => Promise<{
+        deletedData: ExtractedData[];
+        updatedData: BoxInfo[];
+    }>;
+}
+//# sourceMappingURL=AbstractErgoExtractorAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractErgoExtractorAction.d.ts","sourceRoot":"","sources":["../../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAEV,UAAU,EAEV,YAAY,EAEZ,WAAW,EACZ,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAE5E,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,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,YAAY,SACd,aAAa,EAAE,SACd,SAAS,aACL,MAAM,KAChB,MAAM,KAAK,eAAe,EAAE,IAAI,CAAC,CAAC,CAInC;IAEF;;OAEG;IACH,SAAS,CAAC,mBAAmB,aACjB,eAAe,EAAE,KAC1B,aAAa,EAAE,CAIhB;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,gBACT,WAAW,iBACT,MAAM,aAAa,CAAC,SAC5B,SAAS,aACL,MAAM,mBAMjB;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,gBACP,WAAW,aACb,aAAa,SACjB,SAAS,aACL,MAAM,mBAWjB;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,gBACd,WAAW,aACb,MAAM,SACV,MAAM,KACZ,QAAQ,aAAa,EAAE,CAAC,CAazB;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,gBACd,WAAW,aACb,MAAM,SACV,MAAM,KACZ,QAAQ,eAAe,EAAE,CAAC,CAsB3B;IAEF;;;;;;;;OAQG;IACH,UAAU,UACD,MAAM,aAAa,CAAC,SACpB,SAAS,aACL,MAAM,KAChB,QAAQ,OAAO,CAAC,CA6CjB;IAEF;;;;;;;;;;OAUG;IACH,UAAU,eACI,MAAM,SAAS,CAAC,SACrB,SAAS,aACL,MAAM,KAChB,QAAQ,OAAO,EAAE,CAAC,CA8BnB;IAEF;;;;;;;OAOG;IACH,gBAAgB,UACP,MAAM,aACF,MAAM,KAChB,QAAQ;QAAE,WAAW,EAAE,aAAa,EAAE,CAAC;QAAC,WAAW,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CAiClE;CACH"}

package/dist/lib/ergo/AbstractErgoExtractorAction.js

@@ -0,0 +1,222 @@
+import { In, Not, } from '@rosen-bridge/extended-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;
+    }
+    /**
+     * create the database entity from extracted data and block information
+     */
+    createEntity = (data, // eslint-disable-line @typescript-eslint/no-unused-vars
+    block, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor) => {
+        throw Error('You must implement `createEntity` or override `insertEntities` and `updateEntities`');
+    };
+    /**
+     * convert the database entity back to raw data
+     */
+    convertEntityToData = (entities) => {
+        throw Error('You must implement `convertEntityToData` or override `deleteBlockEntities`');
+    };
+    /**
+     * insert entities extracted from a block to database
+     * @param queryRunner
+     * @param boxesToInsert
+     * @param block
+     * @param extractor
+     */
+    insertEntities = async (queryRunner, boxesToInsert, block, extractor) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        await repository.insert(this.createEntity(boxesToInsert, block, extractor));
+    };
+    /**
+     * update entities related to a box
+     * @param queryRunner
+     * @param updateBox
+     * @param block
+     * @param extractor
+     */
+    updateEntity = async (queryRunner, updateBox, // eslint-disable-line @typescript-eslint/no-unused-vars
+    block, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        const box = this.createEntity([updateBox], block, extractor)[0];
+        await repository.update({
+            boxId: box.boxId,
+            extractor: extractor,
+        }, box);
+    };
+    /**
+     * delete all data extracted from a block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    deleteBlockEntities = async (queryRunner, extractor, block) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        const deletedData = await repository.find({
+            where: {
+                extractor: extractor,
+                block: block,
+            },
+        });
+        await repository.delete({
+            extractor: extractor,
+            block: block,
+        });
+        return this.convertEntityToData(deletedData);
+    };
+    /**
+     * delete all data extracted from a block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    updateBlockEntities = async (queryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor, block) => {
+        const repository = this.datasource.getRepository(this.repo);
+        const updatedData = await repository.find({
+            where: {
+                extractor: extractor,
+                spendBlock: block,
+                block: Not(block),
+            },
+        });
+        await repository.update({
+            spendBlock: block,
+            extractor: extractor,
+        }, {
+            spendBlock: null,
+            spendHeight: 0,
+        });
+        return updatedData;
+    };
+    /**
+     * 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 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 this.insertEntities(queryRunner, 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 boxesToUpdate) {
+                this.logger.debug(`Updating boxes in database [${JsonBigInt.stringify(box)}]`);
+                await this.updateEntity(queryRunner, box, block, extractor);
+            }
+            await queryRunner.commitTransaction();
+            return true;
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store boxes action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            return false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    };
+    /**
+     * 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) => {
+        const queryRunner = this.datasource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            this.logger.info(`Deleting boxes in block ${block} and extractor ${extractor}`);
+            const updatedData = await this.updateBlockEntities(queryRunner, extractor, block);
+            const deletedData = await this.deleteBlockEntities(queryRunner, extractor, block);
+            await queryRunner.commitTransaction();
+            return {
+                deletedData,
+                updatedData: updatedData.map((data) => pick(data, 'boxId')),
+            };
+        }
+        catch (error) {
+            await queryRunner.rollbackTransaction();
+            this.logger.error(`An error occurred while deleting data extracted from block ${block}`, error);
+            throw error;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    };
+}
+//# 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  QueryRunner,\n} from '@rosen-bridge/extended-typeorm';\nimport { chunk, difference, pick } from 'lodash-es';\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\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 createEntity = (\n    data: ExtractedData[], // eslint-disable-line @typescript-eslint/no-unused-vars\n    block: BlockInfo, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string, // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): Array<Omit<ExtractorEntity, 'id'>> => {\n    throw Error(\n      'You must implement `createEntity` or override `insertEntities` and `updateEntities`',\n    );\n  };\n\n  /**\n   * convert the database entity back to raw data\n   */\n  protected convertEntityToData = (\n    entities: ExtractorEntity[], // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): ExtractedData[] => {\n    throw Error(\n      'You must implement `convertEntityToData` or override `deleteBlockEntities`',\n    );\n  };\n\n  /**\n   * insert entities extracted from a block to database\n   * @param queryRunner\n   * @param boxesToInsert\n   * @param block\n   * @param extractor\n   */\n  protected insertEntities = async (\n    queryRunner: QueryRunner,\n    boxesToInsert: Array<ExtractedData>,\n    block: BlockInfo,\n    extractor: string,\n  ) => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    await repository.insert(\n      this.createEntity(boxesToInsert, block, extractor) as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    );\n  };\n\n  /**\n   * update entities related to a box\n   * @param queryRunner\n   * @param updateBox\n   * @param block\n   * @param extractor\n   */\n  protected updateEntity = async (\n    queryRunner: QueryRunner,\n    updateBox: ExtractedData, // eslint-disable-line @typescript-eslint/no-unused-vars\n    block: BlockInfo, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string,\n  ) => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    const box = this.createEntity([updateBox], block, extractor)[0];\n    await repository.update(\n      {\n        boxId: box.boxId,\n        extractor: extractor,\n      } as FindOptionsWhere<ExtractorEntity>,\n      box as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    );\n  };\n\n  /**\n   * delete all data extracted from a block\n   * @param queryRunner\n   * @param extractor\n   * @param block\n   * @returns\n   */\n  protected deleteBlockEntities = async (\n    queryRunner: QueryRunner,\n    extractor: string,\n    block: string,\n  ): Promise<ExtractedData[]> => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    const deletedData = await repository.find({\n      where: {\n        extractor: extractor,\n        block: block,\n      } as FindOptionsWhere<ExtractorEntity>,\n    });\n    await repository.delete({\n      extractor: extractor,\n      block: block,\n    } as unknown as FindOptionsWhere<ExtractorEntity>);\n    return this.convertEntityToData(deletedData);\n  };\n\n  /**\n   * delete all data extracted from a block\n   * @param queryRunner\n   * @param extractor\n   * @param block\n   * @returns\n   */\n  protected updateBlockEntities = async (\n    queryRunner: QueryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string,\n    block: string,\n  ): Promise<ExtractorEntity[]> => {\n    const repository = this.datasource.getRepository(\n      this.repo as EntityTarget<new () => ExtractorEntity>,\n    );\n    const updatedData = await repository.find({\n      where: {\n        extractor: extractor,\n        spendBlock: block,\n        block: Not(block),\n      } as unknown as FindOptionsWhere<ExtractorEntity>,\n    });\n    await repository.update(\n      {\n        spendBlock: block,\n        extractor: extractor,\n      } as unknown as FindOptionsWhere<ExtractorEntity>,\n      {\n        spendBlock: null,\n        spendHeight: 0,\n      },\n    );\n    return updatedData as unknown as ExtractorEntity[];\n  };\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 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 this.insertEntities(queryRunner, boxesToInsert, block, extractor);\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 boxesToUpdate) {\n        this.logger.debug(\n          `Updating boxes in database [${JsonBigInt.stringify(box)}]`,\n        );\n        await this.updateEntity(queryRunner, box, block, extractor);\n      }\n      await queryRunner.commitTransaction();\n      return true;\n    } catch (e) {\n      this.logger.error(`An error occurred during store boxes action: ${e}`);\n      await queryRunner.rollbackTransaction();\n      return false;\n    } finally {\n      await queryRunner.release();\n    }\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        {\n          spendBlock: block.hash,\n          spendHeight: block.height,\n        } as any, // eslint-disable-line @typescript-eslint/no-explicit-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    const queryRunner = this.datasource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    try {\n      this.logger.info(\n        `Deleting boxes in block ${block} and extractor ${extractor}`,\n      );\n      const updatedData = await this.updateBlockEntities(\n        queryRunner,\n        extractor,\n        block,\n      );\n      const deletedData = await this.deleteBlockEntities(\n        queryRunner,\n        extractor,\n        block,\n      );\n      await queryRunner.commitTransaction();\n      return {\n        deletedData,\n        updatedData: updatedData.map((data) => pick(data, 'boxId')),\n      };\n    } catch (error) {\n      await queryRunner.rollbackTransaction();\n      this.logger.error(\n        `An error occurred while deleting data extracted from block ${block}`,\n        error,\n      );\n      throw error;\n    } finally {\n      await queryRunner.release();\n    }\n  };\n}\n"]}

package/dist/lib/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/lib/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/lib/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 '@rosen-bridge/extended-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/lib/ergo/index.d.ts

@@ -0,0 +1,10 @@
+export * from './AbstractErgoExtractor';
+export * from './AbstractErgoExtractorAction';
+export * from './interfaces';
+export * from './network/ExplorerNetwork';
+export * from './network/NodeNetwork';
+export * from './network/AbstractNetwork';
+export * from './initializable';
+export * from './utils';
+export * from './AbstractErgoExtractorEntity';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;AACxB,cAAc,+BAA+B,CAAC"}

package/dist/lib/ergo/index.js

@@ -0,0 +1,10 @@
+export * from './AbstractErgoExtractor';
+export * from './AbstractErgoExtractorAction';
+export * from './interfaces';
+export * from './network/ExplorerNetwork';
+export * from './network/NodeNetwork';
+export * from './network/AbstractNetwork';
+export * from './initializable';
+export * from './utils';
+export * from './AbstractErgoExtractorEntity';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3JBY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9FeHBsb3Jlck5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrL05vZGVOZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9BYnN0cmFjdE5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9pbml0aWFsaXphYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdEVyZ29FeHRyYWN0b3JFbnRpdHknO1xuIl19