@rosen-bridge/abstract-extractor 0.1.5 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @rosen-bridge/abstract-extractor
 
+## 0.3.0
+
+### Minor Changes
+
+- Add abstract extractor class that can be initialized using address transactions.
+
+### Patch Changes
+
+- Change processTransaction Block interface to use minimal information
+
+## 0.2.0
+
+### Minor Changes
+
+- Add spendIndex to extracted data in initialization
+
 ## 0.1.5
 
 ### Patch Changes

package/dist/ergo/AbstractErgoExtractor.d.ts

@@ -2,7 +2,7 @@ import { DataSource } from 'typeorm';
 import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';
 import { AbstractExtractor } from '../AbstractExtractor';
 import { AbstractErgoExtractorAction } from './AbstractErgoExtractorAction';
-import { Block } from '../interfaces';
+import { BlockInfo } from '../interfaces';
 import { Transaction, OutputBox, ErgoExtractedData } from './interfaces';
 export declare abstract class AbstractErgoExtractor<ExtractedData extends ErgoExtractedData> extends AbstractExtractor<Transaction> {
     protected readonly dataSource: DataSource;
@@ -29,7 +29,7 @@ export declare abstract class AbstractErgoExtractor<ExtractedData extends ErgoEx
      * @param block
      * @return true if the process is completed successfully and false otherwise
      */
-    processTransactions: (txs: Transaction[], block: Block) => Promise<boolean>;
+    processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
     /**
      * fork one block and remove all stored information for this block
      * @param hash block hash

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractErgoExtractor.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EACL,WAAW,EACX,SAAS,EACT,iBAAiB,EAElB,MAAM,cAAc,CAAC;AAEtB,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,iBAAiB,CACvC,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAC1C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC,aAAa,CAAC,CAAC;IACvE,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,cAAoB;IAKtC;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,KACX,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,aAAa,CAAC,GAAG,SAAS,CAAC;IAEnE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAE9C;;;;;OAKG;IACH,mBAAmB,QACZ,WAAW,EAAE,SACX,KAAK,KACX,QAAQ,OAAO,CAAC,CAyCjB;IAEF;;;OAGG;IACH,SAAS,SAAgB,MAAM,KAAG,QAAQ,IAAI,CAAC,CAE7C;CACH"}
+{"version":3,"file":"AbstractErgoExtractor.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EACL,WAAW,EACX,SAAS,EACT,iBAAiB,EAElB,MAAM,cAAc,CAAC;AAEtB,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,iBAAiB,CACvC,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAC1C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC,aAAa,CAAC,CAAC;IACvE,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,cAAoB;IAKtC;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,KACX,IAAI,CAAC,aAAa,EAAE,YAAY,GAAG,aAAa,CAAC,GAAG,SAAS,CAAC;IAEnE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAE9C;;;;;OAKG;IACH,mBAAmB,QACZ,WAAW,EAAE,SACX,SAAS,KACf,QAAQ,OAAO,CAAC,CAyCjB;IAEF;;;OAGG;IACH,SAAS,SAAgB,MAAM,KAAG,QAAQ,IAAI,CAAC,CAE7C;CACH"}

package/dist/ergo/AbstractErgoExtractor.js

@@ -54,4 +54,4 @@ export class AbstractErgoExtractor extends AbstractExtractor {
         await this.actions.deleteBlockBoxes(hash, this.getId());
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RFcmdvRXh0cmFjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2VyZ28vQWJzdHJhY3RFcmdvRXh0cmFjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBa0IsV0FBVyxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDNUUsT0FBTyxVQUFVLE1BQU0sMkJBQTJCLENBQUM7QUFFbkQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFVekQsTUFBTSxPQUFnQixxQkFFcEIsU0FBUSxpQkFBOEI7SUFDbkIsVUFBVSxDQUFhO0lBRWhDLE1BQU0sQ0FBaUI7SUFFakMsWUFBWSxNQUFNLEdBQUcsSUFBSSxXQUFXLEVBQUU7UUFDcEMsS0FBSyxFQUFFLENBQUM7UUFDUixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDO0lBc0JEOzs7OztPQUtHO0lBQ0gsbUJBQW1CLEdBQUcsS0FBSyxFQUN6QixHQUFrQixFQUNsQixLQUFZLEVBQ00sRUFBRTtRQUNwQixJQUFJLENBQUM7WUFDSCxNQUFNLEtBQUssR0FBeUIsRUFBRSxDQUFDO1lBQ3ZDLE1BQU0sVUFBVSxHQUFxQixFQUFFLENBQUM7WUFDeEMsS0FBSyxNQUFNLEVBQUUsSUFBSSxHQUFHLEVBQUUsQ0FBQztnQkFDckIsS0FBSyxNQUFNLE1BQU0sSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUM7b0JBQ2hDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7d0JBQzFCLFNBQVM7b0JBQ1gsQ0FBQztvQkFDRCxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxtQ0FBbUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUM7b0JBQ3JFLE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxjQUFjLENBQ3ZDLE1BQU0sRUFDTixLQUFLLENBQUMsSUFBSSxFQUNWLEtBQUssQ0FBQyxNQUFNLENBQ2IsQ0FBQztvQkFDRixJQUFJLGFBQWEsRUFBRSxDQUFDO3dCQUNsQixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FDZixrQkFBa0IsVUFBVSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsYUFDbkQsTUFBTSxDQUFDLEtBQ1QsRUFBRSxDQUNILENBQUM7d0JBQ0YsS0FBSyxDQUFDLElBQUksQ0FBQyxhQUE4QixDQUFDLENBQUM7b0JBQzdDLENBQUM7Z0JBQ0gsQ0FBQztnQkFDRCxJQUFJLFFBQVEsR0FBRyxDQUFDLENBQUM7Z0JBQ2pCLEtBQUssTUFBTSxLQUFLLElBQUksRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDO29CQUM5QixVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQyxFQUFFLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7b0JBQ3RFLFFBQVEsSUFBSSxDQUFDLENBQUM7Z0JBQ2hCLENBQUM7WUFDSCxDQUFDO1lBRUQsSUFBSSxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUM7Z0JBQUUsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUM7WUFDMUUsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxVQUFVLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO1FBQ2pFLENBQUM7UUFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ1gsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQ2YsNEJBQTRCLElBQUksQ0FBQyxLQUFLLEVBQUUsaUJBQWlCLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FDdkUsQ0FBQztZQUNGLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztRQUVELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQyxDQUFDO0lBRUY7OztPQUdHO0lBQ0gsU0FBUyxHQUFHLEtBQUssRUFBRSxJQUFZLEVBQWlCLEVBQUU7UUFDaEQsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztJQUMxRCxDQUFDLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGFTb3VyY2UgfSBmcm9tICd0eXBlb3JtJztcbmltcG9ydCB7IEFic3RyYWN0TG9nZ2VyLCBEdW1teUxvZ2dlciB9IGZyb20gJ0Byb3Nlbi1icmlkZ2UvYWJzdHJhY3QtbG9nZ2VyJztcbmltcG9ydCBKc29uQmlnSW50IGZyb20gJ0Byb3Nlbi1icmlkZ2UvanNvbi1iaWdpbnQnO1xuXG5pbXBvcnQgeyBBYnN0cmFjdEV4dHJhY3RvciB9IGZyb20gJy4uL0Fic3RyYWN0RXh0cmFjdG9yJztcbmltcG9ydCB7IEFic3RyYWN0RXJnb0V4dHJhY3RvckFjdGlvbiB9IGZyb20gJy4vQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uJztcbmltcG9ydCB7IEJsb2NrIH0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XG5pbXBvcnQge1xuICBUcmFuc2FjdGlvbixcbiAgT3V0cHV0Qm94LFxuICBFcmdvRXh0cmFjdGVkRGF0YSxcbiAgU3BlbmRJbmZvLFxufSBmcm9tICcuL2ludGVyZmFjZXMnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RFcmdvRXh0cmFjdG9yPFxuICBFeHRyYWN0ZWREYXRhIGV4dGVuZHMgRXJnb0V4dHJhY3RlZERhdGFcbj4gZXh0ZW5kcyBBYnN0cmFjdEV4dHJhY3RvcjxUcmFuc2FjdGlvbj4ge1xuICBwcm90ZWN0ZWQgcmVhZG9ubHkgZGF0YVNvdXJjZTogRGF0YVNvdXJjZTtcbiAgcHJvdGVjdGVkIGFic3RyYWN0IGFjdGlvbnM6IEFic3RyYWN0RXJnb0V4dHJhY3RvckFjdGlvbjxFeHRyYWN0ZWREYXRhPjtcbiAgcHJvdGVjdGVkIGxvZ2dlcjogQWJzdHJhY3RMb2dnZXI7XG5cbiAgY29uc3RydWN0b3IobG9nZ2VyID0gbmV3IER1bW15TG9nZ2VyKCkpIHtcbiAgICBzdXBlcigpO1xuICAgIHRoaXMubG9nZ2VyID0gbG9nZ2VyO1xuICB9XG5cbiAgLyoqXG4gICAqIGV4dHJhY3QgYm94IGRhdGEgdG8gcHJvcGVyIGZvcm1hdCAobm90IGluY2x1ZGluZyBzcGVuZGluZyBpbmZvcm1hdGlvbilcbiAgICogQHBhcmFtIGJveFxuICAgKiBAcGFyYW0gYmxvY2tJZCBib3ggaW5jbHVzaW9uIGJsb2NrIGhhc2hcbiAgICogQHBhcmFtIGhlaWdodCBib3ggaW5jbHVzaW9uIGJsb2NrIGhlaWdodFxuICAgKiBAcmV0dXJuIGV4dHJhY3RlZCBkYXRhIGluIHByb3BlciBmb3JtYXRcbiAgICovXG4gIGFic3RyYWN0IGV4dHJhY3RCb3hEYXRhOiAoXG4gICAgYm94OiBPdXRwdXRCb3gsXG4gICAgYmxvY2tJZDogc3RyaW5nLFxuICAgIGhlaWdodDogbnVtYmVyXG4gICkgPT4gT21pdDxFeHRyYWN0ZWREYXRhLCAnc3BlbmRCbG9jaycgfCAnc3BlbmRIZWlnaHQnPiB8IHVuZGVmaW5lZDtcblxuICAvKipcbiAgICogY2hlY2sgcHJvcGVyIGRhdGEgZm9ybWF0IGluIHRoZSBib3hcbiAgICogQHBhcmFtIGJveFxuICAgKiBAcmV0dXJuIHRydWUgaWYgdGhlIGJveCBoYXMgdGhlIHJlcXVpcmVkIGRhdGEgYW5kIGZhbHNlIG90aGVyd2lzZVxuICAgKi9cbiAgYWJzdHJhY3QgaGFzRGF0YTogKGJveDogT3V0cHV0Qm94KSA9PiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBwcm9jZXNzIGEgbGlzdCBvZiB0cmFuc2FjdGlvbnMgaW4gYSBibG9jayBhbmQgc3RvcmUgcmVxdWlyZWQgaW5mb3JtYXRpb25cbiAgICogQHBhcmFtIHR4cyBsaXN0IG9mIHRyYW5zYWN0aW9ucyBpbiB0aGUgYmxvY2tcbiAgICogQHBhcmFtIGJsb2NrXG4gICAqIEByZXR1cm4gdHJ1ZSBpZiB0aGUgcHJvY2VzcyBpcyBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5IGFuZCBmYWxzZSBvdGhlcndpc2VcbiAgICovXG4gIHByb2Nlc3NUcmFuc2FjdGlvbnMgPSBhc3luYyAoXG4gICAgdHhzOiBUcmFuc2FjdGlvbltdLFxuICAgIGJsb2NrOiBCbG9ja1xuICApOiBQcm9taXNlPGJvb2xlYW4+ID0+IHtcbiAgICB0cnkge1xuICAgICAgY29uc3QgYm94ZXM6IEFycmF5PEV4dHJhY3RlZERhdGE+ID0gW107XG4gICAgICBjb25zdCBzcGVudEluZm9zOiBBcnJheTxTcGVuZEluZm8+ID0gW107XG4gICAgICBmb3IgKGNvbnN0IHR4IG9mIHR4cykge1xuICAgICAgICBmb3IgKGNvbnN0IG91dHB1dCBvZiB0eC5vdXRwdXRzKSB7XG4gICAgICAgICAgaWYgKCF0aGlzLmhhc0RhdGEob3V0cHV0KSkge1xuICAgICAgICAgICAgY29udGludWU7XG4gICAgICAgICAgfVxuICAgICAgICAgIHRoaXMubG9nZ2VyLmRlYnVnKGBUcnlpbmcgdG8gZXh0cmFjdCBkYXRhIGZyb20gYm94ICR7b3V0cHV0LmJveElkfWApO1xuICAgICAgICAgIGNvbnN0IGV4dHJhY3RlZERhdGEgPSB0aGlzLmV4dHJhY3RCb3hEYXRhKFxuICAgICAgICAgICAgb3V0cHV0LFxuICAgICAgICAgICAgYmxvY2suaGFzaCxcbiAgICAgICAgICAgIGJsb2NrLmhlaWdodFxuICAgICAgICAgICk7XG4gICAgICAgICAgaWYgKGV4dHJhY3RlZERhdGEpIHtcbiAgICAgICAgICAgIHRoaXMubG9nZ2VyLmRlYnVnKFxuICAgICAgICAgICAgICBgRXh0cmFjdGVkIGRhdGEgJHtKc29uQmlnSW50LnN0cmluZ2lmeShleHRyYWN0ZWREYXRhKX0gZnJvbSBib3ggJHtcbiAgICAgICAgICAgICAgICBvdXRwdXQuYm94SWRcbiAgICAgICAgICAgICAgfWBcbiAgICAgICAgICAgICk7XG4gICAgICAgICAgICBib3hlcy5wdXNoKGV4dHJhY3RlZERhdGEgYXMgRXh0cmFjdGVkRGF0YSk7XG4gICAgICAgICAgfVxuICAgICAgICB9XG4gICAgICAgIGxldCBib3hJbmRleCA9IDE7XG4gICAgICAgIGZvciAoY29uc3QgaW5wdXQgb2YgdHguaW5wdXRzKSB7XG4gICAgICAgICAgc3BlbnRJbmZvcy5wdXNoKHsgdHhJZDogdHguaWQsIGJveElkOiBpbnB1dC5ib3hJZCwgaW5kZXg6IGJveEluZGV4IH0pO1xuICAgICAgICAgIGJveEluZGV4ICs9IDE7XG4gICAgICAgIH1cbiAgICAgIH1cblxuICAgICAgaWYgKGJveGVzLmxlbmd0aCA+IDApIGF3YWl0IHRoaXMuYWN0aW9ucy5pbnNlcnRCb3hlcyhib3hlcywgdGhpcy5nZXRJZCgpKTtcbiAgICAgIGF3YWl0IHRoaXMuYWN0aW9ucy5zcGVuZEJveGVzKHNwZW50SW5mb3MsIGJsb2NrLCB0aGlzLmdldElkKCkpO1xuICAgIH0gY2F0Y2ggKGUpIHtcbiAgICAgIHRoaXMubG9nZ2VyLmVycm9yKFxuICAgICAgICBgRXJyb3IgaW4gc3RvcmluZyBkYXRhIGluICR7dGhpcy5nZXRJZCgpfSBvZiB0aGUgYmxvY2sgJHtibG9ja306ICR7ZX1gXG4gICAgICApO1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cblxuICAgIHJldHVybiB0cnVlO1xuICB9O1xuXG4gIC8qKlxuICAgKiBmb3JrIG9uZSBibG9jayBhbmQgcmVtb3ZlIGFsbCBzdG9yZWQgaW5mb3JtYXRpb24gZm9yIHRoaXMgYmxvY2tcbiAgICogQHBhcmFtIGhhc2ggYmxvY2sgaGFzaFxuICAgKi9cbiAgZm9ya0Jsb2NrID0gYXN5bmMgKGhhc2g6IHN0cmluZyk6IFByb21pc2U8dm9pZD4gPT4ge1xuICAgIGF3YWl0IHRoaXMuYWN0aW9ucy5kZWxldGVCbG9ja0JveGVzKGhhc2gsIHRoaXMuZ2V0SWQoKSk7XG4gIH07XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ergo/AbstractErgoExtractorAction.d.ts

@@ -1,4 +1,4 @@
-import { Block } from '../interfaces';
+import { BlockInfo } from '../interfaces';
 import { SpendInfo } from './interfaces';
 export declare abstract class AbstractErgoExtractorAction<ExtractedData> {
     /**
@@ -14,7 +14,7 @@ export declare abstract class AbstractErgoExtractorAction<ExtractedData> {
      * @param block
      * @param extractorId
      */
-    abstract spendBoxes: (spendInfos: SpendInfo[], block: Block, extractorId: string) => Promise<void>;
+    abstract spendBoxes: (spendInfos: SpendInfo[], block: BlockInfo, extractorId: string) => Promise<void>;
     /**
      * delete extracted data from a specific block
      * if a box is spend in this block mark it as unspent

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractErgoExtractorAction.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,8BAAsB,2BAA2B,CAAC,aAAa;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,CACpB,IAAI,EAAE,aAAa,EAAE,EACrB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,CACnB,UAAU,EAAE,SAAS,EAAE,EACvB,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnB;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CACzB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB"}
+{"version":3,"file":"AbstractErgoExtractorAction.d.ts","sourceRoot":"","sources":["../../lib/ergo/AbstractErgoExtractorAction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,8BAAsB,2BAA2B,CAAC,aAAa;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,CACpB,IAAI,EAAE,aAAa,EAAE,EACrB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,CACnB,UAAU,EAAE,SAAS,EAAE,EACvB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnB;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CACzB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB"}

package/dist/ergo/AbstractErgoExtractorAction.js

@@ -1,3 +1,3 @@
 export class AbstractErgoExtractorAction {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2VyZ28vQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBZ0IsMkJBQTJCO0NBbUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJsb2NrIH0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XG5pbXBvcnQgeyBTcGVuZEluZm8gfSBmcm9tICcuL2ludGVyZmFjZXMnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uPEV4dHJhY3RlZERhdGE+IHtcbiAgLyoqXG4gICAqIGluc2VydCBhbGwgZXh0cmFjdGVkIGJveCBkYXRhIGluIGFuIGF0b21pYyB0cmFuc2FjdGlvblxuICAgKiBAcGFyYW0gZGF0YVxuICAgKiBAcGFyYW0gZXh0cmFjdG9ySWRcbiAgICogQHJldHVybiBwcm9jZXNzIHN1Y2Nlc3NcbiAgICovXG4gIGFic3RyYWN0IGluc2VydEJveGVzOiAoXG4gICAgZGF0YTogRXh0cmFjdGVkRGF0YVtdLFxuICAgIGV4dHJhY3RvcklkOiBzdHJpbmdcbiAgKSA9PiBQcm9taXNlPGJvb2xlYW4+O1xuXG4gIC8qKlxuICAgKiB1cGRhdGUgc3BlbmRpbmcgaW5mb3JtYXRpb24gb2Ygc3RvcmVkIGJveGVzXG4gICAqIEBwYXJhbSBzcGVuZEluZm9zXG4gICAqIEBwYXJhbSBibG9ja1xuICAgKiBAcGFyYW0gZXh0cmFjdG9ySWRcbiAgICovXG4gIGFic3RyYWN0IHNwZW5kQm94ZXM6IChcbiAgICBzcGVuZEluZm9zOiBTcGVuZEluZm9bXSxcbiAgICBibG9jazogQmxvY2ssXG4gICAgZXh0cmFjdG9ySWQ6IHN0cmluZ1xuICApID0+IFByb21pc2U8dm9pZD47XG5cbiAgLyoqXG4gICAqIGRlbGV0ZSBleHRyYWN0ZWQgZGF0YSBmcm9tIGEgc3BlY2lmaWMgYmxvY2tcbiAgICogaWYgYSBib3ggaXMgc3BlbmQgaW4gdGhpcyBibG9jayBtYXJrIGl0IGFzIHVuc3BlbnRcbiAgICogaWYgYSBib3ggaXMgY3JlYXRlZCBpbiB0aGlzIGJsb2NrIHJlbW92ZSBpdCBmcm9tIGRhdGFiYXNlXG4gICAqIEBwYXJhbSBibG9ja1xuICAgKiBAcGFyYW0gZXh0cmFjdG9ySWRcbiAgICovXG4gIGFic3RyYWN0IGRlbGV0ZUJsb2NrQm94ZXM6IChcbiAgICBibG9jazogc3RyaW5nLFxuICAgIGV4dHJhY3RvcklkOiBzdHJpbmdcbiAgKSA9PiBQcm9taXNlPHZvaWQ+O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbGliL2VyZ28vQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBZ0IsMkJBQTJCO0NBbUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJsb2NrSW5mbyB9IGZyb20gJy4uL2ludGVyZmFjZXMnO1xuaW1wb3J0IHsgU3BlbmRJbmZvIH0gZnJvbSAnLi9pbnRlcmZhY2VzJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFic3RyYWN0RXJnb0V4dHJhY3RvckFjdGlvbjxFeHRyYWN0ZWREYXRhPiB7XG4gIC8qKlxuICAgKiBpbnNlcnQgYWxsIGV4dHJhY3RlZCBib3ggZGF0YSBpbiBhbiBhdG9taWMgdHJhbnNhY3Rpb25cbiAgICogQHBhcmFtIGRhdGFcbiAgICogQHBhcmFtIGV4dHJhY3RvcklkXG4gICAqIEByZXR1cm4gcHJvY2VzcyBzdWNjZXNzXG4gICAqL1xuICBhYnN0cmFjdCBpbnNlcnRCb3hlczogKFxuICAgIGRhdGE6IEV4dHJhY3RlZERhdGFbXSxcbiAgICBleHRyYWN0b3JJZDogc3RyaW5nXG4gICkgPT4gUHJvbWlzZTxib29sZWFuPjtcblxuICAvKipcbiAgICogdXBkYXRlIHNwZW5kaW5nIGluZm9ybWF0aW9uIG9mIHN0b3JlZCBib3hlc1xuICAgKiBAcGFyYW0gc3BlbmRJbmZvc1xuICAgKiBAcGFyYW0gYmxvY2tcbiAgICogQHBhcmFtIGV4dHJhY3RvcklkXG4gICAqL1xuICBhYnN0cmFjdCBzcGVuZEJveGVzOiAoXG4gICAgc3BlbmRJbmZvczogU3BlbmRJbmZvW10sXG4gICAgYmxvY2s6IEJsb2NrSW5mbyxcbiAgICBleHRyYWN0b3JJZDogc3RyaW5nXG4gICkgPT4gUHJvbWlzZTx2b2lkPjtcblxuICAvKipcbiAgICogZGVsZXRlIGV4dHJhY3RlZCBkYXRhIGZyb20gYSBzcGVjaWZpYyBibG9ja1xuICAgKiBpZiBhIGJveCBpcyBzcGVuZCBpbiB0aGlzIGJsb2NrIG1hcmsgaXQgYXMgdW5zcGVudFxuICAgKiBpZiBhIGJveCBpcyBjcmVhdGVkIGluIHRoaXMgYmxvY2sgcmVtb3ZlIGl0IGZyb20gZGF0YWJhc2VcbiAgICogQHBhcmFtIGJsb2NrXG4gICAqIEBwYXJhbSBleHRyYWN0b3JJZFxuICAgKi9cbiAgYWJzdHJhY3QgZGVsZXRlQmxvY2tCb3hlczogKFxuICAgIGJsb2NrOiBzdHJpbmcsXG4gICAgZXh0cmFjdG9ySWQ6IHN0cmluZ1xuICApID0+IFByb21pc2U8dm9pZD47XG59XG4iXX0=

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

@@ -1,42 +1,41 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
-import { ErgoBox, ErgoExtractedData } from '../interfaces';
+import { ErgoExtractedData, ErgoNetworkType } from '../interfaces';
 import { AbstractErgoExtractor } from '../AbstractErgoExtractor';
 import { AbstractInitializableErgoExtractorAction } from './AbstractInitializableAction';
 import { BlockInfo } from '../../interfaces';
 export declare abstract class AbstractInitializableErgoExtractor<ExtractedData extends ErgoExtractedData> extends AbstractErgoExtractor<ExtractedData> {
     protected initialize: boolean;
+    private address;
     protected abstract actions: AbstractInitializableErgoExtractorAction<ExtractedData>;
+    private network;
+    constructor(type: ErgoNetworkType, url: string, address: string, logger?: AbstractLogger, initialize?: boolean);
     /**
-     * create an initializable ergo extractor
-     * @param initialize ignore the initialization step if its false
-     * @param logger
+     * Initialize extractor using Explorer network
+     * @param initialBlock
+     */
+    private initializeWithExplorer;
+    /**
+     * Get the total tx count from Node network
+     * @returns total tx count of the address
      */
-    constructor(initialize?: boolean, logger?: AbstractLogger);
+    private getTotalTxCount;
     /**
-     * return init required boxes with offset limit
-     * @param offset
-     * @param limit
-     * @return boxes in batch
+     * Initialize extractor using Node network
+     * @param initialBlock
      */
-    abstract getBoxesWithOffsetLimit: (offset: number, limit: number) => Promise<{
-        boxes: ErgoBox[];
-        hasNextBatch: boolean;
-    }>;
+    private initializeWithNode;
     /**
-     * return block information of specified tx
-     * @param txId
-     * @return block info
+     * Process a batch of transactions
+     * group txs into blocks and process them using `processTransactions`
+     * @param txs
      */
-    abstract getTxBlock: (txId: string) => Promise<BlockInfo>;
+    private processTransactionBatch;
     /**
-     * return all related data below the initial height (including the init height)
-     * @param initialHeight
-     * @return extracted data in batch
+     * Initialize the extractor with retrial on any unexpected problem
+     * its the common part of initialize with Node and Explorer network
+     * @param job
      */
-    fetchDataWithOffsetLimit: (initialHeight: number, offset: number, limit: number) => Promise<{
-        extractedBoxes: Array<ExtractedData>;
-        hasNextBatch: boolean;
-    }>;
+    private initWithRetrial;
     /**
      * initialize extractor database with data created below the initial height
      * ignore initialization if this feature is off

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractInitializable.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,8BAAsB,kCAAkC,CACtD,aAAa,SAAS,iBAAiB,CACvC,SAAQ,qBAAqB,CAAC,aAAa,CAAC;IAC5C,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC;IAC9B,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wCAAwC,CAAC,aAAa,CAAC,CAAC;IAEpF;;;;OAIG;gBACS,UAAU,UAAO,EAAE,MAAM,CAAC,EAAE,cAAc;IAKtD;;;;;OAKG;IACH,QAAQ,CAAC,uBAAuB,EAAE,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,KACV,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAE1D;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IAE1D;;;;OAIG;IACH,wBAAwB,kBACP,MAAM,UACb,MAAM,SACP,MAAM,KACZ,QAAQ;QACT,cAAc,EAAE,MAAM,aAAa,CAAC,CAAC;QACrC,YAAY,EAAE,OAAO,CAAC;KACvB,CAAC,CA+BA;IAEF;;;;;OAKG;IACH,eAAe,iBAAwB,SAAS,mBA+C9C;CACH"}
+{"version":3,"file":"AbstractInitializable.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,iBAAiB,EACjB,eAAe,EAEhB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,wCAAwC,EAAE,MAAM,+BAA+B,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C,8BAAsB,kCAAkC,CACtD,aAAa,SAAS,iBAAiB,CACvC,SAAQ,qBAAqB,CAAC,aAAa,CAAC;IAC5C,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,OAAO,CAAS;IACxB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wCAAwC,CAAC,aAAa,CAAC,CAAC;IAEpF,OAAO,CAAC,OAAO,CAAgC;gBAG7C,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,UAAO;IAkBnB;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CA6C5B;IAEF;;;OAGG;IACH,OAAO,CAAC,eAAe,CAKrB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAoCxB;IAEF;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CAgB7B;IAEF;;;;OAIG;IACH,OAAO,CAAC,eAAe,CA+BrB;IAEF;;;;;OAKG;IACH,eAAe,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D"}

package/dist/ergo/initializable/AbstractInitializable.js

@@ -1,65 +1,138 @@
-import JsonBigInt from '@rosen-bridge/json-bigint';
+import { ErgoNetworkType, } from '../interfaces';
 import { API_LIMIT, RETRIAL_COUNT } from '../../constants';
 import { AbstractErgoExtractor } from '../AbstractErgoExtractor';
+import { ExplorerNetwork } from '../network/ExplorerNetwork';
+import { NodeNetwork } from '../network/NodeNetwork';
+import { groupBy, sortBy } from 'lodash-es';
 export class AbstractInitializableErgoExtractor extends AbstractErgoExtractor {
     initialize;
-    /**
-     * create an initializable ergo extractor
-     * @param initialize ignore the initialization step if its false
-     * @param logger
-     */
-    constructor(initialize = true, logger) {
+    address;
+    network;
+    constructor(type, url, address, logger, initialize = true) {
         super(logger);
+        this.address = address;
         this.initialize = initialize;
+        if (type == ErgoNetworkType.Explorer) {
+            this.network = new ExplorerNetwork(url);
+            this.initializeBoxes = (initialBlock) => {
+                return this.initializeWithExplorer(initialBlock);
+            };
+        }
+        else if (type == ErgoNetworkType.Node) {
+            this.network = new NodeNetwork(url);
+            this.initializeBoxes = (initialBlock) => {
+                return this.initializeWithNode(initialBlock);
+            };
+        }
+        else
+            throw new Error(`Network type ${type} is not supported`);
     }
     /**
-     * return all related data below the initial height (including the init height)
-     * @param initialHeight
-     * @return extracted data in batch
+     * Initialize extractor using Explorer network
+     * @param initialBlock
      */
-    fetchDataWithOffsetLimit = async (initialHeight, offset, limit) => {
-        const extractedBoxes = [];
-        const apiOutput = await this.getBoxesWithOffsetLimit(offset, limit);
-        const filteredBoxes = apiOutput.boxes.filter((box) => box.inclusionHeight <= initialHeight && this.hasData(box));
-        for (const box of filteredBoxes) {
-            const data = this.extractBoxData(box, box.blockId, box.inclusionHeight);
-            if (!data)
-                continue;
-            const spent = box.spentHeight && box.spentHeight <= initialHeight;
-            if (spent)
-                this.logger.debug(`Box with id ${box.boxId} spent at block ${JsonBigInt.stringify(box.blockId)} bellow the initial height`);
-            const extractedData = {
-                ...data,
-                spendBlock: spent ? box.spentBlockId : undefined,
-                spendHeight: spent ? box.spentHeight : undefined,
-            };
-            this.logger.debug(`Extracted data ${JsonBigInt.stringify(extractedData)} from box ${box.boxId} in initialization phase`);
-            extractedBoxes.push(extractedData);
-        }
-        return { extractedBoxes, hasNextBatch: apiOutput.hasNextBatch };
+    initializeWithExplorer = async (initialBlock) => {
+        const explorerNetwork = this.network;
+        let fromHeight = 0, toHeight = initialBlock.height;
+        await this.initWithRetrial(async () => {
+            while (fromHeight < toHeight) {
+                let txs;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    txs = await explorerNetwork.getAddressTransactionsWithHeight(this.address, fromHeight, toHeight);
+                    this.logger.debug(`Found ${txs.length} transactions for the address from height ${fromHeight} to height ${toHeight}`);
+                    if (txs.length < API_LIMIT || fromHeight === toHeight) {
+                        break; // Exit loop if we have fewer transactions than the limit or if the range is reduced to a single height
+                    }
+                    toHeight = Math.floor((toHeight - fromHeight) / 2) + fromHeight;
+                    this.logger.debug(`Limiting the query height range to [${fromHeight}, ${toHeight}]`);
+                }
+                if (txs.length < API_LIMIT) {
+                    if (txs.length > 0)
+                        await this.processTransactionBatch(txs);
+                }
+                else {
+                    this.logger.debug(`Block at height ${fromHeight} has more than (or equal) ${API_LIMIT} relevant txs, processing all txs in the block`);
+                    const blockId = await explorerNetwork.getBlockIdAtHeight(fromHeight);
+                    const blockTxs = await explorerNetwork.getBlockTxs(blockId);
+                    this.logger.debug(`Found ${blockTxs.length} transactions at height ${fromHeight}`);
+                    await this.processTransactions(blockTxs, {
+                        hash: blockId,
+                        height: fromHeight,
+                    });
+                }
+                fromHeight = toHeight + 1;
+                toHeight = initialBlock.height;
+            }
+        });
     };
     /**
-     * initialize extractor database with data created below the initial height
-     * ignore initialization if this feature is off
-     * try to get data multiple times to pass accidental network problems
+     * Get the total tx count from Node network
+     * @returns total tx count of the address
+     */
+    getTotalTxCount = async () => {
+        const response = await this.network.getAddressTransactionsWithOffsetLimit(this.address, 0, 0);
+        return response.total;
+    };
+    /**
+     * Initialize extractor using Node network
      * @param initialBlock
      */
-    initializeBoxes = async (initialBlock) => {
+    initializeWithNode = async (initialBlock) => {
+        const txCountBeforeInit = await this.getTotalTxCount();
+        await this.initWithRetrial(async () => {
+            // Repeat the whole process twice to cover all spent boxes
+            // After round 1 all boxes have been saved and processed once
+            // After round 2 spending information of all stored boxes are updated successfully
+            for (let round = 0; round <= 1; round++) {
+                this.logger.debug(`Starting round ${round} of initialization`);
+                let offset = 0, total = 1;
+                while (offset < total) {
+                    const response = await this.network.getAddressTransactionsWithOffsetLimit(this.address, offset, API_LIMIT);
+                    total = response.total;
+                    const txs = response.items.filter((tx) => tx.inclusionHeight <= initialBlock.height);
+                    this.logger.debug(`Found ${txs.length} transactions below the initial height with offset ${offset} and total number of transactions ${total}`);
+                    if (txs.length > 0)
+                        await this.processTransactionBatch(txs);
+                    offset += API_LIMIT;
+                }
+            }
+        });
+        const txCountAfterInit = await this.getTotalTxCount();
+        if (txCountAfterInit != txCountBeforeInit) {
+            throw Error('Total transaction count changed during initialization phase, the stored data is not valid');
+        }
+    };
+    /**
+     * Process a batch of transactions
+     * group txs into blocks and process them using `processTransactions`
+     * @param txs
+     */
+    processTransactionBatch = async (txs) => {
+        txs = sortBy(txs, (tx) => tx.inclusionHeight);
+        const groupedTxs = groupBy(txs, (tx) => tx.blockId);
+        this.logger.debug(`The transaction batch grouped to ${Object.keys(groupedTxs).length} blocks`);
+        for (const blockId in groupedTxs) {
+            const blockTxs = groupedTxs[blockId];
+            const block = { hash: blockId, height: blockTxs[0].inclusionHeight };
+            this.logger.debug(`Processing transactions at height ${blockTxs[0].inclusionHeight}`);
+            await this.processTransactions(blockTxs, block);
+        }
+    };
+    /**
+     * Initialize the extractor with retrial on any unexpected problem
+     * its the common part of initialize with Node and Explorer network
+     * @param job
+     */
+    initWithRetrial = async (job) => {
         let trial = 1;
         if (this.initialize) {
             this.logger.debug(`Initializing ${this.getId()} started, removing all existing data`);
             await this.actions.removeAllData(this.getId());
-            let hasNextBatch = true;
-            let offset = 0;
-            while (hasNextBatch) {
+            while (trial <= RETRIAL_COUNT) {
                 try {
-                    const data = await this.fetchDataWithOffsetLimit(initialBlock.height, offset, API_LIMIT);
-                    this.logger.info(`Inserting ${data.extractedBoxes.length} new extracted data in ${this.getId()} initialization`);
-                    const insertSuccess = await this.actions.insertBoxes(data.extractedBoxes, this.getId());
-                    if (!insertSuccess)
-                        throw new Error('Could not store extracted data');
-                    hasNextBatch = data.hasNextBatch;
-                    offset += API_LIMIT;
+                    await job();
+                    break;
                 }
                 catch (e) {
                     this.logger.warn(`Initialization for ${this.getId()} failed with error :${e}`);
@@ -69,10 +142,18 @@ export class AbstractInitializableErgoExtractor extends AbstractErgoExtractor {
                     this.logger.info(`Trying again to initialize ${this.getId()} with trial step ${trial}`);
                 }
             }
+            this.logger.info(`Initialization completed successfully for ${this.getId()}`);
         }
         else {
             this.logger.info(`Initialization for ${this.getId()} is turned off`);
         }
     };
+    /**
+     * initialize extractor database with data created below the initial height
+     * ignore initialization if this feature is off
+     * try to get data multiple times to pass accidental network problems
+     * @param initialBlock
+     */
+    initializeBoxes;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractInitializable.js","sourceRoot":"","sources":["../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\n\nimport { ErgoBox, ErgoExtractedData } from '../interfaces';\nimport { API_LIMIT, RETRIAL_COUNT } from '../../constants';\nimport { AbstractErgoExtractor } from '../AbstractErgoExtractor';\nimport { AbstractInitializableErgoExtractorAction } from './AbstractInitializableAction';\nimport { BlockInfo } from '../../interfaces';\n\nexport abstract class AbstractInitializableErgoExtractor<\n  ExtractedData extends ErgoExtractedData\n> extends AbstractErgoExtractor<ExtractedData> {\n  protected initialize: boolean;\n  protected abstract actions: AbstractInitializableErgoExtractorAction<ExtractedData>;\n\n  /**\n   * create an initializable ergo extractor\n   * @param initialize ignore the initialization step if its false\n   * @param logger\n   */\n  constructor(initialize = true, logger?: AbstractLogger) {\n    super(logger);\n    this.initialize = initialize;\n  }\n\n  /**\n   * return init required boxes with offset limit\n   * @param offset\n   * @param limit\n   * @return boxes in batch\n   */\n  abstract getBoxesWithOffsetLimit: (\n    offset: number,\n    limit: number\n  ) => Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }>;\n\n  /**\n   * return block information of specified tx\n   * @param txId\n   * @return block info\n   */\n  abstract getTxBlock: (txId: string) => Promise<BlockInfo>;\n\n  /**\n   * return all related data below the initial height (including the init height)\n   * @param initialHeight\n   * @return extracted data in batch\n   */\n  fetchDataWithOffsetLimit = async (\n    initialHeight: number,\n    offset: number,\n    limit: number\n  ): Promise<{\n    extractedBoxes: Array<ExtractedData>;\n    hasNextBatch: boolean;\n  }> => {\n    const extractedBoxes: Array<ExtractedData> = [];\n    const apiOutput = await this.getBoxesWithOffsetLimit(offset, limit);\n\n    const filteredBoxes = apiOutput.boxes.filter(\n      (box: ErgoBox) =>\n        box.inclusionHeight <= initialHeight && this.hasData(box)\n    );\n    for (const box of filteredBoxes) {\n      const data = this.extractBoxData(box, box.blockId, box.inclusionHeight);\n      if (!data) continue;\n      const spent = box.spentHeight && box.spentHeight <= initialHeight;\n      if (spent)\n        this.logger.debug(\n          `Box with id ${box.boxId} spent at block ${JsonBigInt.stringify(\n            box.blockId\n          )} bellow the initial height`\n        );\n      const extractedData = {\n        ...data,\n        spendBlock: spent ? box.spentBlockId : undefined,\n        spendHeight: spent ? box.spentHeight : undefined,\n      } as ExtractedData;\n      this.logger.debug(\n        `Extracted data ${JsonBigInt.stringify(extractedData)} from box ${\n          box.boxId\n        } in initialization phase`\n      );\n      extractedBoxes.push(extractedData);\n    }\n    return { extractedBoxes, hasNextBatch: apiOutput.hasNextBatch };\n  };\n\n  /**\n   * initialize extractor database with data created below the initial height\n   * ignore initialization if this feature is off\n   * try to get data multiple times to pass accidental network problems\n   * @param initialBlock\n   */\n  initializeBoxes = async (initialBlock: BlockInfo) => {\n    let trial = 1;\n    if (this.initialize) {\n      this.logger.debug(\n        `Initializing ${this.getId()} started, removing all existing data`\n      );\n      await this.actions.removeAllData(this.getId());\n\n      let hasNextBatch = true;\n      let offset = 0;\n      while (hasNextBatch) {\n        try {\n          const data = await this.fetchDataWithOffsetLimit(\n            initialBlock.height,\n            offset,\n            API_LIMIT\n          );\n          this.logger.info(\n            `Inserting ${\n              data.extractedBoxes.length\n            } new extracted data in ${this.getId()} initialization`\n          );\n          const insertSuccess = await this.actions.insertBoxes(\n            data.extractedBoxes,\n            this.getId()\n          );\n          if (!insertSuccess) throw new Error('Could not store extracted data');\n\n          hasNextBatch = data.hasNextBatch;\n          offset += API_LIMIT;\n        } catch (e) {\n          this.logger.warn(\n            `Initialization for ${this.getId()} failed with error :${e}`\n          );\n          if (trial == RETRIAL_COUNT)\n            throw Error(\n              `Initialization for ${this.getId()} failed after ${RETRIAL_COUNT} retrial`\n            );\n          trial += 1;\n          this.logger.info(\n            `Trying again to initialize ${this.getId()} with trial step ${trial}`\n          );\n        }\n      }\n    } else {\n      this.logger.info(`Initialization for ${this.getId()} is turned off`);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractInitializable.js","sourceRoot":"","sources":["../../../lib/ergo/initializable/AbstractInitializable.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,eAAe,GAEhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,OAAgB,kCAEpB,SAAQ,qBAAoC;IAClC,UAAU,CAAU;IACtB,OAAO,CAAS;IAGhB,OAAO,CAAgC;IAE/C,YACE,IAAqB,EACrB,GAAW,EACX,OAAe,EACf,MAAuB,EACvB,UAAU,GAAG,IAAI;QAEjB,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,IAAI,IAAI,eAAe,CAAC,QAAQ,EAAE,CAAC;YACrC,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC,CAAC;YACxC,IAAI,CAAC,eAAe,GAAG,CAAC,YAAuB,EAAE,EAAE;gBACjD,OAAO,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;YACnD,CAAC,CAAC;QACJ,CAAC;aAAM,IAAI,IAAI,IAAI,eAAe,CAAC,IAAI,EAAE,CAAC;YACxC,IAAI,CAAC,OAAO,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;YACpC,IAAI,CAAC,eAAe,GAAG,CAAC,YAAuB,EAAE,EAAE;gBACjD,OAAO,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;YAC/C,CAAC,CAAC;QACJ,CAAC;;YAAM,MAAM,IAAI,KAAK,CAAC,gBAAgB,IAAI,mBAAmB,CAAC,CAAC;IAClE,CAAC;IAED;;;OAGG;IACK,sBAAsB,GAAG,KAAK,EAAE,YAAuB,EAAE,EAAE;QACjE,MAAM,eAAe,GAAG,IAAI,CAAC,OAA0B,CAAC;QACxD,IAAI,UAAU,GAAG,CAAC,EAChB,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC;QACjC,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE;YACpC,OAAO,UAAU,GAAG,QAAQ,EAAE,CAAC;gBAC7B,IAAI,GAA+B,CAAC;gBACpC,iDAAiD;gBACjD,OAAO,IAAI,EAAE,CAAC;oBACZ,GAAG,GAAG,MAAM,eAAe,CAAC,gCAAgC,CAC1D,IAAI,CAAC,OAAO,EACZ,UAAU,EACV,QAAQ,CACT,CAAC;oBACF,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,GAAG,CAAC,MAAM,6CAA6C,UAAU,cAAc,QAAQ,EAAE,CACnG,CAAC;oBACF,IAAI,GAAG,CAAC,MAAM,GAAG,SAAS,IAAI,UAAU,KAAK,QAAQ,EAAE,CAAC;wBACtD,MAAM,CAAC,uGAAuG;oBAChH,CAAC;oBACD,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;oBAChE,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,uCAAuC,UAAU,KAAK,QAAQ,GAAG,CAClE,CAAC;gBACJ,CAAC;gBACD,IAAI,GAAG,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;oBAC3B,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;wBAAE,MAAM,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC;gBAC9D,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,mBAAmB,UAAU,6BAA6B,SAAS,gDAAgD,CACpH,CAAC;oBACF,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;oBACrE,MAAM,QAAQ,GAAG,MAAM,eAAe,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;oBAC5D,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,QAAQ,CAAC,MAAM,2BAA2B,UAAU,EAAE,CAChE,CAAC;oBACF,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE;wBACvC,IAAI,EAAE,OAAO;wBACb,MAAM,EAAE,UAAU;qBACnB,CAAC,CAAC;gBACL,CAAC;gBACD,UAAU,GAAG,QAAQ,GAAG,CAAC,CAAC;gBAC1B,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC;YACjC,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF;;;OAGG;IACK,eAAe,GAAG,KAAK,IAAI,EAAE;QACnC,MAAM,QAAQ,GAAG,MACf,IAAI,CAAC,OACN,CAAC,qCAAqC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5D,OAAO,QAAQ,CAAC,KAAK,CAAC;IACxB,CAAC,CAAC;IAEF;;;OAGG;IACK,kBAAkB,GAAG,KAAK,EAAE,YAAuB,EAAE,EAAE;QAC7D,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QACvD,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE;YACpC,0DAA0D;YAC1D,6DAA6D;YAC7D,kFAAkF;YAClF,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;gBACxC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kBAAkB,KAAK,oBAAoB,CAAC,CAAC;gBAC/D,IAAI,MAAM,GAAG,CAAC,EACZ,KAAK,GAAG,CAAC,CAAC;gBACZ,OAAO,MAAM,GAAG,KAAK,EAAE,CAAC;oBACtB,MAAM,QAAQ,GAAG,MACf,IAAI,CAAC,OACN,CAAC,qCAAqC,CACrC,IAAI,CAAC,OAAO,EACZ,MAAM,EACN,SAAS,CACV,CAAC;oBACF,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;oBACvB,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAC/B,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,eAAe,IAAI,YAAY,CAAC,MAAM,CAClD,CAAC;oBACF,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,SAAS,GAAG,CAAC,MAAM,sDAAsD,MAAM,qCAAqC,KAAK,EAAE,CAC5H,CAAC;oBACF,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;wBAAE,MAAM,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC;oBAC5D,MAAM,IAAI,SAAS,CAAC;gBACtB,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QACH,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QACtD,IAAI,gBAAgB,IAAI,iBAAiB,EAAE,CAAC;YAC1C,MAAM,KAAK,CACT,2FAA2F,CAC5F,CAAC;QACJ,CAAC;IACH,CAAC,CAAC;IAEF;;;;OAIG;IACK,uBAAuB,GAAG,KAAK,EAAE,GAA+B,EAAE,EAAE;QAC1E,GAAG,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC;QAC9C,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,oCACE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAC1B,SAAS,CACV,CAAC;QACF,KAAK,MAAM,OAAO,IAAI,UAAU,EAAE,CAAC;YACjC,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;YACrC,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC;YACrE,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,qCAAqC,QAAQ,CAAC,CAAC,CAAC,CAAC,eAAe,EAAE,CACnE,CAAC;YACF,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC,CAAC;IAEF;;;;OAIG;IACK,eAAe,GAAG,KAAK,EAAE,GAAwB,EAAE,EAAE;QAC3D,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,gBAAgB,IAAI,CAAC,KAAK,EAAE,sCAAsC,CACnE,CAAC;YACF,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;YAC/C,OAAO,KAAK,IAAI,aAAa,EAAE,CAAC;gBAC9B,IAAI,CAAC;oBACH,MAAM,GAAG,EAAE,CAAC;oBACZ,MAAM;gBACR,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,sBAAsB,IAAI,CAAC,KAAK,EAAE,uBAAuB,CAAC,EAAE,CAC7D,CAAC;oBACF,IAAI,KAAK,IAAI,aAAa;wBACxB,MAAM,KAAK,CACT,sBAAsB,IAAI,CAAC,KAAK,EAAE,iBAAiB,aAAa,UAAU,CAC3E,CAAC;oBACJ,KAAK,IAAI,CAAC,CAAC;oBACX,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,8BAA8B,IAAI,CAAC,KAAK,EAAE,oBAAoB,KAAK,EAAE,CACtE,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,6CAA6C,IAAI,CAAC,KAAK,EAAE,EAAE,CAC5D,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,IAAI,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;QACvE,CAAC;IACH,CAAC,CAAC;IAEF;;;;;OAKG;IACH,eAAe,CAA6C;CAC7D","sourcesContent":["import { AbstractLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  ErgoExtractedData,\n  ErgoNetworkType,\n  ExtendedTransaction,\n} from '../interfaces';\nimport { API_LIMIT, RETRIAL_COUNT } from '../../constants';\nimport { AbstractErgoExtractor } from '../AbstractErgoExtractor';\nimport { AbstractInitializableErgoExtractorAction } from './AbstractInitializableAction';\nimport { BlockInfo } from '../../interfaces';\nimport { ExplorerNetwork } from '../network/ExplorerNetwork';\nimport { NodeNetwork } from '../network/NodeNetwork';\nimport { groupBy, sortBy } from 'lodash-es';\n\nexport abstract class AbstractInitializableErgoExtractor<\n  ExtractedData extends ErgoExtractedData\n> extends AbstractErgoExtractor<ExtractedData> {\n  protected initialize: boolean;\n  private address: string;\n  protected abstract actions: AbstractInitializableErgoExtractorAction<ExtractedData>;\n\n  private network: ExplorerNetwork | NodeNetwork;\n\n  constructor(\n    type: ErgoNetworkType,\n    url: string,\n    address: string,\n    logger?: AbstractLogger,\n    initialize = true\n  ) {\n    super(logger);\n    this.address = address;\n    this.initialize = initialize;\n    if (type == ErgoNetworkType.Explorer) {\n      this.network = new ExplorerNetwork(url);\n      this.initializeBoxes = (initialBlock: BlockInfo) => {\n        return this.initializeWithExplorer(initialBlock);\n      };\n    } else if (type == ErgoNetworkType.Node) {\n      this.network = new NodeNetwork(url);\n      this.initializeBoxes = (initialBlock: BlockInfo) => {\n        return this.initializeWithNode(initialBlock);\n      };\n    } else throw new Error(`Network type ${type} is not supported`);\n  }\n\n  /**\n   * Initialize extractor using Explorer network\n   * @param initialBlock\n   */\n  private initializeWithExplorer = async (initialBlock: BlockInfo) => {\n    const explorerNetwork = this.network as ExplorerNetwork;\n    let fromHeight = 0,\n      toHeight = initialBlock.height;\n    await this.initWithRetrial(async () => {\n      while (fromHeight < toHeight) {\n        let txs: Array<ExtendedTransaction>;\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n          txs = await explorerNetwork.getAddressTransactionsWithHeight(\n            this.address,\n            fromHeight,\n            toHeight\n          );\n          this.logger.debug(\n            `Found ${txs.length} transactions for the address from height ${fromHeight} to height ${toHeight}`\n          );\n          if (txs.length < API_LIMIT || fromHeight === toHeight) {\n            break; // Exit loop if we have fewer transactions than the limit or if the range is reduced to a single height\n          }\n          toHeight = Math.floor((toHeight - fromHeight) / 2) + fromHeight;\n          this.logger.debug(\n            `Limiting the query height range to [${fromHeight}, ${toHeight}]`\n          );\n        }\n        if (txs.length < API_LIMIT) {\n          if (txs.length > 0) await this.processTransactionBatch(txs);\n        } else {\n          this.logger.debug(\n            `Block at height ${fromHeight} has more than (or equal) ${API_LIMIT} relevant txs, processing all txs in the block`\n          );\n          const blockId = await explorerNetwork.getBlockIdAtHeight(fromHeight);\n          const blockTxs = await explorerNetwork.getBlockTxs(blockId);\n          this.logger.debug(\n            `Found ${blockTxs.length} transactions at height ${fromHeight}`\n          );\n          await this.processTransactions(blockTxs, {\n            hash: blockId,\n            height: fromHeight,\n          });\n        }\n        fromHeight = toHeight + 1;\n        toHeight = initialBlock.height;\n      }\n    });\n  };\n\n  /**\n   * Get the total tx count from Node network\n   * @returns total tx count of the address\n   */\n  private getTotalTxCount = async () => {\n    const response = await (\n      this.network as NodeNetwork\n    ).getAddressTransactionsWithOffsetLimit(this.address, 0, 0);\n    return response.total;\n  };\n\n  /**\n   * Initialize extractor using Node network\n   * @param initialBlock\n   */\n  private initializeWithNode = async (initialBlock: BlockInfo) => {\n    const txCountBeforeInit = await this.getTotalTxCount();\n    await this.initWithRetrial(async () => {\n      // Repeat the whole process twice to cover all spent boxes\n      // After round 1 all boxes have been saved and processed once\n      // After round 2 spending information of all stored boxes are updated successfully\n      for (let round = 0; round <= 1; round++) {\n        this.logger.debug(`Starting round ${round} of initialization`);\n        let offset = 0,\n          total = 1;\n        while (offset < total) {\n          const response = await (\n            this.network as NodeNetwork\n          ).getAddressTransactionsWithOffsetLimit(\n            this.address,\n            offset,\n            API_LIMIT\n          );\n          total = response.total;\n          const txs = response.items.filter(\n            (tx) => tx.inclusionHeight <= initialBlock.height\n          );\n          this.logger.debug(\n            `Found ${txs.length} transactions below the initial height with offset ${offset} and total number of transactions ${total}`\n          );\n          if (txs.length > 0) await this.processTransactionBatch(txs);\n          offset += API_LIMIT;\n        }\n      }\n    });\n    const txCountAfterInit = await this.getTotalTxCount();\n    if (txCountAfterInit != txCountBeforeInit) {\n      throw Error(\n        'Total transaction count changed during initialization phase, the stored data is not valid'\n      );\n    }\n  };\n\n  /**\n   * Process a batch of transactions\n   * group txs into blocks and process them using `processTransactions`\n   * @param txs\n   */\n  private processTransactionBatch = async (txs: Array<ExtendedTransaction>) => {\n    txs = sortBy(txs, (tx) => tx.inclusionHeight);\n    const groupedTxs = groupBy(txs, (tx) => tx.blockId);\n    this.logger.debug(\n      `The transaction batch grouped to ${\n        Object.keys(groupedTxs).length\n      } blocks`\n    );\n    for (const blockId in groupedTxs) {\n      const blockTxs = groupedTxs[blockId];\n      const block = { hash: blockId, height: blockTxs[0].inclusionHeight };\n      this.logger.debug(\n        `Processing transactions at height ${blockTxs[0].inclusionHeight}`\n      );\n      await this.processTransactions(blockTxs, block);\n    }\n  };\n\n  /**\n   * Initialize the extractor with retrial on any unexpected problem\n   * its the common part of initialize with Node and Explorer network\n   * @param job\n   */\n  private initWithRetrial = async (job: () => Promise<void>) => {\n    let trial = 1;\n    if (this.initialize) {\n      this.logger.debug(\n        `Initializing ${this.getId()} started, removing all existing data`\n      );\n      await this.actions.removeAllData(this.getId());\n      while (trial <= RETRIAL_COUNT) {\n        try {\n          await job();\n          break;\n        } catch (e) {\n          this.logger.warn(\n            `Initialization for ${this.getId()} failed with error :${e}`\n          );\n          if (trial == RETRIAL_COUNT)\n            throw Error(\n              `Initialization for ${this.getId()} failed after ${RETRIAL_COUNT} retrial`\n            );\n          trial += 1;\n          this.logger.info(\n            `Trying again to initialize ${this.getId()} with trial step ${trial}`\n          );\n        }\n      }\n      this.logger.info(\n        `Initialization completed successfully for ${this.getId()}`\n      );\n    } else {\n      this.logger.info(`Initialization for ${this.getId()} is turned off`);\n    }\n  };\n\n  /**\n   * initialize extractor database with data created below the initial height\n   * ignore initialization if this feature is off\n   * try to get data multiple times to pass accidental network problems\n   * @param initialBlock\n   */\n  initializeBoxes: (initialBlock: BlockInfo) => Promise<void>;\n}\n"]}

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

@@ -1,7 +1,6 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { ErgoExtractedData, ErgoNetworkType, ErgoBox } from '../interfaces';
 import { AbstractInitializableErgoExtractor } from './AbstractInitializable';
-import { BlockInfo } from '../../interfaces';
 export declare abstract class AbstractInitializableByAddressErgoExtractor<ExtractedData extends ErgoExtractedData> extends AbstractInitializableErgoExtractor<ExtractedData> {
     private address;
     private network;
@@ -16,11 +15,5 @@ export declare abstract class AbstractInitializableByAddressErgoExtractor<Extrac
         boxes: ErgoBox[];
         hasNextBatch: boolean;
     }>;
-    /**
-     * return block information from the specified network source
-     * @param txId
-     * @return block info
-     */
-    getTxBlock: (txId: string) => Promise<BlockInfo>;
 }
 //# sourceMappingURL=InitializableByAddress.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"InitializableByAddress.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/InitializableByAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C,8BAAsB,2CAA2C,CAC/D,aAAa,SAAS,iBAAiB,CACvC,SAAQ,kCAAkC,CAAC,aAAa,CAAC;IACzD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAkB;gBAG/B,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,cAAc;IAWzB;;;;;OAKG;IACH,uBAAuB,WACb,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAErD;IAEF;;;;OAIG;IACH,UAAU,SAAU,MAAM,KAAG,QAAQ,SAAS,CAAC,CAE7C;CACH"}
+{"version":3,"file":"InitializableByAddress.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/InitializableByAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAK7E,8BAAsB,2CAA2C,CAC/D,aAAa,SAAS,iBAAiB,CACvC,SAAQ,kCAAkC,CAAC,aAAa,CAAC;IACzD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAkB;gBAG/B,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,cAAc;IAWzB;;;;;OAKG;IACH,uBAAuB,WACb,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAErD;CACH"}

package/dist/ergo/initializable/InitializableByAddress.js

@@ -26,13 +26,5 @@ export class AbstractInitializableByAddressErgoExtractor extends AbstractInitial
     getBoxesWithOffsetLimit = (offset, limit) => {
         return this.network.getBoxesByAddress(this.address, offset, limit);
     };
-    /**
-     * return block information from the specified network source
-     * @param txId
-     * @return block info
-     */
-    getTxBlock = (txId) => {
-        return this.network.getTxBlock(txId);
-    };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,7 +1,6 @@
 import { AbstractLogger } from '@rosen-bridge/abstract-logger';
 import { ErgoExtractedData, ErgoNetworkType, ErgoBox } from '../interfaces';
 import { AbstractInitializableErgoExtractor } from './AbstractInitializable';
-import { BlockInfo } from '../../interfaces';
 export declare abstract class AbstractInitializableByTokenErgoExtractor<ExtractedData extends ErgoExtractedData> extends AbstractInitializableErgoExtractor<ExtractedData> {
     private tokenId;
     private network;
@@ -16,11 +15,5 @@ export declare abstract class AbstractInitializableByTokenErgoExtractor<Extracte
         boxes: ErgoBox[];
         hasNextBatch: boolean;
     }>;
-    /**
-     * return block information from the specified network source
-     * @param txId
-     * @return block info
-     */
-    getTxBlock: (txId: string) => Promise<BlockInfo>;
 }
 //# sourceMappingURL=InitializableByToken.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"InitializableByToken.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/InitializableByToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C,8BAAsB,yCAAyC,CAC7D,aAAa,SAAS,iBAAiB,CACvC,SAAQ,kCAAkC,CAAC,aAAa,CAAC;IACzD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAkB;gBAG/B,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,cAAc;IAWzB;;;;;OAKG;IACH,uBAAuB,WACb,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAErD;IAEF;;;;OAIG;IACH,UAAU,SAAU,MAAM,KAAG,QAAQ,SAAS,CAAC,CAE7C;CACH"}
+{"version":3,"file":"InitializableByToken.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/InitializableByToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAK7E,8BAAsB,yCAAyC,CAC7D,aAAa,SAAS,iBAAiB,CACvC,SAAQ,kCAAkC,CAAC,aAAa,CAAC;IACzD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAkB;gBAG/B,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,cAAc;IAWzB;;;;;OAKG;IACH,uBAAuB,WACb,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAErD;CACH"}

package/dist/ergo/initializable/InitializableByToken.js

@@ -26,13 +26,5 @@ export class AbstractInitializableByTokenErgoExtractor extends AbstractInitializ
     getBoxesWithOffsetLimit = (offset, limit) => {
         return this.network.getBoxesByTokenId(this.tokenId, offset, limit);
     };
-    /**
-     * return block information from the specified network source
-     * @param txId
-     * @return block info
-     */
-    getTxBlock = (txId) => {
-        return this.network.getTxBlock(txId);
-    };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,3 @@
 export * from './AbstractInitializable';
 export * from './AbstractInitializableAction';
-export * from './InitializableByAddress';
-export * from './InitializableByToken';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializable/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}

package/dist/ergo/initializable/index.js

@@ -1,5 +1,3 @@
 export * from './AbstractInitializable';
 export * from './AbstractInitializableAction';
-export * from './InitializableByAddress';
-export * from './InitializableByToken';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9pbml0aWFsaXphYmxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL0Fic3RyYWN0SW5pdGlhbGl6YWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL0Fic3RyYWN0SW5pdGlhbGl6YWJsZUFjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL0luaXRpYWxpemFibGVCeUFkZHJlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9Jbml0aWFsaXphYmxlQnlUb2tlbic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9pbml0aWFsaXphYmxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vQWJzdHJhY3RJbml0aWFsaXphYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vQWJzdHJhY3RJbml0aWFsaXphYmxlQWN0aW9uJztcbiJdfQ==