@rosen-bridge/abstract-extractor 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @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

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,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
+//# 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,36 +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
+     */
+    private getTotalTxCount;
+    /**
+     * Initialize extractor using Node network
+     * @param initialBlock
      */
-    constructor(initialize?: boolean, logger?: AbstractLogger);
+    private initializeWithNode;
     /**
-     * return init required boxes with offset limit
-     * @param offset
-     * @param limit
-     * @return boxes in batch
+     * Process a batch of transactions
+     * group txs into blocks and process them using `processTransactions`
+     * @param txs
      */
-    abstract getBoxesWithOffsetLimit: (offset: number, limit: number) => Promise<{
-        boxes: ErgoBox[];
-        hasNextBatch: boolean;
-    }>;
+    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,wBAAwB,kBACP,MAAM,UACb,MAAM,SACP,MAAM,KACZ,QAAQ;QACT,cAAc,EAAE,MAAM,aAAa,CAAC,CAAC;QACrC,YAAY,EAAE,OAAO,CAAC;KACvB,CAAC,CAiCA;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,67 +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,
-                spendTxId: spent ? box.spentTransactionId : undefined,
-                spendIndex: spent ? box.spentIndex : 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}`);
@@ -71,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 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        spendTxId: spent ? box.spentTransactionId : undefined,\n        spendIndex: spent ? box.spentIndex : 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":"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","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/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==

package/dist/ergo/interfaces.d.ts

@@ -45,6 +45,10 @@ export type Transaction = {
     outputs: Array<OutputBox>;
     size?: bigint;
 };
+export interface ExtendedTransaction extends Transaction {
+    inclusionHeight: number;
+    blockId: string;
+}
 export interface SpendInfo {
     boxId: string;
     txId: string;

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

@@ -1 +1 @@
-{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../lib/ergo/interfaces.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxB,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../lib/ergo/interfaces.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxB,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/ergo/interfaces.js

@@ -3,4 +3,4 @@ export var ErgoNetworkType;
     ErgoNetworkType["Explorer"] = "explorer";
     ErgoNetworkType["Node"] = "node";
 })(ErgoNetworkType || (ErgoNetworkType = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ergo/network/ExplorerNetwork.d.ts

@@ -1,7 +1,6 @@
-import { BlockInfo } from '../../interfaces';
-import { ErgoBox } from '../interfaces';
 import { AbstractNetwork } from './AbstractNetwork';
-import { V1 } from '@rosen-clients/ergo-explorer';
+import { BlockInfo } from '../../interfaces';
+import { ErgoBox, ExtendedTransaction, Transaction } from '../interfaces';
 export declare class ExplorerNetwork extends AbstractNetwork {
     private api;
     constructor(url: string);
@@ -18,7 +17,37 @@ export declare class ExplorerNetwork extends AbstractNetwork {
      * @param box
      * @returns ErgoBox
      */
-    convertBox: (box: V1.OutputInfo) => Promise<ErgoBox>;
+    private convertBox;
+    /**
+     * convert explorer transaction to extractor transaction type
+     * @param tx
+     */
+    private convertTransaction;
+    /**
+     * convert explorer block transaction to transaction type
+     * @param tx
+     */
+    private convertBlockTransaction;
+    /**
+     * use explorer api to return related transactions of the specified address in the height range
+     * @param tokenId
+     * @param offset
+     * @param limit
+     * @returns related transactions
+     */
+    getAddressTransactionsWithHeight: (address: string, fromHeight: number, toHeight: number) => Promise<Array<ExtendedTransaction>>;
+    /**
+     * use explorer api to get the block id at the specified height
+     * @param height
+     * @returns block id
+     */
+    getBlockIdAtHeight: (height: number) => Promise<string>;
+    /**
+     * use explorer api to return all transactions in a block
+     * @param blockId
+     * @returns converted transactions
+     */
+    getBlockTxs: (blockId: string) => Promise<Array<Transaction>>;
     /**
      * use explorer api to return related boxes by specified address
      * @param address

package/dist/ergo/network/ExplorerNetwork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExplorerNetwork.d.ts","sourceRoot":"","sources":["../../../lib/ergo/network/ExplorerNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,EAAE,EAAE,MAAM,8BAA8B,CAAC;AAGlD,qBAAa,eAAgB,SAAQ,eAAe;IAClD,OAAO,CAAC,GAAG,CAAC;gBAEA,GAAG,EAAE,MAAM;IAKvB;;;;OAIG;IACH,eAAe,UACN,MAAM,aACF,MAAM,KAChB,QAAQ,SAAS,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAY5C;IAEF;;;;OAIG;IACH,UAAU,QAAe,GAAG,UAAU,KAAG,QAAQ,OAAO,CAAC,CAuBvD;IAEF;;;;;;OAMG;IACH,iBAAiB,YACN,MAAM,UACP,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAarD;IAEF;;;;;;OAMG;IACH,iBAAiB,YACN,MAAM,UACP,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAYrD;CACH"}
+{"version":3,"file":"ExplorerNetwork.d.ts","sourceRoot":"","sources":["../../../lib/ergo/network/ExplorerNetwork.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI1E,qBAAa,eAAgB,SAAQ,eAAe;IAClD,OAAO,CAAC,GAAG,CAAC;gBAEA,GAAG,EAAE,MAAM;IAKvB;;;;OAIG;IACH,eAAe,UACN,MAAM,aACF,MAAM,KAChB,QAAQ,SAAS,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAY5C;IAEF;;;;OAIG;IACH,OAAO,CAAC,UAAU,CAuBhB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CA6BxB;IAEF;;;OAGG;IACH,OAAO,CAAC,uBAAuB,CAsB7B;IAEF;;;;;;OAMG;IACH,gCAAgC,YACrB,MAAM,cACH,MAAM,YACR,MAAM,KACf,QAAQ,MAAM,mBAAmB,CAAC,CAAC,CAWpC;IAEF;;;;OAIG;IACH,kBAAkB,WAAkB,MAAM,KAAG,QAAQ,MAAM,CAAC,CAG1D;IAEF;;;;OAIG;IACH,WAAW,YAAmB,MAAM,KAAG,QAAQ,MAAM,WAAW,CAAC,CAAC,CAUhE;IAEF;;;;;;OAMG;IACH,iBAAiB,YACN,MAAM,UACP,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAarD;IAEF;;;;;;OAMG;IACH,iBAAiB,YACN,MAAM,UACP,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC,CAYrD;CACH"}