@rosen-bridge/abstract-extractor 2.1.2 → 3.0.0-8f3c7016

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @rosen-bridge/abstract-extractor
 
+## 3.0.0-8f3c7016
+
+### Major Changes
+
+- Update AbstractExtractor interface; use `BlockInfo` in `processTransactions` and rename `initializeBoxes` to `initializeData`
+- Update abstract entities and actions to have a new abstraction level, seperating box-based logic from general extraction
+- Update `AbstractErgoExtractor` to use a tx-based data extraction method and add `AbstractErgoBoxExtractor` for box-based data extraction
+- Update abstract database entity to be general; rename `boxId` columnt to `identifier`
+
 ## 2.1.2
 
 ### Patch Changes

package/dist/abstractExtractor.d.ts

@@ -1,25 +1,37 @@
-import { BlockInfo, Block } from '@rosen-bridge/scanner-interfaces';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
 export declare abstract class AbstractExtractor<TransactionType> {
     /**
-     * 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
+     * Process a list of transactions (or other blockchain data) in a block and store required information.
+     * This method is the core of the extraction process and should be implemented to handle
+     * the specific data extraction logic for your blockchain.
+     *
+     * @param txs - List of transactions or blockchain data structures in the block
+     * @param block - Block information containing metadata about the block
+     * @returns Promise<boolean> - true if the process completed successfully, false otherwise
      */
-    abstract processTransactions: (txs: Array<TransactionType>, block: Block) => Promise<boolean>;
+    abstract processTransactions: (txs: Array<TransactionType>, block: BlockInfo) => Promise<boolean>;
     /**
-     * return extractor id. This id must be unique over all extractors.
+     * Return a unique identifier for this extractor.
+     * This ID must be unique across all extractors in the system to prevent conflicts.
+     *
+     * @returns string - Unique extractor identifier
      */
     abstract getId: () => string;
     /**
-     * fork one block and remove all stored information for this block
-     * @param hash block hash
+     * Fork (rollback) one block and remove all stored information for this block.
+     * This is essential for handling blockchain reorganizations where blocks
+     * need to be removed from the database.
+     *
+     * @param hash - Block hash to fork/remove
      */
     abstract forkBlock: (hash: string) => Promise<void>;
     /**
-     * initialize extractor database with data created below the initial height
-     * @param initialBlock
+     * Initialize extractor database with historical data created below the initial height.
+     * This method is called during extractor setup to populate the database with
+     * data that existed before the scanner started monitoring.
+     *
+     * @param initialBlock - The block from which to start scanning (initial height)
      */
-    abstract initializeBoxes: (initialBlock: BlockInfo) => Promise<void>;
+    abstract initializeData: (initialBlock: BlockInfo) => Promise<void>;
 }
 //# sourceMappingURL=abstractExtractor.d.ts.map

