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

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

@@ -0,0 +1,29 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { ExtendedTransaction } from '../../interfaces';
+export declare class NodeInitializationStrategy {
+    private address;
+    private maxParallelRequests;
+    private processTransactionBatch;
+    private logger;
+    private network;
+    constructor(url: string, address: string, maxParallelRequests: number, processTransactionBatch: (txs: ExtendedTransaction[]) => Promise<void>, logger?: DummyLogger);
+    /**
+     * Get the total tx count from Node network
+     * @returns total tx count of the address
+     */
+    private getTotalTxCount;
+    /**
+     * Processing node transactions with offset and limit
+     * @param offset
+     * @param limit
+     * @param initialHeight
+     */
+    private processWithOffsetLimit;
+    /**
+     * Initialize extractor using Node network
+     * @param initialBlock
+     */
+    initialize: (initialBlock: BlockInfo) => Promise<void>;
+}
+//# sourceMappingURL=nodeInitializationStrategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeInitializationStrategy.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/nodeInitializationStrategy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAG7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAKvD,qBAAa,0BAA0B;IAKnC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,uBAAuB;IAG/B,OAAO,CAAC,MAAM;IAThB,OAAO,CAAC,OAAO,CAAc;gBAG3B,GAAG,EAAE,MAAM,EACH,OAAO,EAAE,MAAM,EACf,mBAAmB,EAAE,MAAM,EAC3B,uBAAuB,EAAE,CAC/B,GAAG,EAAE,mBAAmB,EAAE,KACvB,OAAO,CAAC,IAAI,CAAC,EACV,MAAM,cAAoB;IAKpC;;;OAGG;IACH,OAAO,CAAC,eAAe,CAOrB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB,CAuB5B;IAEF;;;OAGG;IACH,UAAU,GAAU,cAAc,SAAS,mBAmBzC;CACH"}

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

