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

package/dist/ergo/index.d.ts

@@ -1,10 +1,8 @@
-export * from './abstractErgoExtractor';
-export * from './abstractErgoExtractorAction';
+export * from './extractors';
+export * from './initializers';
+export * from './database';
 export * from './interfaces';
-export * from './network/explorerNetwork';
-export * from './network/nodeNetwork';
-export * from './network/abstractNetwork';
-export * from './initializable';
+export * from './networks';
+export * from './initializers';
 export * from './utils';
-export * from './abstractErgoExtractorEntity';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/ergo/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,cAAc,CAAC;AAC7B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/ergo/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC"}

package/dist/ergo/index.js

@@ -1,10 +1,8 @@
-export * from './abstractErgoExtractor';
-export * from './abstractErgoExtractorAction';
+export * from './extractors';
+export * from './initializers';
+export * from './database';
 export * from './interfaces';
-export * from './network/explorerNetwork';
-export * from './network/nodeNetwork';
-export * from './network/abstractNetwork';
-export * from './initializable';
+export * from './networks';
+export * from './initializers';
 export * from './utils';
-export * from './abstractErgoExtractorEntity';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLCtCQUErQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdEVyZ29FeHRyYWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdEVyZ29FeHRyYWN0b3JBY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9leHBsb3Jlck5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3JrL25vZGVOZXR3b3JrJztcbmV4cG9ydCAqIGZyb20gJy4vbmV0d29yay9hYnN0cmFjdE5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9pbml0aWFsaXphYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdEVyZ29FeHRyYWN0b3JFbnRpdHknO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V4dHJhY3RvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbml0aWFsaXplcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhYmFzZSc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9uZXR3b3Jrcyc7XG5leHBvcnQgKiBmcm9tICcuL2luaXRpYWxpemVycyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbiJdfQ==

package/dist/ergo/initializers/ergoBoxInitializer.d.ts

@@ -0,0 +1,36 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo, ErgoNetworkType, OutputBox, Transaction } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoBoxAction, AbstractErgoEntity } from '../database';
+import { AbstractEntityData, ExtendedSpendInfo, ExtendedTransaction } from '../interfaces';
+import { ErgoInitializer } from './ergoInitializer';
+export declare class ErgoBoxInitializer<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoEntity> extends ErgoInitializer<ExtractedData, ExtractorEntity> {
+    protected extractorId: string;
+    protected hasBoxData: (box: OutputBox) => boolean;
+    protected processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
+    protected actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>;
+    protected logger: DummyLogger;
+    private spendRecordsMutex;
+    private spendRecords;
+    constructor(networkType: ErgoNetworkType, url: string, address: string, extractorId: string, hasBoxData: (box: OutputBox) => boolean, processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>, actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>, maxParallelRequests?: number, logger?: DummyLogger);
+    /**
+     * Extracts spending information of all related boxes in the transaction
+     * Note: override this function if the extractor needs extra spending info
+     * @param tx
+     * @returns transaction spend info
+     */
+    protected extractTxSpendInfo: (tx: ExtendedTransaction) => ExtendedSpendInfo[];
+    /**
+     * Extract and store all spending information of a transaction batch
+     * @param txs
+     */
+    protected storeExtraInfo: (txs: ExtendedTransaction[]) => Promise<void>;
+    /**
+     * Apply stored spend records into extractor database
+     * Note: As transactions are processed out of order (due to parallel
+     * processing), some box spend information may be invalid after the first pass
+     * To avoid processing everything twice, we keep all spend records in the
+     * first pass and reapply them at the end
+     */
+    protected applyExtraInfo: () => Promise<void>;
+}
+//# sourceMappingURL=ergoBoxInitializer.d.ts.map

package/dist/ergo/initializers/ergoBoxInitializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ergoBoxInitializer.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializers/ergoBoxInitializer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EACL,SAAS,EACT,eAAe,EACf,SAAS,EACT,WAAW,EACZ,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,kBAAkB,CAC7B,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,kBAAkB,CAC1C,SAAQ,eAAe,CAAC,aAAa,EAAE,eAAe,CAAC;IAQrD,SAAS,CAAC,WAAW,EAAE,MAAM;IAC7B,SAAS,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO;IACjD,SAAS,CAAC,mBAAmB,EAAE,CAC7B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC;IACrB,SAAS,CAAC,OAAO,EAAE,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC;IAExE,SAAS,CAAC,MAAM;IAflB,OAAO,CAAC,iBAAiB,CAAe;IACxC,OAAO,CAAC,YAAY,CAAsB;gBAGxC,WAAW,EAAE,eAAe,EAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACL,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,EACvC,mBAAmB,EAAE,CAC7B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC,EACX,OAAO,EAAE,qBAAqB,CAAC,aAAa,EAAE,eAAe,CAAC,EACxE,mBAAmB,SAAwB,EACjC,MAAM,cAAoB;IAetC;;;;;OAKG;IACH,SAAS,CAAC,kBAAkB,GAC1B,IAAI,mBAAmB,KACtB,iBAAiB,EAAE,CAepB;IAEF;;;OAGG;IACH,SAAS,CAAC,cAAc,GACtB,KAAK,mBAAmB,EAAE,KACzB,OAAO,CAAC,IAAI,CAAC,CASd;IAEF;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,sBAoBtB;CACH"}

package/dist/ergo/initializers/ergoBoxInitializer.js