package/dist/abstractExtractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstractExtractor.d.ts","sourceRoot":"","sources":["../lib/abstractExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAEpE,8BAAsB,iBAAiB,CAAC,eAAe;IACrD;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,EAAE,CAC5B,GAAG,EAAE,KAAK,CAAC,eAAe,CAAC,EAC3B,KAAK,EAAE,KAAK,KACT,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpD;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACtE"}
+{"version":3,"file":"abstractExtractor.d.ts","sourceRoot":"","sources":["../lib/abstractExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,8BAAsB,iBAAiB,CAAC,eAAe;IACrD;;;;;;;;OAQG;IACH,QAAQ,CAAC,mBAAmB,EAAE,CAC5B,GAAG,EAAE,KAAK,CAAC,eAAe,CAAC,EAC3B,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;IAE7B;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpD;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE"}

package/dist/abstractExtractor.js

@@ -1,3 +1,3 @@
 export class AbstractExtractor {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3RFeHRyYWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvYWJzdHJhY3RFeHRyYWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFnQixpQkFBaUI7Q0E0QnRDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmxvY2tJbmZvLCBCbG9jayB9IGZyb20gJ0Byb3Nlbi1icmlkZ2Uvc2Nhbm5lci1pbnRlcmZhY2VzJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0RXh0cmFjdG9yPFRyYW5zYWN0aW9uVHlwZT4ge1xuICAvKipcbiAgICogcHJvY2VzcyBhIGxpc3Qgb2YgdHJhbnNhY3Rpb25zIGluIGEgYmxvY2sgYW5kIHN0b3JlIHJlcXVpcmVkIGluZm9ybWF0aW9uXG4gICAqIEBwYXJhbSB0eHMgbGlzdCBvZiB0cmFuc2FjdGlvbnMgaW4gdGhlIGJsb2NrXG4gICAqIEBwYXJhbSBibG9ja1xuICAgKiBAcmV0dXJuIHRydWUgaWYgdGhlIHByb2Nlc3MgaXMgY29tcGxldGVkIHN1Y2Nlc3NmdWxseSBhbmQgZmFsc2Ugb3RoZXJ3aXNlXG4gICAqL1xuICBhYnN0cmFjdCBwcm9jZXNzVHJhbnNhY3Rpb25zOiAoXG4gICAgdHhzOiBBcnJheTxUcmFuc2FjdGlvblR5cGU+LFxuICAgIGJsb2NrOiBCbG9jayxcbiAgKSA9PiBQcm9taXNlPGJvb2xlYW4+O1xuXG4gIC8qKlxuICAgKiByZXR1cm4gZXh0cmFjdG9yIGlkLiBUaGlzIGlkIG11c3QgYmUgdW5pcXVlIG92ZXIgYWxsIGV4dHJhY3RvcnMuXG4gICAqL1xuICBhYnN0cmFjdCBnZXRJZDogKCkgPT4gc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBmb3JrIG9uZSBibG9jayBhbmQgcmVtb3ZlIGFsbCBzdG9yZWQgaW5mb3JtYXRpb24gZm9yIHRoaXMgYmxvY2tcbiAgICogQHBhcmFtIGhhc2ggYmxvY2sgaGFzaFxuICAgKi9cbiAgYWJzdHJhY3QgZm9ya0Jsb2NrOiAoaGFzaDogc3RyaW5nKSA9PiBQcm9taXNlPHZvaWQ+O1xuXG4gIC8qKlxuICAgKiBpbml0aWFsaXplIGV4dHJhY3RvciBkYXRhYmFzZSB3aXRoIGRhdGEgY3JlYXRlZCBiZWxvdyB0aGUgaW5pdGlhbCBoZWlnaHRcbiAgICogQHBhcmFtIGluaXRpYWxCbG9ja1xuICAgKi9cbiAgYWJzdHJhY3QgaW5pdGlhbGl6ZUJveGVzOiAoaW5pdGlhbEJsb2NrOiBCbG9ja0luZm8pID0+IFByb21pc2U8dm9pZD47XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const API_LIMIT = 100;
 export declare const RETRIAL_COUNT = 10;
 export declare const DB_CHUNK_SIZE = 100;
+export declare const MAX_PARALLEL_REQUESTS = 10;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,MAAM,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,qBAAqB,KAAK,CAAC"}

package/dist/constants.js

@@ -1,4 +1,5 @@
 export const API_LIMIT = 100;
 export const RETRIAL_COUNT = 10;
 export const DB_CHUNK_SIZE = 100;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsR0FBRyxDQUFDO0FBQzdCLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxFQUFFLENBQUM7QUFDaEMsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEdBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBBUElfTElNSVQgPSAxMDA7XG5leHBvcnQgY29uc3QgUkVUUklBTF9DT1VOVCA9IDEwO1xuZXhwb3J0IGNvbnN0IERCX0NIVU5LX1NJWkUgPSAxMDA7XG4iXX0=
+export const MAX_PARALLEL_REQUESTS = 10;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsR0FBRyxDQUFDO0FBQzdCLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxFQUFFLENBQUM7QUFDaEMsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEdBQUcsQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgQVBJX0xJTUlUID0gMTAwO1xuZXhwb3J0IGNvbnN0IFJFVFJJQUxfQ09VTlQgPSAxMDtcbmV4cG9ydCBjb25zdCBEQl9DSFVOS19TSVpFID0gMTAwO1xuZXhwb3J0IGNvbnN0IE1BWF9QQVJBTExFTF9SRVFVRVNUUyA9IDEwO1xuIl19

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

@@ -0,0 +1,83 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+import { DataSource, EntityTarget, QueryRunner, Repository } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { AbstractEntityData, EntityInfo } from '../../interfaces';
+import { AbstractErgoEntity } from '../entities/abstractErgoEntity';
+export declare abstract class AbstractErgoAction<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoEntity> {
+    protected readonly dataSource: DataSource;
+    protected readonly repo: EntityTarget<ExtractorEntity>;
+    protected readonly logger: AbstractLogger;
+    protected readonly repository: Repository<ExtractorEntity>;
+    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 entities extracted from a block to database
+     * @param queryRunner
+     * @param entitiesToInsert
+     * @param block
+     * @param extractor
+     */
+    protected insertEntities: (queryRunner: QueryRunner, entitiesToInsert: Array<ExtractedData>, block: BlockInfo, extractor: string) => Promise<void>;
+    /**
+     * update an entity in the database
+     * @param queryRunner
+     * @param updateEntity
+     * @param block
+     * @param extractor
+     */
+    protected updateEntity: (queryRunner: QueryRunner, updatedEntity: ExtractedData, block: BlockInfo, extractor: string) => Promise<void>;
+    /**
+     * delete all database records that were created from a specific block
+     * @param queryRunner
+     * @param extractor
+     * @param block
+     * @returns
+     */
+    protected deleteBlockRecords: (queryRunner: QueryRunner, extractor: string, block: string) => Promise<ExtractedData[]>;
+    /**
+     * 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
+     */
+    protected revertBlockUpdates: (queryRunner: QueryRunner, // eslint-disable-line @typescript-eslint/no-unused-vars
+    extractor: string, // eslint-disable-line @typescript-eslint/no-unused-vars
+    block: string) => Promise<ExtractorEntity[]>;
+    /**
+     * 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: (block: string, extractor: string) => Promise<{
+        deletedData: ExtractedData[];
+        updatedData: EntityInfo[];
+    }>;
+    /**
+     * 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: (entities: Array<ExtractedData>, block: BlockInfo, extractor: string) => Promise<boolean>;
+    /**
+     * remove all existing data for the extractor
+     * @param extractorId
+     */
+    removeAllData: (extractorId: string) => Promise<void>;
+}
+//# sourceMappingURL=abstractErgoAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"abstractErgoAction.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/database/actions/abstractErgoAction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,UAAU,EACV,YAAY,EAGZ,WAAW,EACX,UAAU,EACX,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEpE,8BAAsB,kBAAkB,CACtC,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,kBAAkB;IAKxC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU;IACzC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,eAAe,CAAC;IACtD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc;IAL3C,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,CAAC;gBAGtC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,YAAY,CAAC,eAAe,CAAC,EACnC,MAAM,GAAE,cAAkC;IAK/D;;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;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,GACtB,aAAa,WAAW,EACxB,kBAAkB,KAAK,CAAC,aAAa,CAAC,EACtC,OAAO,SAAS,EAChB,WAAW,MAAM,mBAMjB;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,GACpB,aAAa,WAAW,EACxB,eAAe,aAAa,EAC5B,OAAO,SAAS,EAChB,WAAW,MAAM,mBAWjB;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,kBAAkB,GAC1B,aAAa,WAAW,EACxB,WAAW,MAAM,EACjB,OAAO,MAAM,KACZ,OAAO,CAAC,aAAa,EAAE,CAAC,CAazB;IAEF;;;;;;;OAOG;IACH,SAAS,CAAC,kBAAkB,GAC1B,aAAa,WAAW,EAAE,wDAAwD;IAClF,WAAW,MAAM,EAAE,wDAAwD;IAC3E,OAAO,MAAM,KACZ,OAAO,CAAC,eAAe,EAAE,CAAC,CAE3B;IAEF;;;;;;;OAOG;IACH,eAAe,GACb,OAAO,MAAM,EACb,WAAW,MAAM,KAChB,OAAO,CAAC;QAAE,WAAW,EAAE,aAAa,EAAE,CAAC;QAAC,WAAW,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC,CAgCrE;IAEF;;;;;;;;OAQG;IACH,aAAa,GACX,UAAU,KAAK,CAAC,aAAa,CAAC,EAC9B,OAAO,SAAS,EAChB,WAAW,MAAM,KAChB,OAAO,CAAC,OAAO,CAAC,CA4DjB;IAEF;;;OAGG;IACH,aAAa,GAAU,aAAa,MAAM,mBAKxC;CACH"}

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

@@ -0,0 +1,167 @@
+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} 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,
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractErgoAction.js","sourceRoot":"","sources":["../../../../lib/ergo/database/actions/abstractErgoAction.ts"],"names":[],"mappings":"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","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} 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} 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"]}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3RFcmdvQm94QWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGliL2VyZ28vZGF0YWJhc2UvYWN0aW9ucy9hYnN0cmFjdEVyZ29Cb3hBY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFHeEMsT0FBTyxFQUVMLEVBQUUsRUFDRixHQUFHLEdBSUosTUFBTSxnQ0FBZ0MsQ0FBQztBQUd4QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHbkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFMUQsTUFBTSxPQUFnQixxQkFHcEIsU0FBUSxrQkFBa0Q7SUFDMUQsWUFDRSxVQUFzQixFQUN0QixJQUFtQyxFQUNuQyxNQUF1QjtRQUV2QixLQUFLLENBQUMsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNPLGtCQUFrQixHQUFHLEtBQUssRUFDbEMsV0FBd0IsRUFDeEIsU0FBaUIsRUFDakIsS0FBYSxFQUNlLEVBQUU7UUFDOUIsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2hFLE1BQU0sV0FBVyxHQUFHLE1BQU0sVUFBVSxDQUFDLElBQUksQ0FBQztZQUN4QyxLQUFLLEVBQUU7Z0JBQ0wsU0FBUyxFQUFFLFNBQVM7Z0JBQ3BCLFVBQVUsRUFBRSxLQUFLO2dCQUNqQixLQUFLLEVBQUUsR0FBRyxDQUFDLEtBQUssQ0FBQzthQUM4QjtTQUNsRCxDQUFDLENBQUM7UUFDSCxNQUFNLFVBQVUsQ0FBQyxNQUFNLENBQ3JCO1lBQ0UsVUFBVSxFQUFFLEtBQUs7WUFDakIsU0FBUyxFQUFFLFNBQVM7U0FDMkIsRUFDakQ7WUFDRSxVQUFVLEVBQUUsSUFBSTtZQUNoQixXQUFXLEVBQUUsSUFBSTtTQUNYLENBQ1QsQ0FBQztRQUNGLE9BQU8sV0FBMkMsQ0FBQztJQUNyRCxDQUFDLENBQUM7SUFFRjs7Ozs7Ozs7OztPQVVHO0lBQ0gsa0JBQWtCLEdBQUcsS0FBSyxFQUN4QixVQUE0QixFQUM1QixLQUFnQixFQUNoQixTQUFpQixFQUNNLEVBQUU7UUFDekIsTUFBTSxTQUFTLEdBQUcsRUFBRSxDQUFDO1FBQ3JCLE1BQU0sZUFBZSxHQUFHLEtBQUssQ0FBQyxVQUFVLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFDekQsS0FBSyxNQUFNLGNBQWMsSUFBSSxlQUFlLEVBQUUsQ0FBQztZQUM3QyxNQUFNLE1BQU0sR0FBRyxjQUFjLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDeEQsTUFBTSxZQUFZLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FDL0M7Z0JBQ0UsVUFBVSxFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUM7Z0JBQ3RCLFNBQVMsRUFBRSxTQUFTO2FBQ2dCLEVBQ3RDO2dCQUNFLFVBQVUsRUFBRSxLQUFLLENBQUMsSUFBSTtnQkFDdEIsV0FBVyxFQUFFLEtBQUssQ0FBQyxNQUFNO2FBQ25CLENBQ1QsQ0FBQztZQUVGLElBQUksWUFBWSxDQUFDLFFBQVEsSUFBSSxZQUFZLENBQUMsUUFBUSxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUN2RCxNQUFNLFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDO29CQUM3QyxVQUFVLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQztvQkFDdEIsVUFBVSxFQUFFLEtBQUssQ0FBQyxJQUFJO2lCQUNjLENBQUMsQ0FBQztnQkFDeEMsU0FBUyxDQUFDLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQUFDO2dCQUM3QixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FDZiwwQkFBMEIsU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxjQUFjLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FDN0YsQ0FBQztZQUNKLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFlBQVksQ0FBQyxDQUFDLENBQUM7SUFDM0QsQ0FBQyxDQUFDO0NBQ0giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjaHVuaywgcGljayB9IGZyb20gJ2xvZGFzaC1lcyc7XG5cbmltcG9ydCB7IEFic3RyYWN0TG9nZ2VyIH0gZnJvbSAnQHJvc2VuLWJyaWRnZS9hYnN0cmFjdC1sb2dnZXInO1xuaW1wb3J0IHtcbiAgRGF0YVNvdXJjZSxcbiAgSW4sXG4gIE5vdCxcbiAgRW50aXR5VGFyZ2V0LFxuICBGaW5kT3B0aW9uc1doZXJlLFxuICBRdWVyeVJ1bm5lcixcbn0gZnJvbSAnQHJvc2VuLWJyaWRnZS9leHRlbmRlZC10eXBlb3JtJztcbmltcG9ydCB7IEJsb2NrSW5mbyB9IGZyb20gJ0Byb3Nlbi1icmlkZ2Uvc2Nhbm5lci1pbnRlcmZhY2VzJztcblxuaW1wb3J0IHsgREJfQ0hVTktfU0laRSB9IGZyb20gJy4uLy4uLy4uL2NvbnN0YW50cyc7XG5pbXBvcnQgeyBBYnN0cmFjdEVudGl0eURhdGEsIEVudGl0eUluZm8sIFNwZW5kSW5mbyB9IGZyb20gJy4uLy4uL2ludGVyZmFjZXMnO1xuaW1wb3J0IHsgQWJzdHJhY3RFcmdvQm94RW50aXR5IH0gZnJvbSAnLi4vZW50aXRpZXMvYWJzdHJhY3RFcmdvQm94RW50aXR5JztcbmltcG9ydCB7IEFic3RyYWN0RXJnb0FjdGlvbiB9IGZyb20gJy4vYWJzdHJhY3RFcmdvQWN0aW9uJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0RXJnb0JveEFjdGlvbjxcbiAgRXh0cmFjdGVkRGF0YSBleHRlbmRzIEFic3RyYWN0RW50aXR5RGF0YSxcbiAgRXh0cmFjdG9yRW50aXR5IGV4dGVuZHMgQWJzdHJhY3RFcmdvQm94RW50aXR5LFxuPiBleHRlbmRzIEFic3RyYWN0RXJnb0FjdGlvbjxFeHRyYWN0ZWREYXRhLCBFeHRyYWN0b3JFbnRpdHk+IHtcbiAgY29uc3RydWN0b3IoXG4gICAgZGF0YVNvdXJjZTogRGF0YVNvdXJjZSxcbiAgICByZXBvOiBFbnRpdHlUYXJnZXQ8RXh0cmFjdG9yRW50aXR5PixcbiAgICBsb2dnZXI/OiBBYnN0cmFjdExvZ2dlcixcbiAgKSB7XG4gICAgc3VwZXIoZGF0YVNvdXJjZSwgcmVwbywgbG9nZ2VyKTtcbiAgfVxuXG4gIC8qKlxuICAgKiByZXZlcnQgdGhlIHNwZW5kaW5nIHVwZGF0ZXMgd2hlbiBhIGJsb2NrIGlzIGRlbGV0ZWRcbiAgICogcmVtb3ZlIHNwZW5kaW5nIGluZm9ybWF0aW9uIG9mIGJveGVzIHRoYXQgYXJlIHNwZW50IGluIHRoZSBibG9ja1xuICAgKiBAcGFyYW0gcXVlcnlSdW5uZXJcbiAgICogQHBhcmFtIGV4dHJhY3RvclxuICAgKiBAcGFyYW0gYmxvY2tcbiAgICogQHJldHVybnNcbiAgICovXG4gIHByb3RlY3RlZCByZXZlcnRCbG9ja1VwZGF0ZXMgPSBhc3luYyAoXG4gICAgcXVlcnlSdW5uZXI6IFF1ZXJ5UnVubmVyLFxuICAgIGV4dHJhY3Rvcjogc3RyaW5nLFxuICAgIGJsb2NrOiBzdHJpbmcsXG4gICk6IFByb21pc2U8RXh0cmFjdG9yRW50aXR5W10+ID0+IHtcbiAgICBjb25zdCByZXBvc2l0b3J5ID0gcXVlcnlSdW5uZXIubWFuYWdlci5nZXRSZXBvc2l0b3J5KHRoaXMucmVwbyk7XG4gICAgY29uc3QgdXBkYXRlZERhdGEgPSBhd2FpdCByZXBvc2l0b3J5LmZpbmQoe1xuICAgICAgd2hlcmU6IHtcbiAgICAgICAgZXh0cmFjdG9yOiBleHRyYWN0b3IsXG4gICAgICAgIHNwZW5kQmxvY2s6IGJsb2NrLFxuICAgICAgICBibG9jazogTm90KGJsb2NrKSxcbiAgICAgIH0gYXMgdW5rbm93biBhcyBGaW5kT3B0aW9uc1doZXJlPEV4dHJhY3RvckVudGl0eT4sXG4gICAgfSk7XG4gICAgYXdhaXQgcmVwb3NpdG9yeS51cGRhdGUoXG4gICAgICB7XG4gICAgICAgIHNwZW5kQmxvY2s6IGJsb2NrLFxuICAgICAgICBleHRyYWN0b3I6IGV4dHJhY3RvcixcbiAgICAgIH0gYXMgdW5rbm93biBhcyBGaW5kT3B0aW9uc1doZXJlPEV4dHJhY3RvckVudGl0eT4sXG4gICAgICB7XG4gICAgICAgIHNwZW5kQmxvY2s6IG51bGwsXG4gICAgICAgIHNwZW5kSGVpZ2h0OiBudWxsLFxuICAgICAgfSBhcyBhbnksIC8vIGVzbGludC1kaXNhYmxlLWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueVxuICAgICk7XG4gICAgcmV0dXJuIHVwZGF0ZWREYXRhIGFzIHVua25vd24gYXMgRXh0cmFjdG9yRW50aXR5W107XG4gIH07XG5cbiAgLyoqXG4gICAqIHVwZGF0ZSBzcGVuZGluZyBpbmZvcm1hdGlvbiBvZiBzdG9yZWQgYm94ZXNcbiAgICogY2h1bmsgc3BlbmRJbmZvcyB0byBwcmV2ZW50IGxhcmdlIGRhdGFiYXNlIHF1ZXJpZXNcbiAgICogTm90ZTogSXQgb25seSB1cGRhdGVzIHRoZSBzcGVuZEhlaWdodCBhbmQgc3BlbmRCbG9jayBmaWVsZHMuIElmIHVwZGF0aW5nXG4gICAqIGFueXRoaW5nIGVsc2UgaXMgcmVxdWlyZWQsIG92ZXJyaWRlIHRoaXMgaW1wbGVtZW50YXRpb24gdG8gaW5jbHVkZSB0aGVcbiAgICogYWRkaXRpb25hbCBmaWVsZHMuXG4gICAqIEBwYXJhbSBzcGVuZEluZm9zXG4gICAqIEBwYXJhbSBibG9ja1xuICAgKiBAcGFyYW0gZXh0cmFjdG9yXG4gICAqIEByZXR1cm5zIHNwZW50IGJveCBpZHNcbiAgICovXG4gIHVwZGF0ZVNwZW5kaW5nSW5mbyA9IGFzeW5jIChcbiAgICBzcGVuZEluZm9zOiBBcnJheTxTcGVuZEluZm8+LFxuICAgIGJsb2NrOiBCbG9ja0luZm8sXG4gICAgZXh0cmFjdG9yOiBzdHJpbmcsXG4gICk6IFByb21pc2U8RW50aXR5SW5mb1tdPiA9PiB7XG4gICAgY29uc3Qgc3BlbnREYXRhID0gW107XG4gICAgY29uc3Qgc3BlbmRJbmZvQ2h1bmtzID0gY2h1bmsoc3BlbmRJbmZvcywgREJfQ0hVTktfU0laRSk7XG4gICAgZm9yIChjb25zdCBzcGVuZEluZm9DaHVuayBvZiBzcGVuZEluZm9DaHVua3MpIHtcbiAgICAgIGNvbnN0IGJveElkcyA9IHNwZW5kSW5mb0NodW5rLm1hcCgoaW5mbykgPT4gaW5mby5ib3hJZCk7XG4gICAgICBjb25zdCB1cGRhdGVSZXN1bHQgPSBhd2FpdCB0aGlzLnJlcG9zaXRvcnkudXBkYXRlKFxuICAgICAgICB7XG4gICAgICAgICAgaWRlbnRpZmllcjogSW4oYm94SWRzKSxcbiAgICAgICAgICBleHRyYWN0b3I6IGV4dHJhY3RvcixcbiAgICAgICAgfSBhcyBGaW5kT3B0aW9uc1doZXJlPEV4dHJhY3RvckVudGl0eT4sXG4gICAgICAgIHtcbiAgICAgICAgICBzcGVuZEJsb2NrOiBibG9jay5oYXNoLFxuICAgICAgICAgIHNwZW5kSGVpZ2h0OiBibG9jay5oZWlnaHQsXG4gICAgICAgIH0gYXMgYW55LCAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby1leHBsaWNpdC1hbnlcbiAgICAgICk7XG5cbiAgICAgIGlmICh1cGRhdGVSZXN1bHQuYWZmZWN0ZWQgJiYgdXBkYXRlUmVzdWx0LmFmZmVjdGVkID4gMCkge1xuICAgICAgICBjb25zdCBzcGVudFJvd3MgPSBhd2FpdCB0aGlzLnJlcG9zaXRvcnkuZmluZEJ5KHtcbiAgICAgICAgICBpZGVudGlmaWVyOiBJbihib3hJZHMpLFxuICAgICAgICAgIHNwZW5kQmxvY2s6IGJsb2NrLmhhc2gsXG4gICAgICAgIH0gYXMgRmluZE9wdGlvbnNXaGVyZTxFeHRyYWN0b3JFbnRpdHk+KTtcbiAgICAgICAgc3BlbnREYXRhLnB1c2goLi4uc3BlbnRSb3dzKTtcbiAgICAgICAgdGhpcy5sb2dnZXIuZGVidWcoXG4gICAgICAgICAgYFNwZW50IGJveGVzIHdpdGggYm94SWQgJHtzcGVudFJvd3MubWFwKChyb3cpID0+IHJvdy5pZGVudGlmaWVyKX0gYXQgaGVpZ2h0ICR7YmxvY2suaGVpZ2h0fWAsXG4gICAgICAgICk7XG4gICAgICB9XG4gICAgfVxuICAgIHJldHVybiBzcGVudERhdGEubWFwKChkYXRhKSA9PiBwaWNrKGRhdGEsICdpZGVudGlmaWVyJykpO1xuICB9O1xufVxuIl19

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"}