@@ -0,0 +1,66 @@
+import PQueue from 'p-queue';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { API_LIMIT } from '../../../constants';
+import { NodeNetwork } from '../../networks/nodeNetwork';
+import { delay, requestWithRetrial } from '../../utils';
+import { DELAY_BETWEEN_INIT_REQUESTS } from './constants';
+export class NodeInitializationStrategy {
+    address;
+    maxParallelRequests;
+    processTransactionBatch;
+    logger;
+    network;
+    constructor(url, address, maxParallelRequests, processTransactionBatch, logger = new DummyLogger()) {
+        this.address = address;
+        this.maxParallelRequests = maxParallelRequests;
+        this.processTransactionBatch = processTransactionBatch;
+        this.logger = logger;
+        this.network = new NodeNetwork(url);
+    }
+    /**
+     * 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;
+    };
+    /**
+     * Processing node transactions with offset and limit
+     * @param offset
+     * @param limit
+     * @param initialHeight
+     */
+    processWithOffsetLimit = async (offset, limit, initialHeight) => {
+        this.logger.debug(`Requesting node getTxsByAddress with offset ${offset}`);
+        const response = await requestWithRetrial(() => this.network.getAddressTransactionsWithOffsetLimit(this.address, offset, limit), this.logger);
+        const txs = response.items.filter((tx) => tx.inclusionHeight <= initialHeight);
+        this.logger.debug(`Found ${txs.length} new transactions below the initial height with offset ${offset}, total is ${response.total}`);
+        if (txs.length > 0)
+            await this.processTransactionBatch(txs);
+        this.logger.debug(`Processing completed for request with offset ${offset}`);
+    };
+    /**
+     * Initialize extractor using Node network
+     * @param initialBlock
+     */
+    initialize = async (initialBlock) => {
+        try {
+            let offset = 0;
+            const total = await this.getTotalTxCount();
+            const promiseQueue = new PQueue({
+                concurrency: this.maxParallelRequests,
+            });
+            while (offset < total) {
+                await delay(DELAY_BETWEEN_INIT_REQUESTS);
+                ((offset) => promiseQueue.add(() => this.processWithOffsetLimit(offset, API_LIMIT, initialBlock.height)))(offset);
+                offset += API_LIMIT;
+            }
+            await promiseQueue.onIdle();
+        }
+        catch (error) {
+            throw new Error(`Error initializing extractor by node: ${error}`);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { RangeQuery } from '../../interfaces';
+export declare class WorkerManager {
+    private workerCount;
+    private getRangeTxCount;
+    private logger;
+    private workersRangeList;
+    private mutex;
+    private initialSegmentSize;
+    private maxHeight?;
+    constructor(workerCount: number, getRangeTxCount: (start: number, end: number) => Promise<number>, logger?: DummyLogger);
+    /**
+     * Setup the worker manager to start working
+     * @param maxHeight
+     */
+    setup: (maxHeight: number) => void;
+    /**
+     * Checks if the worker's search range is completed
+     * @param workerIndex
+     * @returns true if worker has an incomplete range to work on
+     */
+    isWorkerActive: (workerIndex: number) => boolean;
+    /**
+     * Register the worker for the first time
+     * splits the whole range equally between workers
+     * @param workerIndex
+     */
+    registerWorker: (workerIndex: number) => Promise<void>;
+    /**
+     * Add a new range to the workers range list
+     * new range is a subset of all existing ranges
+     * @param workerIndex
+     * @param start
+     * @param end
+     */
+    private addWorkerRange;
+    /**
+     * Limit the last range by adding a new range query to the workers range list
+     * the new range the first half of the last existing range
+     * @param workerIndex
+     */
+    limitLastRange: (workerIndex: number) => Promise<void>;
+    /**
+     * Pop the last range query after being processed
+     * also update all older ranges and deduct the processed numbers
+     * @param workerIndex
+     */
+    popLastRangeQuery: (workerIndex: number) => Promise<void>;
+    /**
+     * Find the biggest incomplete range list containing at least 2 ranges
+     * the range list must have at least two range so that it wont become empty
+     * after splitting the range between two workers
+     * @returns biggest incomplete range list index
+     */
+    private getBiggestIncompleteRangeIndex;
+    /**
+     * Check all workers and reassign incomplete ranges to the idle ones
+     * do nothing if all workers are active
+     * do nothing if there is no incomplete range list
+     * split the biggest range list between the current worker and the idle worker
+     * @returns
+     */
+    reassignIdleWorkers: () => Promise<number[]>;
+    /**
+     * Get the last (biggest) processable range from the worker's range list
+     *
+     * After the last range is processed, the older ones are updated and usually
+     * become smaller. Some of them might shrink below a certain threshold, which
+     * means they can now be processed too.
+     * This function finds the biggest range that is small enough to be processed,
+     * and removes all of its child ranges from the list.
+     * Returns the last range if none of them is processable.
+     * @param workerIndex
+     * @param rangeThreshold
+     * @returns range query
+     */
+    getLastRange: (workerIndex: number, rangeThreshold: number) => Promise<RangeQuery>;
+}
+//# sourceMappingURL=workerManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workerManager.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/workerManager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,OAAO,EAAa,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzD,qBAAa,aAAa;IAOtB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,MAAM;IARhB,OAAO,CAAC,gBAAgB,CAAc;IACtC,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,SAAS,CAAC,CAAS;gBAGjB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EAChE,MAAM,cAAoB;IAGpC;;;OAGG;IACH,KAAK,GAAI,WAAW,MAAM,UAIxB;IAEF;;;;OAIG;IACH,cAAc,GAAI,aAAa,MAAM,KAAG,OAAO,CAE7C;IAEF;;;;OAIG;IACH,cAAc,GAAU,aAAa,MAAM,mBAYzC;IAEF;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,CAapB;IAEF;;;;OAIG;IACH,cAAc,GAAU,aAAa,MAAM,mBAazC;IAEF;;;;OAIG;IACH,iBAAiB,GAAU,aAAa,MAAM,mBAU5C;IAEF;;;;;OAKG;IACH,OAAO,CAAC,8BAA8B,CAWpC;IAEF;;;;;;OAMG;IACH,mBAAmB,QAAa,OAAO,CAAC,MAAM,EAAE,CAAC,CA+C/C;IAEF;;;;;;;;;;;;OAYG;IACH,YAAY,GACV,aAAa,MAAM,EACnB,gBAAgB,MAAM,KACrB,OAAO,CAAC,UAAU,CAAC,CAkBpB;CACH"}

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

@@ -0,0 +1,183 @@
+import { Mutex } from 'await-semaphore';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+export class WorkerManager {
+    workerCount;
+    getRangeTxCount;
+    logger;
+    workersRangeList;
+    mutex = new Mutex();
+    initialSegmentSize;
+    maxHeight;
+    constructor(workerCount, getRangeTxCount, logger = new DummyLogger()) {
+        this.workerCount = workerCount;
+        this.getRangeTxCount = getRangeTxCount;
+        this.logger = logger;
+    }
+    /**
+     * Setup the worker manager to start working
+     * @param maxHeight
+     */
+    setup = (maxHeight) => {
+        this.maxHeight = maxHeight;
+        this.workersRangeList = Array.from({ length: this.workerCount }, () => []);
+        this.initialSegmentSize = Math.ceil(this.maxHeight / this.workerCount);
+    };
+    /**
+     * Checks if the worker's search range is completed
+     * @param workerIndex
+     * @returns true if worker has an incomplete range to work on
+     */
+    isWorkerActive = (workerIndex) => {
+        return this.workersRangeList[workerIndex].length > 0;
+    };
+    /**
+     * Register the worker for the first time
+     * splits the whole range equally between workers
+     * @param workerIndex
+     */
+    registerWorker = async (workerIndex) => {
+        if (!this.maxHeight)
+            throw Error('Please call setup before registering workers');
+        const start = workerIndex * this.initialSegmentSize;
+        const end = Math.min((workerIndex + 1) * this.initialSegmentSize - 1, this.maxHeight);
+        await this.addWorkerRange(workerIndex, start, end);
+        this.logger.debug(`Worker-${workerIndex} is initialized with range [${start}, ${end}]`);
+    };
+    /**
+     * Add a new range to the workers range list
+     * new range is a subset of all existing ranges
+     * @param workerIndex
+     * @param start
+     * @param end
+     */
+    addWorkerRange = async (workerIndex, start, end) => {
+        const count = await this.getRangeTxCount(start, end);
+        const release = await this.mutex.acquire();
+        this.workersRangeList[workerIndex].push({
+            start,
+            end,
+            count,
+        });
+        release();
+    };
+    /**
+     * Limit the last range by adding a new range query to the workers range list
+     * the new range the first half of the last existing range
+     * @param workerIndex
+     */
+    limitLastRange = async (workerIndex) => {
+        const lastRangeQuery = this.workersRangeList[workerIndex].at(-1);
+        if (!lastRangeQuery)
+            throw Error('Impossible case, worker does not have any range query');
+        const newQueryEnd = Math.floor((lastRangeQuery.end - lastRangeQuery.start) / 2) +
+            lastRangeQuery.start;
+        this.logger.debug(`Limiting the range by adding a new range query [${(lastRangeQuery.start, newQueryEnd)}]`);
+        await this.addWorkerRange(workerIndex, lastRangeQuery.start, newQueryEnd);
+    };
+    /**
+     * Pop the last range query after being processed
+     * also update all older ranges and deduct the processed numbers
+     * @param workerIndex
+     */
+    popLastRangeQuery = async (workerIndex) => {
+        const release = await this.mutex.acquire();
+        const lastRangeQuery = this.workersRangeList[workerIndex].pop();
+        if (!lastRangeQuery)
+            throw Error('Impossible case, worker does not have any range query');
+        this.workersRangeList[workerIndex].map((rangeQuery) => {
+            rangeQuery.count -= lastRangeQuery.count;
+            rangeQuery.start = lastRangeQuery.end + 1;
+        });
+        release();
+    };
+    /**
+     * Find the biggest incomplete range list containing at least 2 ranges
+     * the range list must have at least two range so that it wont become empty
+     * after splitting the range between two workers
+     * @returns biggest incomplete range list index
+     */
+    getBiggestIncompleteRangeIndex = () => {
+        let biggestRange = 0, biggestRangeIndex = undefined;
+        for (let i = 0; i < this.workersRangeList.length; i++) {
+            const rangeList = this.workersRangeList[i];
+            if (rangeList.length > 1 && rangeList[0].count > biggestRange) {
+                biggestRange = rangeList[0].count;
+                biggestRangeIndex = i;
+            }
+        }
+        return biggestRangeIndex;
+    };
+    /**
+     * Check all workers and reassign incomplete ranges to the idle ones
+     * do nothing if all workers are active
+     * do nothing if there is no incomplete range list
+     * split the biggest range list between the current worker and the idle worker
+     * @returns
+     */
+    reassignIdleWorkers = async () => {
+        this.logger.debug('Checking idle workers to reassign');
+        const release = await this.mutex.acquire();
+        const idleWorkerIndexes = this.workersRangeList
+            .map((_, index) => (this.isWorkerActive(index) ? -1 : index))
+            .filter((index) => index !== -1);
+        if (idleWorkerIndexes.length == 0) {
+            this.logger.debug(`There is no idle worker to reassign`);
+            release();
+            return [];
+        }
+        this.logger.debug(`Found idle workers ${idleWorkerIndexes}`);
+        this.logger.debug(`Workers range lists before splitting ${JSON.stringify(this.workersRangeList)}`);
+        const newWorkers = [];
+        for (const idleWorkerIndex of idleWorkerIndexes) {
+            this.logger.debug(`reassigning job to worker-${idleWorkerIndex}`);
+            const biggestIncompleteRangeIndex = this.getBiggestIncompleteRangeIndex();
+            if (biggestIncompleteRangeIndex == undefined) {
+                this.logger.debug(`there is no incomplete range to reassign`);
+                break;
+            }
+            this.logger.debug(`biggest incomplete range is ${JSON.stringify(this.workersRangeList[biggestIncompleteRangeIndex])}`);
+            const removedRangeQuery = this.workersRangeList[biggestIncompleteRangeIndex].shift();
+            const head = this.workersRangeList[biggestIncompleteRangeIndex][0];
+            this.workersRangeList[idleWorkerIndex] = [
+                {
+                    start: head.end + 1,
+                    end: removedRangeQuery.end,
+                    count: removedRangeQuery.count - head.count,
+                },
+            ];
+            newWorkers.push(idleWorkerIndex);
+        }
+        release();
+        this.logger.debug(`Range lists after splitting ${JSON.stringify(this.workersRangeList)}`);
+        return newWorkers;
+    };
+    /**
+     * Get the last (biggest) processable range from the worker's range list
+     *
+     * After the last range is processed, the older ones are updated and usually
+     * become smaller. Some of them might shrink below a certain threshold, which
+     * means they can now be processed too.
+     * This function finds the biggest range that is small enough to be processed,
+     * and removes all of its child ranges from the list.
+     * Returns the last range if none of them is processable.
+     * @param workerIndex
+     * @param rangeThreshold
+     * @returns range query
+     */
+    getLastRange = async (workerIndex, rangeThreshold) => {
+        const rangeList = this.workersRangeList[workerIndex];
+        this.logger.debug(`Search range of worker-${workerIndex} is ${JSON.stringify(rangeList)}`);
+        let lastRangeQuery = rangeList.at(-1);
+        // avoid race condition when updating the shared `rangeList` variable
+        const release = await this.mutex.acquire();
+        // jump over small ranges to select the biggest processable range
+        while (rangeList.length > 1 &&
+            (rangeList.at(-2).count <= rangeThreshold || lastRangeQuery.count == 0)) {
+            rangeList.pop();
+            lastRangeQuery = rangeList.at(-1);
+        }
+        release();
+        return lastRangeQuery;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workerManager.js","sourceRoot":"","sources":["../../../../lib/ergo/initializers/strategies/workerManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAI5D,MAAM,OAAO,aAAa;IAOd;IACA;IACA;IARF,gBAAgB,CAAc;IAC9B,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;IACpB,kBAAkB,CAAS;IAC3B,SAAS,CAAU;IAE3B,YACU,WAAmB,EACnB,eAAgE,EAChE,SAAS,IAAI,WAAW,EAAE;QAF1B,gBAAW,GAAX,WAAW,CAAQ;QACnB,oBAAe,GAAf,eAAe,CAAiD;QAChE,WAAM,GAAN,MAAM,CAAoB;IACjC,CAAC;IAEJ;;;OAGG;IACH,KAAK,GAAG,CAAC,SAAiB,EAAE,EAAE;QAC5B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;QAC3E,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;IACzE,CAAC,CAAC;IAEF;;;;OAIG;IACH,cAAc,GAAG,CAAC,WAAmB,EAAW,EAAE;QAChD,OAAO,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IACvD,CAAC,CAAC;IAEF;;;;OAIG;IACH,cAAc,GAAG,KAAK,EAAE,WAAmB,EAAE,EAAE;QAC7C,IAAI,CAAC,IAAI,CAAC,SAAS;YACjB,MAAM,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAC9D,MAAM,KAAK,GAAG,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAClB,CAAC,WAAW,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,kBAAkB,GAAG,CAAC,EAC/C,IAAI,CAAC,SAAS,CACf,CAAC;QACF,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;QACnD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,UAAU,WAAW,+BAA+B,KAAK,KAAK,GAAG,GAAG,CACrE,CAAC;IACJ,CAAC,CAAC;IAEF;;;;;;OAMG;IACK,cAAc,GAAG,KAAK,EAC5B,WAAmB,EACnB,KAAa,EACb,GAAW,EACX,EAAE;QACF,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACrD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC;YACtC,KAAK;YACL,GAAG;YACH,KAAK;SACN,CAAC,CAAC;QACH,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IAEF;;;;OAIG;IACH,cAAc,GAAG,KAAK,EAAE,WAAmB,EAAE,EAAE;QAC7C,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,IAAI,CAAC,cAAc;YACjB,MAAM,KAAK,CAAC,uDAAuD,CAAC,CAAC;QACvE,MAAM,WAAW,GACf,IAAI,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,GAAG,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC3D,cAAc,CAAC,KAAK,CAAC;QACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,mDACE,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CACpC,GAAG,CACJ,CAAC;QACF,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IAC5E,CAAC,CAAC;IAEF;;;;OAIG;IACH,iBAAiB,GAAG,KAAK,EAAE,WAAmB,EAAE,EAAE;QAChD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,GAAG,EAAE,CAAC;QAChE,IAAI,CAAC,cAAc;YACjB,MAAM,KAAK,CAAC,uDAAuD,CAAC,CAAC;QACvE,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE;YACpD,UAAU,CAAC,KAAK,IAAI,cAAc,CAAC,KAAK,CAAC;YACzC,UAAU,CAAC,KAAK,GAAG,cAAc,CAAC,GAAG,GAAG,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QACH,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IAEF;;;;;OAKG;IACK,8BAA8B,GAAG,GAAuB,EAAE;QAChE,IAAI,YAAY,GAAG,CAAC,EAClB,iBAAiB,GAAG,SAAS,CAAC;QAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtD,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,YAAY,EAAE,CAAC;gBAC9D,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;gBAClC,iBAAiB,GAAG,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;QACD,OAAO,iBAAiB,CAAC;IAC3B,CAAC,CAAC;IAEF;;;;;;OAMG;IACH,mBAAmB,GAAG,KAAK,IAAuB,EAAE;QAClD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3C,MAAM,iBAAiB,GAAG,IAAI,CAAC,gBAAgB;aAC5C,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;aAC5D,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;QACnC,IAAI,iBAAiB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;YACzD,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,iBAAiB,EAAE,CAAC,CAAC;QAC7D,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,wCAAwC,IAAI,CAAC,SAAS,CACpD,IAAI,CAAC,gBAAgB,CACtB,EAAE,CACJ,CAAC;QACF,MAAM,UAAU,GAAa,EAAE,CAAC;QAChC,KAAK,MAAM,eAAe,IAAI,iBAAiB,EAAE,CAAC;YAChD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,6BAA6B,eAAe,EAAE,CAAC,CAAC;YAClE,MAAM,2BAA2B,GAAG,IAAI,CAAC,8BAA8B,EAAE,CAAC;YAC1E,IAAI,2BAA2B,IAAI,SAAS,EAAE,CAAC;gBAC7C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC;gBAC9D,MAAM;YACR,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,+BAA+B,IAAI,CAAC,SAAS,CAC3C,IAAI,CAAC,gBAAgB,CAAC,2BAA2B,CAAC,CACnD,EAAE,CACJ,CAAC;YACF,MAAM,iBAAiB,GACrB,IAAI,CAAC,gBAAgB,CAAC,2BAA2B,CAAC,CAAC,KAAK,EAAG,CAAC;YAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC;YACnE,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,GAAG;gBACvC;oBACE,KAAK,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC;oBACnB,GAAG,EAAE,iBAAiB,CAAC,GAAG;oBAC1B,KAAK,EAAE,iBAAiB,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;iBAC5C;aACF,CAAC;YACF,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,EAAE,CAAC;QACV,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,+BAA+B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CACvE,CAAC;QACF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;IAEF;;;;;;;;;;;;OAYG;IACH,YAAY,GAAG,KAAK,EAClB,WAAmB,EACnB,cAAsB,EACD,EAAE;QACvB,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,0BAA0B,WAAW,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CACxE,CAAC;QACF,IAAI,cAAc,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC;QACvC,qEAAqE;QACrE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3C,iEAAiE;QACjE,OACE,SAAS,CAAC,MAAM,GAAG,CAAC;YACpB,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC,KAAK,IAAI,cAAc,IAAI,cAAc,CAAC,KAAK,IAAI,CAAC,CAAC,EACxE,CAAC;YACD,SAAS,CAAC,GAAG,EAAG,CAAC;YACjB,cAAc,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC;QACrC,CAAC;QACD,OAAO,EAAE,CAAC;QACV,OAAO,cAAc,CAAC;IACxB,CAAC,CAAC;CACH","sourcesContent":["import { Mutex } from 'await-semaphore';\n\nimport { DummyLogger } from '@rosen-bridge/abstract-logger';\n\nimport { RangeList, RangeQuery } from '../../interfaces';\n\nexport class WorkerManager {\n  private workersRangeList: RangeList[];\n  private mutex = new Mutex();\n  private initialSegmentSize: number;\n  private maxHeight?: number;\n\n  constructor(\n    private workerCount: number,\n    private getRangeTxCount: (start: number, end: number) => Promise<number>,\n    private logger = new DummyLogger(),\n  ) {}\n\n  /**\n   * Setup the worker manager to start working\n   * @param maxHeight\n   */\n  setup = (maxHeight: number) => {\n    this.maxHeight = maxHeight;\n    this.workersRangeList = Array.from({ length: this.workerCount }, () => []);\n    this.initialSegmentSize = Math.ceil(this.maxHeight / this.workerCount);\n  };\n\n  /**\n   * Checks if the worker's search range is completed\n   * @param workerIndex\n   * @returns true if worker has an incomplete range to work on\n   */\n  isWorkerActive = (workerIndex: number): boolean => {\n    return this.workersRangeList[workerIndex].length > 0;\n  };\n\n  /**\n   * Register the worker for the first time\n   * splits the whole range equally between workers\n   * @param workerIndex\n   */\n  registerWorker = async (workerIndex: number) => {\n    if (!this.maxHeight)\n      throw Error('Please call setup before registering workers');\n    const start = workerIndex * this.initialSegmentSize;\n    const end = Math.min(\n      (workerIndex + 1) * this.initialSegmentSize - 1,\n      this.maxHeight,\n    );\n    await this.addWorkerRange(workerIndex, start, end);\n    this.logger.debug(\n      `Worker-${workerIndex} is initialized with range [${start}, ${end}]`,\n    );\n  };\n\n  /**\n   * Add a new range to the workers range list\n   * new range is a subset of all existing ranges\n   * @param workerIndex\n   * @param start\n   * @param end\n   */\n  private addWorkerRange = async (\n    workerIndex: number,\n    start: number,\n    end: number,\n  ) => {\n    const count = await this.getRangeTxCount(start, end);\n    const release = await this.mutex.acquire();\n    this.workersRangeList[workerIndex].push({\n      start,\n      end,\n      count,\n    });\n    release();\n  };\n\n  /**\n   * Limit the last range by adding a new range query to the workers range list\n   * the new range the first half of the last existing range\n   * @param workerIndex\n   */\n  limitLastRange = async (workerIndex: number) => {\n    const lastRangeQuery = this.workersRangeList[workerIndex].at(-1);\n    if (!lastRangeQuery)\n      throw Error('Impossible case, worker does not have any range query');\n    const newQueryEnd =\n      Math.floor((lastRangeQuery.end - lastRangeQuery.start) / 2) +\n      lastRangeQuery.start;\n    this.logger.debug(\n      `Limiting the range by adding a new range query [${\n        (lastRangeQuery.start, newQueryEnd)\n      }]`,\n    );\n    await this.addWorkerRange(workerIndex, lastRangeQuery.start, newQueryEnd);\n  };\n\n  /**\n   * Pop the last range query after being processed\n   * also update all older ranges and deduct the processed numbers\n   * @param workerIndex\n   */\n  popLastRangeQuery = async (workerIndex: number) => {\n    const release = await this.mutex.acquire();\n    const lastRangeQuery = this.workersRangeList[workerIndex].pop();\n    if (!lastRangeQuery)\n      throw Error('Impossible case, worker does not have any range query');\n    this.workersRangeList[workerIndex].map((rangeQuery) => {\n      rangeQuery.count -= lastRangeQuery.count;\n      rangeQuery.start = lastRangeQuery.end + 1;\n    });\n    release();\n  };\n\n  /**\n   * Find the biggest incomplete range list containing at least 2 ranges\n   * the range list must have at least two range so that it wont become empty\n   * after splitting the range between two workers\n   * @returns biggest incomplete range list index\n   */\n  private getBiggestIncompleteRangeIndex = (): number | undefined => {\n    let biggestRange = 0,\n      biggestRangeIndex = undefined;\n    for (let i = 0; i < this.workersRangeList.length; i++) {\n      const rangeList = this.workersRangeList[i];\n      if (rangeList.length > 1 && rangeList[0].count > biggestRange) {\n        biggestRange = rangeList[0].count;\n        biggestRangeIndex = i;\n      }\n    }\n    return biggestRangeIndex;\n  };\n\n  /**\n   * Check all workers and reassign incomplete ranges to the idle ones\n   * do nothing if all workers are active\n   * do nothing if there is no incomplete range list\n   * split the biggest range list between the current worker and the idle worker\n   * @returns\n   */\n  reassignIdleWorkers = async (): Promise<number[]> => {\n    this.logger.debug('Checking idle workers to reassign');\n    const release = await this.mutex.acquire();\n    const idleWorkerIndexes = this.workersRangeList\n      .map((_, index) => (this.isWorkerActive(index) ? -1 : index))\n      .filter((index) => index !== -1);\n    if (idleWorkerIndexes.length == 0) {\n      this.logger.debug(`There is no idle worker to reassign`);\n      release();\n      return [];\n    }\n    this.logger.debug(`Found idle workers ${idleWorkerIndexes}`);\n    this.logger.debug(\n      `Workers range lists before splitting ${JSON.stringify(\n        this.workersRangeList,\n      )}`,\n    );\n    const newWorkers: number[] = [];\n    for (const idleWorkerIndex of idleWorkerIndexes) {\n      this.logger.debug(`reassigning job to worker-${idleWorkerIndex}`);\n      const biggestIncompleteRangeIndex = this.getBiggestIncompleteRangeIndex();\n      if (biggestIncompleteRangeIndex == undefined) {\n        this.logger.debug(`there is no incomplete range to reassign`);\n        break;\n      }\n      this.logger.debug(\n        `biggest incomplete range is ${JSON.stringify(\n          this.workersRangeList[biggestIncompleteRangeIndex],\n        )}`,\n      );\n      const removedRangeQuery =\n        this.workersRangeList[biggestIncompleteRangeIndex].shift()!;\n      const head = this.workersRangeList[biggestIncompleteRangeIndex][0];\n      this.workersRangeList[idleWorkerIndex] = [\n        {\n          start: head.end + 1,\n          end: removedRangeQuery.end,\n          count: removedRangeQuery.count - head.count,\n        },\n      ];\n      newWorkers.push(idleWorkerIndex);\n    }\n    release();\n    this.logger.debug(\n      `Range lists after splitting ${JSON.stringify(this.workersRangeList)}`,\n    );\n    return newWorkers;\n  };\n\n  /**\n   * Get the last (biggest) processable range from the worker's range list\n   *\n   * After the last range is processed, the older ones are updated and usually\n   * become smaller. Some of them might shrink below a certain threshold, which\n   * means they can now be processed too.\n   * This function finds the biggest range that is small enough to be processed,\n   * and removes all of its child ranges from the list.\n   * Returns the last range if none of them is processable.\n   * @param workerIndex\n   * @param rangeThreshold\n   * @returns range query\n   */\n  getLastRange = async (\n    workerIndex: number,\n    rangeThreshold: number,\n  ): Promise<RangeQuery> => {\n    const rangeList = this.workersRangeList[workerIndex];\n    this.logger.debug(\n      `Search range of worker-${workerIndex} is ${JSON.stringify(rangeList)}`,\n    );\n    let lastRangeQuery = rangeList.at(-1)!;\n    // avoid race condition when updating the shared `rangeList` variable\n    const release = await this.mutex.acquire();\n    // jump over small ranges to select the biggest processable range\n    while (\n      rangeList.length > 1 &&\n      (rangeList.at(-2)!.count <= rangeThreshold || lastRangeQuery.count == 0)\n    ) {\n      rangeList.pop()!;\n      lastRangeQuery = rangeList.at(-1)!;\n    }\n    release();\n    return lastRangeQuery;\n  };\n}\n"]}

package/dist/ergo/interfaces.d.ts

@@ -1,15 +1,8 @@
-import { OutputBox, Transaction } from '@rosen-bridge/scanner-interfaces';
-export interface ErgoBox extends OutputBox {
-    blockId: string;
-    inclusionHeight: number;
-    spentBlockId?: string;
-    spentHeight?: number;
-    spentTransactionId?: string;
-    spentIndex?: number;
-}
+import { ErgoNetworkType, OutputBox, Transaction } from '@rosen-bridge/scanner-interfaces';
 export interface ExtendedTransaction extends Transaction {
     inclusionHeight: number;
     blockId: string;
+    inputs: OutputBox[];
 }
 export interface SpendInfo {
     boxId: string;
@@ -19,8 +12,12 @@ export interface SpendInfo {
         [key: string]: string;
     };
 }
-export interface AbstractBoxData {
-    boxId: string;
+export interface ExtendedSpendInfo extends SpendInfo {
+    height: number;
+    block: string;
+}
+export interface AbstractEntityData {
+    identifier: string;
     serialized: string;
 }
 export declare enum CallbackType {
@@ -29,19 +26,36 @@ export declare enum CallbackType {
     Spend = "spend",
     Delete = "delete"
 }
-export interface BoxInfo {
-    boxId: string;
+export interface EntityInfo {
+    identifier: string;
 }
-export type CallbackDataMap<ExtractedData extends AbstractBoxData> = {
-    [CallbackType.Update]: BoxInfo[];
+export type CallbackDataMap<ExtractedData extends AbstractEntityData> = {
+    [CallbackType.Update]: EntityInfo[];
     [CallbackType.Insert]: ExtractedData[];
     [CallbackType.Delete]: ExtractedData[];
-    [CallbackType.Spend]: BoxInfo[];
+    [CallbackType.Spend]: EntityInfo[];
 };
-export type CallbackMap<ExtractedData extends AbstractBoxData> = {
+export type CallbackMap<ExtractedData extends AbstractEntityData> = {
     [K in CallbackType]: (data: CallbackDataMap<ExtractedData>[K]) => void;
 };
 export type TxExtra = {
     [key: string]: string;
 };
+export interface RangeQuery {
+    start: number;
+    end: number;
+    count: number;
+}
+/**
+ * The range list is an array where each new range is a child of the previous
+ * one. So, any range in the list supersedes all the ranges that come after it.
+ * */
+export type RangeList = RangeQuery[];
+export interface InitializeOptions {
+    active: boolean;
+    type: ErgoNetworkType;
+    url: string;
+    address: string;
+    maxParallelRequests?: number;
+}
 //# sourceMappingURL=interfaces.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../lib/ergo/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE1E,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,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;IACd,MAAM,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,oBAAY,YAAY;IACtB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,eAAe,CAAC,aAAa,SAAS,eAAe,IAAI;IACnE,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACjC,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACvC,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACvC,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,eAAe,IAAI;KAC9D,CAAC,IAAI,YAAY,GAAG,CAAC,IAAI,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;CACvE,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC"}
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../lib/ergo/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,SAAS,EACT,WAAW,EACZ,MAAM,kCAAkC,CAAC;AAE1C,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACpC;AAED,MAAM,WAAW,iBAAkB,SAAQ,SAAS;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AACD,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,oBAAY,YAAY;IACtB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,eAAe,CAAC,aAAa,SAAS,kBAAkB,IAAI;IACtE,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;IACpC,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACvC,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;IACvC,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,aAAa,SAAS,kBAAkB,IAAI;KACjE,CAAC,IAAI,YAAY,GAAG,CAAC,IAAI,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;CACvE,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAEhD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;KAGK;AACL,MAAM,MAAM,SAAS,GAAG,UAAU,EAAE,CAAC;AAErC,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,eAAe,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B"}

package/dist/ergo/interfaces.js

@@ -5,4 +5,4 @@ export var CallbackType;
     CallbackType["Spend"] = "spend";
     CallbackType["Delete"] = "delete";
 })(CallbackType || (CallbackType = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ergo/networks/explorerNetwork.d.ts

@@ -0,0 +1,52 @@
+import { Transaction } from '@rosen-bridge/scanner-interfaces';
+import { ExtendedTransaction } from '../interfaces';
+export declare class ExplorerNetwork {
+    private api;
+    constructor(url: string);
+    /**
+     * convert explorer api output boxes to OutputBox interface
+     * @param box
+     * @returns OutputBox
+     */
+    private convertOutputBox;
+    /**
+     * convert explorer api input boxes to OutputBox interface
+     * @param box
+     * @returns OutputBox
+     */
+    private convertInputBox;
+    /**
+     * 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, limit?: number) => Promise<{
+        items: Array<ExtendedTransaction>;
+        total: number;
+    }>;
+    /**
+     * 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>>;
+}
+//# sourceMappingURL=explorerNetwork.d.ts.map

package/dist/ergo/networks/explorerNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorerNetwork.d.ts","sourceRoot":"","sources":["../../../lib/ergo/networks/explorerNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAK1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAC;gBAEA,GAAG,EAAE,MAAM;IAIvB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAetB;IAEF;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAerB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAexB;IAEF;;;OAGG;IACH,OAAO,CAAC,uBAAuB,CAuB7B;IAEF;;;;;;OAMG;IACH,gCAAgC,GAC9B,SAAS,MAAM,EACf,YAAY,MAAM,EAClB,UAAU,MAAM,EAChB,cAAiB,KAChB,OAAO,CAAC;QAAE,KAAK,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAc9D;IAEF;;;;OAIG;IACH,kBAAkB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAG1D;IAEF;;;;OAIG;IACH,WAAW,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAUhE;CACH"}