@my-packages-changeit/abstract-extractor 3.2.3

package/dist/ergo/database/actions/abstractErgoAction.js

@@ -0,0 +1,180 @@
+import { difference, pick } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { In, } from '@rosen-bridge/extended-typeorm';
+import JsonBigInt from '@rosen-bridge/json-bigint';
+export class AbstractErgoAction {
+    dataSource;
+    repo;
+    logger;
+    repository;
+    constructor(dataSource, repo, logger = new DummyLogger()) {
+        this.dataSource = dataSource;
+        this.repo = repo;
+        this.logger = logger;
+        this.repository = this.dataSource.getRepository(repo);
+    }
+    /**
+     * insert entities extracted from a block to database
+     * @param queryRunner
+     * @param entitiesToInsert
+     * @param block
+     * @param extractor
+     */
+    insertEntities = async (queryRunner, entitiesToInsert, block, extractor) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        await repository.insert(this.createEntity(entitiesToInsert, block, extractor));
+    };
+    /**
+     * update an entity in the database
+     * @param queryRunner
+     * @param updateEntity
+     * @param block
+     * @param extractor
+     */
+    updateEntity = async (queryRunner, updatedEntity, block, extractor) => {
+        const repository = queryRunner.manager.getRepository(this.repo);
+        const entity = this.createEntity([updatedEntity], block, extractor)[0];
+        await repository.update({
+            identifier: entity.identifier,
+            extractor: extractor,
+        }, entity);
+    };
+    /**
+     * delete all database records that were created from a specific block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    deleteBlockRecords = 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);
+    };
+    /**
+     * override this method to revert the updates made to entities when a block is deleted
+     * e.g., mark boxes as unspent, update related entities, etc.
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    revertBlockUpdates = async (queryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor, // eslint-disable-line @typescript-eslint/no-unused-vars
+    block) => {
+        return [];
+    };
+    /**
+     * delete extracted data from a specific block
+     * if an entity is updated using the data in this block revert the update
+     * if an entity is created in this block remove it from database
+     * @param block
+     * @param extractor
+     * @return deleted items and updated entity identifiers
+     */
+    deleteBlockData = async (block, extractor) => {
+        this.logger.info(`Deleting data in block ${block} and extractor ${extractor}`);
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const updatedData = await this.revertBlockUpdates(queryRunner, extractor, block);
+            const deletedData = await this.deleteBlockRecords(queryRunner, extractor, block);
+            await queryRunner.commitTransaction();
+            this.logger.debug(`Deleted data successfully in block ${block} and extractor ${extractor}`);
+            return {
+                deletedData,
+                updatedData: updatedData.map((data) => pick(data, 'identifier')),
+            };
+        }
+        catch (error) {
+            await queryRunner.rollbackTransaction();
+            throw error;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    };
+    /**
+     * insert all extracted entity data in an atomic transaction
+     * update the data if a entity with the same id is already stored in db
+     * @param entities
+     * @param block
+     * @param extractor
+     * @return inserted items and updated entity identifiers
+     * returns undefined in case of any problem
+     */
+    storeEntities = async (entities, block, extractor) => {
+        this.logger.debug(`Storing entities in block ${block.hash} and ${extractor} extractor`);
+        let entitiesToInsert = [], entitiesToUpdate = [];
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const repository = queryRunner.manager.getRepository(this.repo);
+            const dbEntityIdentifiers = (await repository.findBy({
+                identifier: In(entities.map((item) => item.identifier)),
+                extractor: extractor,
+            })).map((entity) => entity.identifier);
+            if (dbEntityIdentifiers.length > 0)
+                this.logger.debug(`Found stored entities with same identifier`, dbEntityIdentifiers);
+            entitiesToUpdate = entities.filter((entity) => dbEntityIdentifiers.includes(entity.identifier));
+            entitiesToInsert = difference(entities, entitiesToUpdate);
+            if (entitiesToInsert.length > 0) {
+                this.logger.debug(`Inserting ${entitiesToInsert.length} new entities to database`);
+                await this.insertEntities(queryRunner, entitiesToInsert, block, extractor);
+            }
+            if (entitiesToUpdate.length > 0)
+                this.logger.info(`Updating entities with following Ids in the database: [${entitiesToUpdate
+                    .map((entity) => entity.identifier)
+                    .join(', ')}]`);
+            for (const entity of entitiesToUpdate) {
+                this.logger.debug(`Updating entities in database [${JsonBigInt.stringify(entity)}]`);
+                await this.updateEntity(queryRunner, entity, block, extractor);
+            }
+            await queryRunner.commitTransaction();
+            return true;
+        }
+        catch (e) {
+            this.logger.error(`An error occurred during store entities action: ${e}`);
+            await queryRunner.rollbackTransaction();
+            return false;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    };
+    /**
+     * remove all existing data for the extractor
+     * @param extractorId
+     */
+    removeAllData = async (extractorId) => {
+        this.logger.debug(`Removing all old data for extractor ${extractorId}`);
+        await this.repository.delete({
+            extractor: extractorId,
+        });
+    };
+    /**
+     * Builds a query that returns used blocks by selecting the `block` column from the `ExtractorEntity` repository,
+     * filtered by the provided `extractorId`
+     *
+     * @param extractorId - Identifier of the extractor
+     * @returns A query builder selecting used blocks
+     */
+    createUsedBlocksQuery = (extractorId) => {
+        return this.repository
+            .createQueryBuilder('extractorEntity')
+            .select('extractorEntity.block', 'block')
+            .where('extractorEntity.extractor = :extractorId', { extractorId });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractErgoAction.js","sourceRoot":"","sources":["../../../../lib/ergo/database/actions/abstractErgoAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,EAAkB,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAIL,EAAE,GAIH,MAAM,gCAAgC,CAAC;AACxC,OAAO,UAAU,MAAM,2BAA2B,CAAC;AAMnD,MAAM,OAAgB,kBAAkB;IAOjB;IACA;IACA;IALF,UAAU,CAA8B;IAE3D,YACqB,UAAsB,EACtB,IAAmC,EACnC,SAAyB,IAAI,WAAW,EAAE;QAF1C,eAAU,GAAV,UAAU,CAAY;QACtB,SAAI,GAAJ,IAAI,CAA+B;QACnC,WAAM,GAAN,MAAM,CAAoC;QAE7D,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACxD,CAAC;IAkBD;;;;;;OAMG;IACO,cAAc,GAAG,KAAK,EAC9B,WAAwB,EACxB,gBAAsC,EACtC,KAAgB,EAChB,SAAiB,EACjB,EAAE;QACF,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChE,MAAM,UAAU,CAAC,MAAM,CACrB,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,KAAK,EAAE,SAAS,CAAQ,CAC7D,CAAC;IACJ,CAAC,CAAC;IAEF;;;;;;OAMG;IACO,YAAY,GAAG,KAAK,EAC5B,WAAwB,EACxB,aAA4B,EAC5B,KAAgB,EAChB,SAAiB,EACjB,EAAE;QACF,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChE,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QACvE,MAAM,UAAU,CAAC,MAAM,CACrB;YACE,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,SAAS,EAAE,SAAS;SACgB,EACtC,MAAa,CACd,CAAC;IACJ,CAAC,CAAC;IAEF;;;;;;OAMG;IACO,kBAAkB,GAAG,KAAK,EAClC,WAAwB,EACxB,SAAiB,EACjB,KAAa,EACa,EAAE;QAC5B,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChE,MAAM,WAAW,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC;YACxC,KAAK,EAAE;gBACL,SAAS,EAAE,SAAS;gBACpB,KAAK,EAAE,KAAK;aACwB;SACvC,CAAC,CAAC;QACH,MAAM,UAAU,CAAC,MAAM,CAAC;YACtB,SAAS,EAAE,SAAS;YACpB,KAAK,EAAE,KAAK;SACmC,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC,CAAC;IAEF;;;;;;;OAOG;IACO,kBAAkB,GAAG,KAAK,EAClC,WAAwB,EAAE,wDAAwD;IAClF,SAAiB,EAAE,wDAAwD;IAC3E,KAAa,EACe,EAAE;QAC9B,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IAEF;;;;;;;OAOG;IACH,eAAe,GAAG,KAAK,EACrB,KAAa,EACb,SAAiB,EACqD,EAAE;QACxE,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,0BAA0B,KAAK,kBAAkB,SAAS,EAAE,CAC7D,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QACrC,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAC/C,WAAW,EACX,SAAS,EACT,KAAK,CACN,CAAC;YACF,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAC/C,WAAW,EACX,SAAS,EACT,KAAK,CACN,CAAC;YACF,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;YACtC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,sCAAsC,KAAK,kBAAkB,SAAS,EAAE,CACzE,CAAC;YACF,OAAO;gBACL,WAAW;gBACX,WAAW,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;aACjE,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC,CAAC;IAEF;;;;;;;;OAQG;IACH,aAAa,GAAG,KAAK,EACnB,QAA8B,EAC9B,KAAgB,EAChB,SAAiB,EACC,EAAE;QACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,6BAA6B,KAAK,CAAC,IAAI,QAAQ,SAAS,YAAY,CACrE,CAAC;QACF,IAAI,gBAAgB,GAAoB,EAAE,EACxC,gBAAgB,GAAoB,EAAE,CAAC;QACzC,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACxD,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,WAAW,CAAC,gBAAgB,EAAE,CAAC;QACrC,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChE,MAAM,mBAAmB,GAAG,CAC1B,MAAM,UAAU,CAAC,MAAM,CAAC;gBACtB,UAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBACvD,SAAS,EAAE,SAAS;aACgB,CAAC,CACxC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YACrC,IAAI,mBAAmB,CAAC,MAAM,GAAG,CAAC;gBAChC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,4CAA4C,EAC5C,mBAAmB,CACpB,CAAC;YAEJ,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5C,mBAAmB,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,CAChD,CAAC;YACF,gBAAgB,GAAG,UAAU,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;YAE1D,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,aAAa,gBAAgB,CAAC,MAAM,2BAA2B,CAChE,CAAC;gBACF,MAAM,IAAI,CAAC,cAAc,CACvB,WAAW,EACX,gBAAgB,EAChB,KAAK,EACL,SAAS,CACV,CAAC;YACJ,CAAC;YACD,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC;gBAC7B,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,0DAA0D,gBAAgB;qBACvE,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC;qBAClC,IAAI,CAAC,IAAI,CAAC,GAAG,CACjB,CAAC;YACJ,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;gBACtC,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,kCAAkC,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAClE,CAAC;gBACF,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;YACjE,CAAC;YACD,MAAM,WAAW,CAAC,iBAAiB,EAAE,CAAC;YACtC,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mDAAmD,CAAC,EAAE,CAAC,CAAC;YAC1E,MAAM,WAAW,CAAC,mBAAmB,EAAE,CAAC;YACxC,OAAO,KAAK,CAAC;QACf,CAAC;gBAAS,CAAC;YACT,MAAM,WAAW,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC,CAAC;IAEF;;;OAGG;IACH,aAAa,GAAG,KAAK,EAAE,WAAmB,EAAE,EAAE;QAC5C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,uCAAuC,WAAW,EAAE,CAAC,CAAC;QACxE,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;YAC3B,SAAS,EAAE,WAAW;SACc,CAAC,CAAC;IAC1C,CAAC,CAAC;IAEF;;;;;;OAMG;IACH,qBAAqB,GAAG,CACtB,WAAmB,EACkB,EAAE;QACvC,OAAO,IAAI,CAAC,UAAU;aACnB,kBAAkB,CAAC,iBAAiB,CAAC;aACrC,MAAM,CAAC,uBAAuB,EAAE,OAAO,CAAC;aACxC,KAAK,CAAC,0CAA0C,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;IACxE,CAAC,CAAC;CACH","sourcesContent":["import { difference, pick } from 'lodash-es';\n\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  DataSource,\n  EntityTarget,\n  FindOptionsWhere,\n  In,\n  QueryRunner,\n  Repository,\n  SelectQueryBuilder,\n} from '@rosen-bridge/extended-typeorm';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractEntityData, EntityInfo } from '../../interfaces';\nimport { AbstractErgoEntity } from '../entities/abstractErgoEntity';\n\nexport abstract class AbstractErgoAction<\n  ExtractedData extends AbstractEntityData,\n  ExtractorEntity extends AbstractErgoEntity,\n> {\n  protected readonly repository: Repository<ExtractorEntity>;\n\n  constructor(\n    protected readonly dataSource: DataSource,\n    protected readonly repo: EntityTarget<ExtractorEntity>,\n    protected readonly logger: AbstractLogger = new DummyLogger(),\n  ) {\n    this.repository = this.dataSource.getRepository(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 entities extracted from a block to database\n   * @param queryRunner\n   * @param entitiesToInsert\n   * @param block\n   * @param extractor\n   */\n  protected insertEntities = async (\n    queryRunner: QueryRunner,\n    entitiesToInsert: Array<ExtractedData>,\n    block: BlockInfo,\n    extractor: string,\n  ) => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    await repository.insert(\n      this.createEntity(entitiesToInsert, block, extractor) as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    );\n  };\n\n  /**\n   * update an entity in the database\n   * @param queryRunner\n   * @param updateEntity\n   * @param block\n   * @param extractor\n   */\n  protected updateEntity = async (\n    queryRunner: QueryRunner,\n    updatedEntity: ExtractedData,\n    block: BlockInfo,\n    extractor: string,\n  ) => {\n    const repository = queryRunner.manager.getRepository(this.repo);\n    const entity = this.createEntity([updatedEntity], block, extractor)[0];\n    await repository.update(\n      {\n        identifier: entity.identifier,\n        extractor: extractor,\n      } as FindOptionsWhere<ExtractorEntity>,\n      entity as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n    );\n  };\n\n  /**\n   * delete all database records that were created from a specific block\n   * @param queryRunner\n   * @param extractor\n   * @param block\n   * @returns\n   */\n  protected deleteBlockRecords = 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   * override this method to revert the updates made to entities when a block is deleted\n   * e.g., mark boxes as unspent, update related entities, etc.\n   * @param queryRunner\n   * @param extractor\n   * @param block\n   * @returns\n   */\n  protected revertBlockUpdates = async (\n    queryRunner: QueryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars\n    extractor: string, // eslint-disable-line @typescript-eslint/no-unused-vars\n    block: string, // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): Promise<ExtractorEntity[]> => {\n    return [];\n  };\n\n  /**\n   * delete extracted data from a specific block\n   * if an entity is updated using the data in this block revert the update\n   * if an entity is created in this block remove it from database\n   * @param block\n   * @param extractor\n   * @return deleted items and updated entity identifiers\n   */\n  deleteBlockData = async (\n    block: string,\n    extractor: string,\n  ): Promise<{ deletedData: ExtractedData[]; updatedData: EntityInfo[] }> => {\n    this.logger.info(\n      `Deleting data in block ${block} and extractor ${extractor}`,\n    );\n    const queryRunner = this.dataSource.createQueryRunner();\n    await queryRunner.connect();\n    await queryRunner.startTransaction();\n    try {\n      const updatedData = await this.revertBlockUpdates(\n        queryRunner,\n        extractor,\n        block,\n      );\n      const deletedData = await this.deleteBlockRecords(\n        queryRunner,\n        extractor,\n        block,\n      );\n      await queryRunner.commitTransaction();\n      this.logger.debug(\n        `Deleted data successfully in block ${block} and extractor ${extractor}`,\n      );\n      return {\n        deletedData,\n        updatedData: updatedData.map((data) => pick(data, 'identifier')),\n      };\n    } catch (error) {\n      await queryRunner.rollbackTransaction();\n      throw error;\n    } finally {\n      await queryRunner.release();\n    }\n  };\n\n  /**\n   * insert all extracted entity data in an atomic transaction\n   * update the data if a entity with the same id is already stored in db\n   * @param entities\n   * @param block\n   * @param extractor\n   * @return inserted items and updated entity identifiers\n   * returns undefined in case of any problem\n   */\n  storeEntities = async (\n    entities: Array<ExtractedData>,\n    block: BlockInfo,\n    extractor: string,\n  ): Promise<boolean> => {\n    this.logger.debug(\n      `Storing entities in block ${block.hash} and ${extractor} extractor`,\n    );\n    let entitiesToInsert: ExtractedData[] = [],\n      entitiesToUpdate: 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 dbEntityIdentifiers = (\n        await repository.findBy({\n          identifier: In(entities.map((item) => item.identifier)),\n          extractor: extractor,\n        } as FindOptionsWhere<ExtractorEntity>)\n      ).map((entity) => entity.identifier);\n      if (dbEntityIdentifiers.length > 0)\n        this.logger.debug(\n          `Found stored entities with same identifier`,\n          dbEntityIdentifiers,\n        );\n\n      entitiesToUpdate = entities.filter((entity) =>\n        dbEntityIdentifiers.includes(entity.identifier),\n      );\n      entitiesToInsert = difference(entities, entitiesToUpdate);\n\n      if (entitiesToInsert.length > 0) {\n        this.logger.debug(\n          `Inserting ${entitiesToInsert.length} new entities to database`,\n        );\n        await this.insertEntities(\n          queryRunner,\n          entitiesToInsert,\n          block,\n          extractor,\n        );\n      }\n      if (entitiesToUpdate.length > 0)\n        this.logger.info(\n          `Updating entities with following Ids in the database: [${entitiesToUpdate\n            .map((entity) => entity.identifier)\n            .join(', ')}]`,\n        );\n      for (const entity of entitiesToUpdate) {\n        this.logger.debug(\n          `Updating entities in database [${JsonBigInt.stringify(entity)}]`,\n        );\n        await this.updateEntity(queryRunner, entity, block, extractor);\n      }\n      await queryRunner.commitTransaction();\n      return true;\n    } catch (e) {\n      this.logger.error(`An error occurred during store entities action: ${e}`);\n      await queryRunner.rollbackTransaction();\n      return false;\n    } finally {\n      await queryRunner.release();\n    }\n  };\n\n  /**\n   * remove all existing data for the extractor\n   * @param extractorId\n   */\n  removeAllData = async (extractorId: string) => {\n    this.logger.debug(`Removing all old data for extractor ${extractorId}`);\n    await this.repository.delete({\n      extractor: extractorId,\n    } as FindOptionsWhere<ExtractorEntity>);\n  };\n\n  /**\n   * Builds a query that returns used blocks by selecting the `block` column from the `ExtractorEntity` repository,\n   * filtered by the provided `extractorId`\n   *\n   * @param extractorId - Identifier of the extractor\n   * @returns A query builder selecting used blocks\n   */\n  createUsedBlocksQuery = (\n    extractorId: string,\n  ): SelectQueryBuilder<ExtractorEntity> => {\n    return this.repository\n      .createQueryBuilder('extractorEntity')\n      .select('extractorEntity.block', 'block')\n      .where('extractorEntity.extractor = :extractorId', { extractorId });\n  };\n}\n"]}

package/dist/ergo/database/actions/abstractErgoBoxAction.d.ts

@@ -0,0 +1,31 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource, EntityTarget, QueryRunner } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { AbstractEntityData, EntityInfo, SpendInfo } from '../../interfaces';
+import { AbstractErgoBoxEntity } from '../entities/abstractErgoBoxEntity';
+import { AbstractErgoAction } from './abstractErgoAction';
+export declare abstract class AbstractErgoBoxAction<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoBoxEntity> extends AbstractErgoAction<ExtractedData, ExtractorEntity> {
+    constructor(dataSource: DataSource, repo: EntityTarget<ExtractorEntity>, logger?: AbstractLogger);
+    /**
+     * revert the spending updates when a block is deleted
+     * remove spending information of boxes that are spent in the block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    protected revertBlockUpdates: (queryRunner: QueryRunner, extractor: string, block: string) => Promise<ExtractorEntity[]>;
+    /**
+     * 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
+     */
+    updateSpendingInfo: (spendInfos: Array<SpendInfo>, block: BlockInfo, extractor: string) => Promise<EntityInfo[]>;
+}
+//# sourceMappingURL=abstractErgoBoxAction.d.ts.map

package/dist/ergo/database/actions/abstractErgoBoxAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoBoxAction.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/database/actions/abstractErgoBoxAction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,UAAU,EAGV,YAAY,EAEZ,WAAW,EACZ,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAG7D,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,qBAAqB,CAC7C,SAAQ,kBAAkB,CAAC,aAAa,EAAE,eAAe,CAAC;gBAExD,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,YAAY,CAAC,eAAe,CAAC,EACnC,MAAM,CAAC,EAAE,cAAc;IAKzB;;;;;;;OAOG;IACH,SAAS,CAAC,kBAAkB,GAC1B,aAAa,WAAW,EACxB,WAAW,MAAM,EACjB,OAAO,MAAM,KACZ,OAAO,CAAC,eAAe,EAAE,CAAC,CAoB3B;IAEF;;;;;;;;;;OAUG;IACH,kBAAkB,GAChB,YAAY,KAAK,CAAC,SAAS,CAAC,EAC5B,OAAO,SAAS,EAChB,WAAW,MAAM,KAChB,OAAO,CAAC,UAAU,EAAE,CAAC,CA4BtB;CACH"}

package/dist/ergo/database/actions/abstractErgoBoxAction.js

@@ -0,0 +1,70 @@
+import { chunk, pick } from 'lodash-es';
+import { In, Not, } from '@rosen-bridge/extended-typeorm';
+import { DB_CHUNK_SIZE } from '../../../constants';
+import { AbstractErgoAction } from './abstractErgoAction';
+export class AbstractErgoBoxAction extends AbstractErgoAction {
+    constructor(dataSource, repo, logger) {
+        super(dataSource, repo, logger);
+    }
+    /**
+     * revert the spending updates when a block is deleted
+     * remove spending information of boxes that are spent in the block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    revertBlockUpdates = async (queryRunner, extractor, block) => {
+        const repository = queryRunner.manager.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: null,
+        });
+        return updatedData;
+    };
+    /**
+     * 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
+     */
+    updateSpendingInfo = 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({
+                identifier: In(boxIds),
+                extractor: extractor,
+            }, {
+                spendBlock: block.hash,
+                spendHeight: block.height,
+            });
+            if (updateResult.affected && updateResult.affected > 0) {
+                const spentRows = await this.repository.findBy({
+                    identifier: In(boxIds),
+                    spendBlock: block.hash,
+                });
+                spentData.push(...spentRows);
+                this.logger.debug(`Spent boxes with boxId ${spentRows.map((row) => row.identifier)} at height ${block.height}`);
+            }
+        }
+        return spentData.map((data) => pick(data, 'identifier'));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ergo/database/entities/abstractErgoBoxEntity.d.ts

@@ -0,0 +1,18 @@
+import { AbstractErgoEntity } from './abstractErgoEntity';
+/**
+ * Box entity for UTXO-based data extraction.
+ *
+ * This entity extends the base AbstractErgoEntity with box-specific fields
+ * for tracking UTXO spending states.
+ */
+export declare abstract class AbstractErgoBoxEntity extends AbstractErgoEntity {
+    /**
+     * Block hash where this box was spent (null if unspent).
+     */
+    spendBlock?: string | null;
+    /**
+     * Block height where this box was spent (null if unspent).
+     */
+    spendHeight?: number | null;
+}
+//# sourceMappingURL=abstractErgoBoxEntity.d.ts.map

package/dist/ergo/database/entities/abstractErgoBoxEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoBoxEntity.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/database/entities/abstractErgoBoxEntity.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;;;GAKG;AACH,8BAAsB,qBAAsB,SAAQ,kBAAkB;IACpE;;OAEG;IAEH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;OAEG;IAEH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B"}

package/dist/ergo/database/entities/abstractErgoBoxEntity.js

@@ -0,0 +1,36 @@
+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 } from '@rosen-bridge/extended-typeorm';
+import { AbstractErgoEntity } from './abstractErgoEntity';
+/**
+ * Box entity for UTXO-based data extraction.
+ *
+ * This entity extends the base AbstractErgoEntity with box-specific fields
+ * for tracking UTXO spending states.
+ */
+export class AbstractErgoBoxEntity extends AbstractErgoEntity {
+    /**
+     * Block hash where this box was spent (null if unspent).
+     */
+    spendBlock;
+    /**
+     * Block height where this box was spent (null if unspent).
+     */
+    spendHeight;
+}
+__decorate([
+    Column({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], AbstractErgoBoxEntity.prototype, "spendBlock", void 0);
+__decorate([
+    Column({ nullable: true, type: 'int' }),
+    __metadata("design:type", Object)
+], AbstractErgoBoxEntity.prototype, "spendHeight", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3RFcmdvQm94RW50aXR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGliL2VyZ28vZGF0YWJhc2UvZW50aXRpZXMvYWJzdHJhY3RFcmdvQm94RW50aXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUV4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUUxRDs7Ozs7R0FLRztBQUNILE1BQU0sT0FBZ0IscUJBQXNCLFNBQVEsa0JBQWtCO0lBQ3BFOztPQUVHO0lBRUgsVUFBVSxDQUFpQjtJQUUzQjs7T0FFRztJQUVILFdBQVcsQ0FBaUI7Q0FDN0I7QUFQQztJQURDLE1BQU0sQ0FBQyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxDQUFDOzt5REFDakI7QUFNM0I7SUFEQyxNQUFNLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsQ0FBQzs7MERBQ1oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb2x1bW4gfSBmcm9tICdAcm9zZW4tYnJpZGdlL2V4dGVuZGVkLXR5cGVvcm0nO1xuXG5pbXBvcnQgeyBBYnN0cmFjdEVyZ29FbnRpdHkgfSBmcm9tICcuL2Fic3RyYWN0RXJnb0VudGl0eSc7XG5cbi8qKlxuICogQm94IGVudGl0eSBmb3IgVVRYTy1iYXNlZCBkYXRhIGV4dHJhY3Rpb24uXG4gKlxuICogVGhpcyBlbnRpdHkgZXh0ZW5kcyB0aGUgYmFzZSBBYnN0cmFjdEVyZ29FbnRpdHkgd2l0aCBib3gtc3BlY2lmaWMgZmllbGRzXG4gKiBmb3IgdHJhY2tpbmcgVVRYTyBzcGVuZGluZyBzdGF0ZXMuXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdEVyZ29Cb3hFbnRpdHkgZXh0ZW5kcyBBYnN0cmFjdEVyZ29FbnRpdHkge1xuICAvKipcbiAgICogQmxvY2sgaGFzaCB3aGVyZSB0aGlzIGJveCB3YXMgc3BlbnQgKG51bGwgaWYgdW5zcGVudCkuXG4gICAqL1xuICBAQ29sdW1uKHsgbnVsbGFibGU6IHRydWUsIHR5cGU6ICd2YXJjaGFyJyB9KVxuICBzcGVuZEJsb2NrPzogc3RyaW5nIHwgbnVsbDtcblxuICAvKipcbiAgICogQmxvY2sgaGVpZ2h0IHdoZXJlIHRoaXMgYm94IHdhcyBzcGVudCAobnVsbCBpZiB1bnNwZW50KS5cbiAgICovXG4gIEBDb2x1bW4oeyBudWxsYWJsZTogdHJ1ZSwgdHlwZTogJ2ludCcgfSlcbiAgc3BlbmRIZWlnaHQ/OiBudW1iZXIgfCBudWxsO1xufVxuIl19

package/dist/ergo/database/entities/abstractErgoEntity.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Abstract base entity for storing extracted blockchain data.
+ *
+ * This entity serves as the foundation for all extracted data storage,
+ * supporting both box-based and transaction-based extraction patterns.
+ * The identifier field can represent different types of blockchain data:
+ * - For box-based extractors: boxId (UTXO identifier)
+ * - For transaction-based extractors: txId (transaction identifier)
+ * - For general extractors: any unique blockchain data identifier
+ */
+export declare abstract class AbstractErgoEntity {
+    id: number;
+    block: string;
+    height: number;
+    extractor: string;
+    /**
+     * Unique identifier for the entity in the blockchain.
+     * This can be:
+     * - boxId for UTXO-based data (box extractors)
+     * - txId for transaction-based data (general extractors)
+     * - Any unique blockchain data identifier for custom extractors
+     */
+    identifier: string;
+    serialized: string;
+}
+//# sourceMappingURL=abstractErgoEntity.d.ts.map

package/dist/ergo/database/entities/abstractErgoEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoEntity.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/database/entities/abstractErgoEntity.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,8BACsB,kBAAkB;IAEtC,EAAE,EAAE,MAAM,CAAC;IAGX,KAAK,EAAE,MAAM,CAAC;IAGd,MAAM,EAAE,MAAM,CAAC;IAGf,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;OAMG;IAEH,UAAU,EAAE,MAAM,CAAC;IAGnB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/ergo/database/entities/abstractErgoEntity.js

@@ -0,0 +1,64 @@
+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';
+/**
+ * Abstract base entity for storing extracted blockchain data.
+ *
+ * This entity serves as the foundation for all extracted data storage,
+ * supporting both box-based and transaction-based extraction patterns.
+ * The identifier field can represent different types of blockchain data:
+ * - For box-based extractors: boxId (UTXO identifier)
+ * - For transaction-based extractors: txId (transaction identifier)
+ * - For general extractors: any unique blockchain data identifier
+ */
+let AbstractErgoEntity = class AbstractErgoEntity {
+    id;
+    block;
+    height;
+    extractor;
+    /**
+     * Unique identifier for the entity in the blockchain.
+     * This can be:
+     * - boxId for UTXO-based data (box extractors)
+     * - txId for transaction-based data (general extractors)
+     * - Any unique blockchain data identifier for custom extractors
+     */
+    identifier;
+    serialized;
+};
+__decorate([
+    PrimaryGeneratedColumn(),
+    __metadata("design:type", Number)
+], AbstractErgoEntity.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "block", void 0);
+__decorate([
+    Column({ type: 'int' }),
+    __metadata("design:type", Number)
+], AbstractErgoEntity.prototype, "height", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "extractor", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "identifier", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AbstractErgoEntity.prototype, "serialized", void 0);
+AbstractErgoEntity = __decorate([
+    Unique(['identifier', 'extractor'])
+], AbstractErgoEntity);
+export { AbstractErgoEntity };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+export * from './entities/abstractErgoBoxEntity';
+export * from './entities/abstractErgoEntity';
+export * from './actions/abstractErgoBoxAction';
+export * from './actions/abstractErgoAction';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/database/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC"}

package/dist/ergo/database/index.js

@@ -0,0 +1,5 @@
+export * from './entities/abstractErgoBoxEntity';
+export * from './entities/abstractErgoEntity';
+export * from './actions/abstractErgoBoxAction';
+export * from './actions/abstractErgoAction';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9kYXRhYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lbnRpdGllcy9hYnN0cmFjdEVyZ29Cb3hFbnRpdHknO1xuZXhwb3J0ICogZnJvbSAnLi9lbnRpdGllcy9hYnN0cmFjdEVyZ29FbnRpdHknO1xuZXhwb3J0ICogZnJvbSAnLi9hY3Rpb25zL2Fic3RyYWN0RXJnb0JveEFjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2FjdGlvbnMvYWJzdHJhY3RFcmdvQWN0aW9uJztcbiJdfQ==

package/dist/ergo/extractors/abstractErgoBoxExtractor.d.ts

@@ -0,0 +1,67 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { Transaction, BlockInfo, OutputBox, InputExtension } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoBoxEntity, AbstractErgoBoxAction } from '../database';
+import { AbstractEntityData, TxExtra, InitializeOptions } from '../interfaces';
+import { AbstractErgoExtractor } from './abstractErgoExtractor';
+/**
+ * Abstract Ergo Box Extractor class for box-based data extraction.
+ *
+ * This class extends the AbstractErgoExtractor class and provides
+ * functionality for extracting box-based data from the blockchain.
+ *
+ * It overrides the `initializeData` method to use the box-based initializer.
+ * It implements the `processTransactions` method to use the box-based data extraction.
+ *
+ * Triggers `Insert` callback on new data insertion.
+ * Triggers a new callback type `Spend` for each spent box.
+ *
+ * @template ExtractedData - The type of data extracted from blockchain
+ * @template ExtractorEntity - The database entity type for storing extracted data
+ */
+export declare abstract class AbstractErgoBoxExtractor<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoBoxEntity> extends AbstractErgoExtractor<ExtractedData, ExtractorEntity> {
+    protected abstract actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>;
+    constructor(initializeOptions?: InitializeOptions, logger?: AbstractLogger);
+    /**
+     * extract box data to proper format (not including spending information)
+     * @param box
+     * @param inputExtensions all input box extensions in transaction
+     * @return extracted data in proper format
+     */
+    abstract extractBoxData: (box: OutputBox, inputExtensions: InputExtension[], txExtra?: TxExtra) => ExtractedData | undefined;
+    /**
+     * check proper data format in the box
+     * @param box
+     * @return true if the box has the required data and false otherwise
+     */
+    abstract hasBoxData: (box: OutputBox) => boolean;
+    /**
+     * extract transaction extra information
+     * override this function if there is extra needed information
+     * @param tx
+     * @returns
+     */
+    getTransactionExtraData: (tx: Transaction) => TxExtra;
+    /**
+     * create spend info array for the transaction
+     * @param tx
+     * @returns spend info array of the transaction
+     */
+    getTransactionSpendInfo: (tx: Transaction) => {
+        txId: string;
+        boxId: string;
+        index: number;
+    }[];
+    /**
+     * 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: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
+    /**
+     * initialize extractor database with data created below the initial height
+     * @param initialBlock
+     */
+    initializeData: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=abstractErgoBoxExtractor.d.ts.map

package/dist/ergo/extractors/abstractErgoBoxExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoBoxExtractor.d.ts","sourceRoot":"","sources":["../../../lib/ergo/extractors/abstractErgoBoxExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,cAAc,EACf,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE3E,OAAO,EACL,kBAAkB,EAGlB,OAAO,EACP,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,wBAAwB,CAC5C,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,qBAAqB,CAC7C,SAAQ,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;IAC7D,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAC/C,aAAa,EACb,eAAe,CAChB,CAAC;gBAEU,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,cAAc;IAI1E;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,SAAS,EACd,eAAe,EAAE,cAAc,EAAE,EACjC,OAAO,CAAC,EAAE,OAAO,KACd,aAAa,GAAG,SAAS,CAAC;IAE/B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAEjD;;;;;OAKG;IACH,uBAAuB,GACrB,IAAI,WAAW,KACd,OAAO,CAER;IAEF;;;;OAIG;IACH,uBAAuB,GAAI,IAAI,WAAW;;;;QAQxC;IAEF;;;;;OAKG;IACH,mBAAmB,GACjB,KAAK,WAAW,EAAE,EAClB,OAAO,SAAS,KACf,OAAO,CAAC,OAAO,CAAC,CA2DjB;IAEF;;;OAGG;IACH,cAAc,GAAU,cAAc,SAAS,KAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;CACH"}