@@ -0,0 +1,80 @@
+import { Mutex } from 'await-semaphore';
+import { groupBy, sortBy } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { MAX_PARALLEL_REQUESTS } from '../../constants';
+import { ErgoInitializer } from './ergoInitializer';
+export class ErgoBoxInitializer extends ErgoInitializer {
+    extractorId;
+    hasBoxData;
+    processTransactions;
+    actions;
+    logger;
+    spendRecordsMutex = new Mutex();
+    spendRecords;
+    constructor(networkType, url, address, extractorId, hasBoxData, processTransactions, actions, maxParallelRequests = MAX_PARALLEL_REQUESTS, logger = new DummyLogger()) {
+        super(networkType, url, address, extractorId, processTransactions, actions, maxParallelRequests, logger);
+        this.extractorId = extractorId;
+        this.hasBoxData = hasBoxData;
+        this.processTransactions = processTransactions;
+        this.actions = actions;
+        this.logger = logger;
+        this.spendRecords = [];
+    }
+    /**
+     * Extracts spending information of all related boxes in the transaction
+     * Note: override this function if the extractor needs extra spending info
+     * @param tx
+     * @returns transaction spend info
+     */
+    extractTxSpendInfo = (tx) => {
+        const txSpendInfo = [];
+        for (let i = 0; i < tx.inputs.length; i++) {
+            const box = tx.inputs[i];
+            if (this.hasBoxData(box)) {
+                txSpendInfo.push({
+                    boxId: box.boxId,
+                    txId: box.transactionId,
+                    index: i,
+                    height: tx.inclusionHeight,
+                    block: tx.blockId,
+                });
+            }
+        }
+        return txSpendInfo;
+    };
+    /**
+     * Extract and store all spending information of a transaction batch
+     * @param txs
+     */
+    storeExtraInfo = async (txs) => {
+        const spendRecordsBatch = [];
+        for (const tx of txs) {
+            spendRecordsBatch.push(...this.extractTxSpendInfo(tx));
+        }
+        const release = await this.spendRecordsMutex.acquire();
+        this.spendRecords.push(...spendRecordsBatch);
+        release();
+        this.logger.debug(`Stored ${spendRecordsBatch.length} new spend records`);
+    };
+    /**
+     * Apply stored spend records into extractor database
+     * Note: As transactions are processed out of order (due to parallel
+     * processing), some box spend information may be invalid after the first pass
+     * To avoid processing everything twice, we keep all spend records in the
+     * first pass and reapply them at the end
+     */
+    applyExtraInfo = async () => {
+        const sortedRecords = sortBy(this.spendRecords, (record) => record.height);
+        const groupedRecords = groupBy(sortedRecords, (tx) => tx.block);
+        this.logger.debug(`Spend records grouped to ${Object.keys(groupedRecords).length} blocks`);
+        const release = await this.dbMutex.acquire();
+        for (const blockId in groupedRecords) {
+            const blockRecords = groupedRecords[blockId];
+            const block = { hash: blockId, height: blockRecords[0].height };
+            this.logger.debug(`Processing spend records at height ${blockRecords[0].height}`);
+            await this.actions.updateSpendingInfo(blockRecords, block, this.extractorId);
+        }
+        release();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ergoBoxInitializer.js","sourceRoot":"","sources":["../../../lib/ergo/initializers/ergoBoxInitializer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Mutex } from 'await-semaphore';\nimport { groupBy, sortBy } from 'lodash-es';\n\nimport { DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  BlockInfo,\n  ErgoNetworkType,\n  OutputBox,\n  Transaction,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport { MAX_PARALLEL_REQUESTS } from '../../constants';\nimport { AbstractErgoBoxAction, AbstractErgoEntity } from '../database';\nimport {\n  AbstractEntityData,\n  ExtendedSpendInfo,\n  ExtendedTransaction,\n} from '../interfaces';\nimport { ErgoInitializer } from './ergoInitializer';\n\nexport class ErgoBoxInitializer<\n  ExtractedData extends AbstractEntityData,\n  ExtractorEntity extends AbstractErgoEntity,\n> extends ErgoInitializer<ExtractedData, ExtractorEntity> {\n  private spendRecordsMutex = new Mutex();\n  private spendRecords: ExtendedSpendInfo[];\n\n  constructor(\n    networkType: ErgoNetworkType,\n    url: string,\n    address: string,\n    protected extractorId: string,\n    protected hasBoxData: (box: OutputBox) => boolean,\n    protected processTransactions: (\n      txs: Transaction[],\n      block: BlockInfo,\n    ) => Promise<boolean>,\n    protected actions: AbstractErgoBoxAction<ExtractedData, ExtractorEntity>,\n    maxParallelRequests = MAX_PARALLEL_REQUESTS,\n    protected logger = new DummyLogger(),\n  ) {\n    super(\n      networkType,\n      url,\n      address,\n      extractorId,\n      processTransactions,\n      actions,\n      maxParallelRequests,\n      logger,\n    );\n    this.spendRecords = [];\n  }\n\n  /**\n   * Extracts spending information of all related boxes in the transaction\n   * Note: override this function if the extractor needs extra spending info\n   * @param tx\n   * @returns transaction spend info\n   */\n  protected extractTxSpendInfo = (\n    tx: ExtendedTransaction,\n  ): ExtendedSpendInfo[] => {\n    const txSpendInfo = [];\n    for (let i = 0; i < tx.inputs.length; i++) {\n      const box = tx.inputs[i];\n      if (this.hasBoxData(box)) {\n        txSpendInfo.push({\n          boxId: box.boxId,\n          txId: box.transactionId,\n          index: i,\n          height: tx.inclusionHeight,\n          block: tx.blockId,\n        });\n      }\n    }\n    return txSpendInfo;\n  };\n\n  /**\n   * Extract and store all spending information of a transaction batch\n   * @param txs\n   */\n  protected storeExtraInfo = async (\n    txs: ExtendedTransaction[],\n  ): Promise<void> => {\n    const spendRecordsBatch: ExtendedSpendInfo[] = [];\n    for (const tx of txs) {\n      spendRecordsBatch.push(...this.extractTxSpendInfo(tx));\n    }\n    const release = await this.spendRecordsMutex.acquire();\n    this.spendRecords.push(...spendRecordsBatch);\n    release();\n    this.logger.debug(`Stored ${spendRecordsBatch.length} new spend records`);\n  };\n\n  /**\n   * Apply stored spend records into extractor database\n   * Note: As transactions are processed out of order (due to parallel\n   * processing), some box spend information may be invalid after the first pass\n   * To avoid processing everything twice, we keep all spend records in the\n   * first pass and reapply them at the end\n   */\n  protected applyExtraInfo = async () => {\n    const sortedRecords = sortBy(this.spendRecords, (record) => record.height);\n    const groupedRecords = groupBy(sortedRecords, (tx) => tx.block);\n    this.logger.debug(\n      `Spend records grouped to ${Object.keys(groupedRecords).length} blocks`,\n    );\n    const release = await this.dbMutex.acquire();\n    for (const blockId in groupedRecords) {\n      const blockRecords = groupedRecords[blockId];\n      const block = { hash: blockId, height: blockRecords[0].height };\n      this.logger.debug(\n        `Processing spend records at height ${blockRecords[0].height}`,\n      );\n      await this.actions.updateSpendingInfo(\n        blockRecords,\n        block,\n        this.extractorId,\n      );\n    }\n    release();\n  };\n}\n"]}

package/dist/ergo/initializers/ergoInitializer.d.ts

@@ -0,0 +1,39 @@
+import { Mutex } from 'await-semaphore';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo, ErgoNetworkType, Transaction } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoAction, AbstractErgoEntity } from '../database';
+import { AbstractEntityData, ExtendedTransaction } from '../interfaces';
+import { ExplorerInitializationStrategy, NodeInitializationStrategy } from './strategies';
+export declare class ErgoInitializer<ExtractedData extends AbstractEntityData, ExtractorEntity extends AbstractErgoEntity> {
+    protected extractorId: string;
+    protected processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
+    protected actions: AbstractErgoAction<ExtractedData, ExtractorEntity>;
+    protected logger: DummyLogger;
+    protected dbMutex: Mutex;
+    protected initializationStrategy: ExplorerInitializationStrategy | NodeInitializationStrategy;
+    constructor(networkType: ErgoNetworkType, url: string, address: string, extractorId: string, processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>, actions: AbstractErgoAction<ExtractedData, ExtractorEntity>, maxParallelRequests?: number, logger?: DummyLogger);
+    /**
+     * override this function to store extra information of a transaction batch
+     * @param txs list of transactions
+     */
+    protected storeExtraInfo(txs: ExtendedTransaction[]): Promise<void>;
+    /**
+     * override this function to apply extra information to the extractor database
+     */
+    protected applyExtraInfo: () => Promise<void>;
+    /**
+     * Process a batch of transactions
+     * group txs into blocks and process them using `processTransactions`
+     * @param txs
+     */
+    private processTransactionBatch;
+    /**
+     * remove all old data and initialize extractor database with data created
+     * below the initial height and finally apply the stored spend records to make
+     * sure all stored data is valid
+     * ignore initialization if this feature is off
+     * @param initialBlock
+     */
+    initializeData: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=ergoInitializer.d.ts.map

package/dist/ergo/initializers/ergoInitializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ergoInitializer.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializers/ergoInitializer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAGxC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EACL,SAAS,EACT,eAAe,EACf,WAAW,EACZ,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC3B,MAAM,cAAc,CAAC;AAEtB,qBAAa,eAAe,CAC1B,aAAa,SAAS,kBAAkB,EACxC,eAAe,SAAS,kBAAkB;IAWxC,SAAS,CAAC,WAAW,EAAE,MAAM;IAC7B,SAAS,CAAC,mBAAmB,EAAE,CAC7B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC;IACrB,SAAS,CAAC,OAAO,EAAE,kBAAkB,CAAC,aAAa,EAAE,eAAe,CAAC;IAErE,SAAS,CAAC,MAAM;IAhBlB,SAAS,CAAC,OAAO,QAAe;IAChC,SAAS,CAAC,sBAAsB,EAC5B,8BAA8B,GAC9B,0BAA0B,CAAC;gBAG7B,WAAW,EAAE,eAAe,EAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACL,WAAW,EAAE,MAAM,EACnB,mBAAmB,EAAE,CAC7B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC,EACX,OAAO,EAAE,kBAAkB,CAAC,aAAa,EAAE,eAAe,CAAC,EACrE,mBAAmB,SAAwB,EACjC,MAAM,cAAoB;IAsBtC;;;OAGG;IACH,SAAS,CAAC,cAAc,CACtB,GAAG,EAAE,mBAAmB,EAAE,GACzB,OAAO,CAAC,IAAI,CAAC;IAIhB;;OAEG;IACH,SAAS,CAAC,cAAc,QAAO,OAAO,CAAC,IAAI,CAAC,CAE1C;IAEF;;;;OAIG;IACH,OAAO,CAAC,uBAAuB,CA0B7B;IAEF;;;;;;OAMG;IACH,cAAc,GAAU,cAAc,SAAS,mBAQ7C;CACH"}

package/dist/ergo/initializers/ergoInitializer.js

@@ -0,0 +1,80 @@
+import { Mutex } from 'await-semaphore';
+import { groupBy, sortBy } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { ErgoNetworkType, } from '@rosen-bridge/scanner-interfaces';
+import { MAX_PARALLEL_REQUESTS } from '../../constants';
+import { ExplorerInitializationStrategy, NodeInitializationStrategy, } from './strategies';
+export class ErgoInitializer {
+    extractorId;
+    processTransactions;
+    actions;
+    logger;
+    dbMutex = new Mutex();
+    initializationStrategy;
+    constructor(networkType, url, address, extractorId, processTransactions, actions, maxParallelRequests = MAX_PARALLEL_REQUESTS, logger = new DummyLogger()) {
+        this.extractorId = extractorId;
+        this.processTransactions = processTransactions;
+        this.actions = actions;
+        this.logger = logger;
+        if (networkType == ErgoNetworkType.Explorer) {
+            this.initializationStrategy = new ExplorerInitializationStrategy(url, address, maxParallelRequests, this.processTransactions, this.processTransactionBatch, logger);
+        }
+        else if (networkType == ErgoNetworkType.Node) {
+            this.initializationStrategy = new NodeInitializationStrategy(url, address, maxParallelRequests, this.processTransactionBatch, logger);
+        }
+        else
+            throw new Error(`Network type ${networkType} is not supported`);
+    }
+    /**
+     * override this function to store extra information of a transaction batch
+     * @param txs list of transactions
+     */
+    storeExtraInfo(txs) {
+        return Promise.resolve();
+    }
+    /**
+     * override this function to apply extra information to the extractor database
+     */
+    applyExtraInfo = () => {
+        return Promise.resolve();
+    };
+    /**
+     * 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`);
+        const release = await this.dbMutex.acquire();
+        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}`);
+            const success = await this.processTransactions(blockTxs, block);
+            if (!success) {
+                release();
+                throw Error(`Processing transactions failed at height ${blockTxs[0].inclusionHeight}`);
+            }
+        }
+        release();
+        this.logger.debug(`storing spend info of transaction batch`);
+        await this.storeExtraInfo(txs);
+    };
+    /**
+     * remove all old data and initialize extractor database with data created
+     * below the initial height and finally apply the stored spend records to make
+     * sure all stored data is valid
+     * ignore initialization if this feature is off
+     * @param initialBlock
+     */
+    initializeData = async (initialBlock) => {
+        this.logger.info(`Initialization process for ${this.extractorId} started`);
+        await this.actions.removeAllData(this.extractorId);
+        await this.initializationStrategy.initialize(initialBlock);
+        await this.applyExtraInfo();
+        this.logger.info(`Initialization completed successfully for ${this.extractorId}`);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ergoInitializer.js","sourceRoot":"","sources":["../../../lib/ergo/initializers/ergoInitializer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Mutex } from 'await-semaphore';\nimport { groupBy, sortBy } from 'lodash-es';\n\nimport { DummyLogger } from '@rosen-bridge/abstract-logger';\nimport {\n  BlockInfo,\n  ErgoNetworkType,\n  Transaction,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport { MAX_PARALLEL_REQUESTS } from '../../constants';\nimport { AbstractErgoAction, AbstractErgoEntity } from '../database';\nimport { AbstractEntityData, ExtendedTransaction } from '../interfaces';\nimport {\n  ExplorerInitializationStrategy,\n  NodeInitializationStrategy,\n} from './strategies';\n\nexport class ErgoInitializer<\n  ExtractedData extends AbstractEntityData,\n  ExtractorEntity extends AbstractErgoEntity,\n> {\n  protected dbMutex = new Mutex();\n  protected initializationStrategy:\n    | ExplorerInitializationStrategy\n    | NodeInitializationStrategy;\n\n  constructor(\n    networkType: ErgoNetworkType,\n    url: string,\n    address: string,\n    protected extractorId: string,\n    protected processTransactions: (\n      txs: Transaction[],\n      block: BlockInfo,\n    ) => Promise<boolean>,\n    protected actions: AbstractErgoAction<ExtractedData, ExtractorEntity>,\n    maxParallelRequests = MAX_PARALLEL_REQUESTS,\n    protected logger = new DummyLogger(),\n  ) {\n    if (networkType == ErgoNetworkType.Explorer) {\n      this.initializationStrategy = new ExplorerInitializationStrategy(\n        url,\n        address,\n        maxParallelRequests,\n        this.processTransactions,\n        this.processTransactionBatch,\n        logger,\n      );\n    } else if (networkType == ErgoNetworkType.Node) {\n      this.initializationStrategy = new NodeInitializationStrategy(\n        url,\n        address,\n        maxParallelRequests,\n        this.processTransactionBatch,\n        logger,\n      );\n    } else throw new Error(`Network type ${networkType} is not supported`);\n  }\n\n  /**\n   * override this function to store extra information of a transaction batch\n   * @param txs list of transactions\n   */\n  protected storeExtraInfo(\n    txs: ExtendedTransaction[], // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): Promise<void> {\n    return Promise.resolve();\n  }\n\n  /**\n   * override this function to apply extra information to the extractor database\n   */\n  protected applyExtraInfo = (): Promise<void> => {\n    return Promise.resolve();\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    const release = await this.dbMutex.acquire();\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      const success = await this.processTransactions(blockTxs, block);\n      if (!success) {\n        release();\n        throw Error(\n          `Processing transactions failed at height ${blockTxs[0].inclusionHeight}`,\n        );\n      }\n    }\n    release();\n    this.logger.debug(`storing spend info of transaction batch`);\n    await this.storeExtraInfo(txs);\n  };\n\n  /**\n   * remove all old data and initialize extractor database with data created\n   * below the initial height and finally apply the stored spend records to make\n   * sure all stored data is valid\n   * ignore initialization if this feature is off\n   * @param initialBlock\n   */\n  initializeData = async (initialBlock: BlockInfo) => {\n    this.logger.info(`Initialization process for ${this.extractorId} started`);\n    await this.actions.removeAllData(this.extractorId);\n    await this.initializationStrategy.initialize(initialBlock);\n    await this.applyExtraInfo();\n    this.logger.info(\n      `Initialization completed successfully for ${this.extractorId}`,\n    );\n  };\n}\n"]}

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

@@ -0,0 +1,4 @@
+export * from './ergoInitializer';
+export * from './ergoBoxInitializer';
+export * from './strategies';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/ergo/initializers/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC"}

package/dist/ergo/initializers/index.js

@@ -0,0 +1,4 @@
+export * from './ergoInitializer';
+export * from './ergoBoxInitializer';
+export * from './strategies';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9pbml0aWFsaXplcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lcmdvSW5pdGlhbGl6ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9lcmdvQm94SW5pdGlhbGl6ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zdHJhdGVnaWVzJztcbiJdfQ==

package/dist/ergo/initializers/strategies/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DELAY_BETWEEN_INIT_REQUESTS = 100;
+export declare const INIT_WORKERS_REASSIGN_INTERVAL = 5000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/ergo/initializers/strategies/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,8BAA8B,OAAO,CAAC"}

package/dist/ergo/initializers/strategies/constants.js

@@ -0,0 +1,3 @@
+export const DELAY_BETWEEN_INIT_REQUESTS = 100; // In milliseconds (only applies to node initialization)
+export const INIT_WORKERS_REASSIGN_INTERVAL = 5000; //milliseconds (only applies to explorer initialization)
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGliL2VyZ28vaW5pdGlhbGl6ZXJzL3N0cmF0ZWdpZXMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUFHLEdBQUcsQ0FBQyxDQUFDLHdEQUF3RDtBQUN4RyxNQUFNLENBQUMsTUFBTSw4QkFBOEIsR0FBRyxJQUFJLENBQUMsQ0FBQyx3REFBd0QiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgREVMQVlfQkVUV0VFTl9JTklUX1JFUVVFU1RTID0gMTAwOyAvLyBJbiBtaWxsaXNlY29uZHMgKG9ubHkgYXBwbGllcyB0byBub2RlIGluaXRpYWxpemF0aW9uKVxuZXhwb3J0IGNvbnN0IElOSVRfV09SS0VSU19SRUFTU0lHTl9JTlRFUlZBTCA9IDUwMDA7IC8vbWlsbGlzZWNvbmRzIChvbmx5IGFwcGxpZXMgdG8gZXhwbG9yZXIgaW5pdGlhbGl6YXRpb24pXG4iXX0=

package/dist/ergo/initializers/strategies/explorerInitializationStrategy.d.ts

@@ -0,0 +1,59 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo, Transaction } from '@rosen-bridge/scanner-interfaces';
+import { ExtendedTransaction } from '../../interfaces';
+export declare class ExplorerInitializationStrategy {
+    private address;
+    private maxWorkers;
+    private processTransactions;
+    private processTransactionBatch;
+    private logger;
+    private network;
+    private extraLargeBlocks;
+    private promiseQueue;
+    private workerManager;
+    constructor(url: string, address: string, maxWorkers: number, processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>, processTransactionBatch: (txs: ExtendedTransaction[]) => Promise<void>, logger?: DummyLogger);
+    /**
+     * Get height range transaction count
+     * retry the request to avoid failure in case of accidental network issues
+     * @param fromHeight
+     * @param toHeight
+     * @returns transaction count
+     */
+    private getRangeTxCount;
+    /**
+     * Get height range transactions and process them
+     * retry the request to avoid failure in case of accidental network issues
+     * @param rangeQuery
+     */
+    private processRange;
+    /**
+     * Get block id in the specified height and process the block
+     * add the block to extra large blocks
+     * @param height
+     */
+    private processBlockAtHeight;
+    /**
+     * Get block transactions and process them
+     * retry the request to avoid failure in case of accidental network issues
+     * @param block
+     */
+    private processBlock;
+    /**
+     * Start the worker on the assigned range
+     * - worker process the range and split it to smaller ones if it's not processable
+     * - a range is processable if:
+     *    1- has less than or equal to API_LIMIT transactions (Uses processRange)
+     *    2- contains a single block (uses processBlockAtHeight)
+     * - after processing a range, all older ranges are updated accordingly
+     * - to optimize the workflow, the worker selects the biggest processable
+     *    range from top of the range list
+     * @param workerIndex
+     */
+    private startWorker;
+    /**
+     * Initialize extractor using Explorer network
+     * @param initialBlock
+     */
+    initialize: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=explorerInitializationStrategy.d.ts.map

package/dist/ergo/initializers/strategies/explorerInitializationStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorerInitializationStrategy.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/explorerInitializationStrategy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAG1E,OAAO,EAAE,mBAAmB,EAAc,MAAM,kBAAkB,CAAC;AAMnE,qBAAa,8BAA8B;IAQvC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,uBAAuB;IAG/B,OAAO,CAAC,MAAM;IAhBhB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,gBAAgB,CAAc;IACtC,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAgB;gBAGnC,GAAG,EAAE,MAAM,EACH,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,CAC3B,GAAG,EAAE,WAAW,EAAE,EAClB,KAAK,EAAE,SAAS,KACb,OAAO,CAAC,OAAO,CAAC,EACb,uBAAuB,EAAE,CAC/B,GAAG,EAAE,mBAAmB,EAAE,KACvB,OAAO,CAAC,IAAI,CAAC,EACV,MAAM,cAAoB;IAYpC;;;;;;OAMG;IACH,OAAO,CAAC,eAAe,CAarB;IAEF;;;;OAIG;IACH,OAAO,CAAC,YAAY,CA2BlB;IAEF;;;;OAIG;IACH,OAAO,CAAC,oBAAoB,CAS1B;IAEF;;;;OAIG;IACH,OAAO,CAAC,YAAY,CASlB;IAEF;;;;;;;;;;OAUG;IACH,OAAO,CAAC,WAAW,CA+BjB;IAEF;;;OAGG;IACH,UAAU,GAAU,cAAc,SAAS,mBA0BzC;CACH"}

package/dist/ergo/initializers/strategies/explorerInitializationStrategy.js

@@ -0,0 +1,141 @@
+import PQueue from 'p-queue';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { API_LIMIT } from '../../../constants';
+import { ExplorerNetwork } from '../../networks/explorerNetwork';
+import { requestWithRetrial } from '../../utils';
+import { INIT_WORKERS_REASSIGN_INTERVAL } from './constants';
+import { WorkerManager } from './workerManager';
+export class ExplorerInitializationStrategy {
+    address;
+    maxWorkers;
+    processTransactions;
+    processTransactionBatch;
+    logger;
+    network;
+    extraLargeBlocks;
+    promiseQueue;
+    workerManager;
+    constructor(url, address, maxWorkers, processTransactions, processTransactionBatch, logger = new DummyLogger()) {
+        this.address = address;
+        this.maxWorkers = maxWorkers;
+        this.processTransactions = processTransactions;
+        this.processTransactionBatch = processTransactionBatch;
+        this.logger = logger;
+        this.network = new ExplorerNetwork(url);
+        this.extraLargeBlocks = [];
+        this.promiseQueue = new PQueue({ concurrency: maxWorkers });
+        this.workerManager = new WorkerManager(this.maxWorkers, this.getRangeTxCount, this.logger);
+    }
+    /**
+     * Get height range transaction count
+     * retry the request to avoid failure in case of accidental network issues
+     * @param fromHeight
+     * @param toHeight
+     * @returns transaction count
+     */
+    getRangeTxCount = async (fromHeight, toHeight) => {
+        return (await requestWithRetrial(() => this.network.getAddressTransactionsWithHeight(this.address, fromHeight, toHeight, 1), this.logger)).total;
+    };
+    /**
+     * Get height range transactions and process them
+     * retry the request to avoid failure in case of accidental network issues
+     * @param rangeQuery
+     */
+    processRange = async (rangeQuery) => {
+        if (rangeQuery.count == 0) {
+            this.logger.debug(`skipping range [${rangeQuery.start}, ${rangeQuery.end}] with 0 txs`);
+            return;
+        }
+        const txs = await requestWithRetrial(() => this.network.getAddressTransactionsWithHeight(this.address, rangeQuery.start, rangeQuery.end), this.logger);
+        if (txs.total != rangeQuery.count)
+            this.logger.error(`Impossible behavior: Range query count ${rangeQuery.count} differs from total ${txs.total} for range [${rangeQuery.start}, ${rangeQuery.end}]`);
+        this.logger.debug(`Processing started for [${rangeQuery.start}, ${rangeQuery.end}] with ${txs.total} txs`);
+        await this.processTransactionBatch(txs.items);
+        this.logger.debug(`Processing finished for [${rangeQuery.start}, ${rangeQuery.end}] with ${txs.total} txs`);
+    };
+    /**
+     * Get block id in the specified height and process the block
+     * add the block to extra large blocks
+     * @param height
+     */
+    processBlockAtHeight = async (height) => {
+        const blockId = await requestWithRetrial(() => this.network.getBlockIdAtHeight(height), this.logger);
+        const block = { hash: blockId, height: height };
+        await this.processBlock(block);
+        this.extraLargeBlocks.push(block);
+        this.logger.debug(`Added block at height ${height} to extra large blocks`);
+    };
+    /**
+     * Get block transactions and process them
+     * retry the request to avoid failure in case of accidental network issues
+     * @param block
+     */
+    processBlock = async (block) => {
+        const blockTxs = await requestWithRetrial(() => this.network.getBlockTxs(block.hash), this.logger);
+        this.logger.debug(`Found ${blockTxs.length} transactions at height ${block.height}`);
+        await this.processTransactions(blockTxs, block);
+    };
+    /**
+     * Start the worker on the assigned range
+     * - worker process the range and split it to smaller ones if it's not processable
+     * - a range is processable if:
+     *    1- has less than or equal to API_LIMIT transactions (Uses processRange)
+     *    2- contains a single block (uses processBlockAtHeight)
+     * - after processing a range, all older ranges are updated accordingly
+     * - to optimize the workflow, the worker selects the biggest processable
+     *    range from top of the range list
+     * @param workerIndex
+     */
+    startWorker = async (workerIndex) => {
+        while (this.workerManager.isWorkerActive(workerIndex)) {
+            const lastRangeQuery = await this.workerManager.getLastRange(workerIndex, API_LIMIT);
+            this.logger.debug(`Worker-${workerIndex} is checking range query ${JSON.stringify(lastRangeQuery)}`);
+            if (lastRangeQuery.count > API_LIMIT &&
+                lastRangeQuery.start != lastRangeQuery.end) {
+                // range is not processable
+                await this.workerManager.limitLastRange(workerIndex);
+            }
+            else {
+                // range is processable
+                if (lastRangeQuery.count <= API_LIMIT) {
+                    this.logger.debug(`Processing transactions in range query`);
+                    await this.processRange(lastRangeQuery);
+                }
+                else {
+                    this.logger.debug(`processing extra large block at height ${lastRangeQuery.start}`);
+                    await this.processBlockAtHeight(lastRangeQuery.start);
+                }
+                await this.workerManager.popLastRangeQuery(workerIndex);
+            }
+        }
+    };
+    /**
+     * Initialize extractor using Explorer network
+     * @param initialBlock
+     */
+    initialize = async (initialBlock) => {
+        this.workerManager.setup(initialBlock.height);
+        const addWorkerJob = (i) => this.promiseQueue.add(() => this.startWorker(i));
+        // Initialize the workers
+        await Promise.all(Array.from({ length: this.maxWorkers }, async (_, i) => {
+            await this.workerManager.registerWorker(i);
+            addWorkerJob(i);
+        }));
+        // Periodically check for idle workers and reassign a new range to them
+        const reassignWorker = setInterval(async () => {
+            const newWorkers = await this.workerManager.reassignIdleWorkers();
+            if (newWorkers.length > 0) {
+                this.logger.debug(`Reassigned workers ${newWorkers}`);
+                newWorkers.forEach((workerIndex) => addWorkerJob(workerIndex));
+            }
+        }, INIT_WORKERS_REASSIGN_INTERVAL);
+        // Wait for all workers to finish their jobs
+        await this.promiseQueue.onIdle();
+        // Stop reassigning interval
+        clearInterval(reassignWorker);
+        for (const block of this.extraLargeBlocks) {
+            await this.processBlock(block);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"explorerInitializationStrategy.js","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/explorerInitializationStrategy.ts"],"names":[],"mappings":"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","sourcesContent":["import PQueue from 'p-queue';\n\nimport { DummyLogger } from '@rosen-bridge/abstract-logger';\nimport { BlockInfo, Transaction } from '@rosen-bridge/scanner-interfaces';\n\nimport { API_LIMIT } from '../../../constants';\nimport { ExtendedTransaction, RangeQuery } from '../../interfaces';\nimport { ExplorerNetwork } from '../../networks/explorerNetwork';\nimport { requestWithRetrial } from '../../utils';\nimport { INIT_WORKERS_REASSIGN_INTERVAL } from './constants';\nimport { WorkerManager } from './workerManager';\n\nexport class ExplorerInitializationStrategy {\n  private network: ExplorerNetwork;\n  private extraLargeBlocks: BlockInfo[];\n  private promiseQueue: PQueue;\n  private workerManager: WorkerManager;\n\n  constructor(\n    url: string,\n    private address: string,\n    private maxWorkers: number,\n    private processTransactions: (\n      txs: Transaction[],\n      block: BlockInfo,\n    ) => Promise<boolean>,\n    private processTransactionBatch: (\n      txs: ExtendedTransaction[],\n    ) => Promise<void>,\n    private logger = new DummyLogger(),\n  ) {\n    this.network = new ExplorerNetwork(url);\n    this.extraLargeBlocks = [];\n    this.promiseQueue = new PQueue({ concurrency: maxWorkers });\n    this.workerManager = new WorkerManager(\n      this.maxWorkers,\n      this.getRangeTxCount,\n      this.logger,\n    );\n  }\n\n  /**\n   * Get height range transaction count\n   * retry the request to avoid failure in case of accidental network issues\n   * @param fromHeight\n   * @param toHeight\n   * @returns transaction count\n   */\n  private getRangeTxCount = async (fromHeight: number, toHeight: number) => {\n    return (\n      await requestWithRetrial(\n        () =>\n          this.network.getAddressTransactionsWithHeight(\n            this.address,\n            fromHeight,\n            toHeight,\n            1,\n          ),\n        this.logger,\n      )\n    ).total;\n  };\n\n  /**\n   * Get height range transactions and process them\n   * retry the request to avoid failure in case of accidental network issues\n   * @param rangeQuery\n   */\n  private processRange = async (rangeQuery: RangeQuery): Promise<void> => {\n    if (rangeQuery.count == 0) {\n      this.logger.debug(\n        `skipping range [${rangeQuery.start}, ${rangeQuery.end}] with 0 txs`,\n      );\n      return;\n    }\n    const txs = await requestWithRetrial(\n      () =>\n        this.network.getAddressTransactionsWithHeight(\n          this.address,\n          rangeQuery.start,\n          rangeQuery.end,\n        ),\n      this.logger,\n    );\n    if (txs.total != rangeQuery.count)\n      this.logger.error(\n        `Impossible behavior: Range query count ${rangeQuery.count} differs from total ${txs.total} for range [${rangeQuery.start}, ${rangeQuery.end}]`,\n      );\n    this.logger.debug(\n      `Processing started for [${rangeQuery.start}, ${rangeQuery.end}] with ${txs.total} txs`,\n    );\n    await this.processTransactionBatch(txs.items);\n    this.logger.debug(\n      `Processing finished for [${rangeQuery.start}, ${rangeQuery.end}] with ${txs.total} txs`,\n    );\n  };\n\n  /**\n   * Get block id in the specified height and process the block\n   * add the block to extra large blocks\n   * @param height\n   */\n  private processBlockAtHeight = async (height: number) => {\n    const blockId = await requestWithRetrial(\n      () => this.network.getBlockIdAtHeight(height),\n      this.logger,\n    );\n    const block = { hash: blockId, height: height };\n    await this.processBlock(block);\n    this.extraLargeBlocks.push(block);\n    this.logger.debug(`Added block at height ${height} to extra large blocks`);\n  };\n\n  /**\n   * Get block transactions and process them\n   * retry the request to avoid failure in case of accidental network issues\n   * @param block\n   */\n  private processBlock = async (block: BlockInfo) => {\n    const blockTxs = await requestWithRetrial(\n      () => this.network.getBlockTxs(block.hash),\n      this.logger,\n    );\n    this.logger.debug(\n      `Found ${blockTxs.length} transactions at height ${block.height}`,\n    );\n    await this.processTransactions(blockTxs, block);\n  };\n\n  /**\n   * Start the worker on the assigned range\n   * - worker process the range and split it to smaller ones if it's not processable\n   * - a range is processable if:\n   *    1- has less than or equal to API_LIMIT transactions (Uses processRange)\n   *    2- contains a single block (uses processBlockAtHeight)\n   * - after processing a range, all older ranges are updated accordingly\n   * - to optimize the workflow, the worker selects the biggest processable\n   *    range from top of the range list\n   * @param workerIndex\n   */\n  private startWorker = async (workerIndex: number) => {\n    while (this.workerManager.isWorkerActive(workerIndex)) {\n      const lastRangeQuery = await this.workerManager.getLastRange(\n        workerIndex,\n        API_LIMIT,\n      );\n      this.logger.debug(\n        `Worker-${workerIndex} is checking range query ${JSON.stringify(\n          lastRangeQuery,\n        )}`,\n      );\n      if (\n        lastRangeQuery.count > API_LIMIT &&\n        lastRangeQuery.start != lastRangeQuery.end\n      ) {\n        // range is not processable\n        await this.workerManager.limitLastRange(workerIndex);\n      } else {\n        // range is processable\n        if (lastRangeQuery.count <= API_LIMIT) {\n          this.logger.debug(`Processing transactions in range query`);\n          await this.processRange(lastRangeQuery);\n        } else {\n          this.logger.debug(\n            `processing extra large block at height ${lastRangeQuery.start}`,\n          );\n          await this.processBlockAtHeight(lastRangeQuery.start);\n        }\n        await this.workerManager.popLastRangeQuery(workerIndex);\n      }\n    }\n  };\n\n  /**\n   * Initialize extractor using Explorer network\n   * @param initialBlock\n   */\n  initialize = async (initialBlock: BlockInfo) => {\n    this.workerManager.setup(initialBlock.height);\n    const addWorkerJob = (i: number) =>\n      this.promiseQueue.add(() => this.startWorker(i));\n    // Initialize the workers\n    await Promise.all(\n      Array.from({ length: this.maxWorkers }, async (_, i) => {\n        await this.workerManager.registerWorker(i);\n        addWorkerJob(i);\n      }),\n    );\n    // Periodically check for idle workers and reassign a new range to them\n    const reassignWorker = setInterval(async () => {\n      const newWorkers = await this.workerManager.reassignIdleWorkers();\n      if (newWorkers.length > 0) {\n        this.logger.debug(`Reassigned workers ${newWorkers}`);\n        newWorkers.forEach((workerIndex) => addWorkerJob(workerIndex));\n      }\n    }, INIT_WORKERS_REASSIGN_INTERVAL);\n    // Wait for all workers to finish their jobs\n    await this.promiseQueue.onIdle();\n    // Stop reassigning interval\n    clearInterval(reassignWorker);\n    for (const block of this.extraLargeBlocks) {\n      await this.processBlock(block);\n    }\n  };\n}\n"]}

package/dist/ergo/initializers/strategies/index.d.ts

@@ -0,0 +1,4 @@
+export * from './explorerInitializationStrategy';
+export * from './nodeInitializationStrategy';
+export * from './workerManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/ergo/initializers/strategies/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iBAAiB,CAAC"}

package/dist/ergo/initializers/strategies/index.js

@@ -0,0 +1,4 @@
+export * from './explorerInitializationStrategy';
+export * from './nodeInitializationStrategy';
+export * from './workerManager';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvZXJnby9pbml0aWFsaXplcnMvc3RyYXRlZ2llcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXhwbG9yZXJJbml0aWFsaXphdGlvblN0cmF0ZWd5JztcbmV4cG9ydCAqIGZyb20gJy4vbm9kZUluaXRpYWxpemF0aW9uU3RyYXRlZ3knO1xuZXhwb3J0ICogZnJvbSAnLi93b3JrZXJNYW5hZ2VyJztcbiJdfQ==