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

package/dist/ergo/networks/explorerNetwork.js

@@ -0,0 +1,127 @@
+import { mapValues, pick } from 'lodash-es';
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+import { API_LIMIT } from '../../constants';
+export class ExplorerNetwork {
+    api;
+    constructor(url) {
+        this.api = ergoExplorerClientFactory(url);
+    }
+    /**
+     * convert explorer api output boxes to OutputBox interface
+     * @param box
+     * @returns OutputBox
+     */
+    convertOutputBox = (box) => {
+        return {
+            boxId: box.boxId,
+            creationHeight: box.creationHeight,
+            ergoTree: box.ergoTree,
+            index: box.index,
+            transactionId: box.transactionId,
+            value: box.value,
+            additionalRegisters: mapValues(box.additionalRegisters, 'serializedValue'),
+            assets: box.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ?? [],
+        };
+    };
+    /**
+     * convert explorer api input boxes to OutputBox interface
+     * @param box
+     * @returns OutputBox
+     */
+    convertInputBox = (box) => {
+        return {
+            boxId: box.boxId,
+            creationHeight: box.outputCreatedAt,
+            ergoTree: box.ergoTree,
+            index: box.outputIndex,
+            transactionId: box.outputTransactionId,
+            value: box.value,
+            additionalRegisters: mapValues(box.additionalRegisters, 'serializedValue'),
+            assets: box.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ?? [],
+        };
+    };
+    /**
+     * convert explorer transaction to extractor transaction type
+     * @param tx
+     */
+    convertTransaction = (tx) => {
+        return {
+            id: tx.id,
+            inclusionHeight: tx.inclusionHeight,
+            blockId: tx.blockId,
+            dataInputs: tx.dataInputs?.map((dataInput) => ({
+                boxId: dataInput.boxId,
+            })) ?? [],
+            // TODO: Add input extension to explorer local/ergo/rosen-bridge/scanner/-/issues/156
+            inputs: tx.inputs?.map((input) => this.convertInputBox(input)) ?? [],
+            outputs: tx.outputs?.map((output) => this.convertOutputBox(output)) ?? [],
+        };
+    };
+    /**
+     * convert explorer block transaction to transaction type
+     * @param tx
+     */
+    convertBlockTransaction = (tx) => {
+        return {
+            id: tx.id,
+            dataInputs: tx.dataInputs?.map((dataInput) => ({
+                boxId: dataInput.id,
+            })) ?? [],
+            // TODO: Add input extension local/ergo/rosen-bridge/scanner/-/issues/156
+            inputs: tx.inputs?.map((input) => ({ boxId: input.id })) ?? [],
+            outputs: tx.outputs?.map((output) => ({
+                boxId: output.id,
+                transactionId: output.txId,
+                additionalRegisters: output.additionalRegisters,
+                assets: output.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ??
+                    [],
+                ergoTree: output.ergoTree,
+                creationHeight: output.creationHeight,
+                index: output.index,
+                value: output.value,
+            })) ?? [],
+        };
+    };
+    /**
+     * 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 = async (address, fromHeight, toHeight, limit = API_LIMIT) => {
+        const txs = await this.api.v1.getApiV1AddressesP1Transactions(address, {
+            fromHeight,
+            toHeight,
+            limit: limit,
+        });
+        if (!txs.items)
+            throw new Error('Explorer AddressTransactions api expected to have items');
+        return {
+            items: txs.items.map((tx) => this.convertTransaction(tx)),
+            total: txs.total,
+        };
+    };
+    /**
+     * use explorer api to get the block id at the specified height
+     * @param height
+     * @returns block id
+     */
+    getBlockIdAtHeight = async (height) => {
+        const id = await this.api.v0.getApiV0BlocksAtP1(height);
+        return id[0];
+    };
+    /**
+     * use explorer api to return all transactions in a block
+     * @param blockId
+     * @returns converted transactions
+     */
+    getBlockTxs = async (blockId) => {
+        const block = await this.api.v1.getApiV1BlocksP1(blockId);
+        if (!block.block.blockTransactions) {
+            throw new Error(`Expected explorer block api to include block transactions for block ${blockId}`);
+        }
+        return block.block.blockTransactions.map((tx) => this.convertBlockTransaction(tx));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"explorerNetwork.js","sourceRoot":"","sources":["../../../lib/ergo/networks/explorerNetwork.ts"],"names":[],"mappings":"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","sourcesContent":["import { mapValues, pick } from 'lodash-es';\n\nimport { OutputBox, Transaction } from '@rosen-bridge/scanner-interfaces';\nimport ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';\nimport { V1 } from '@rosen-clients/ergo-explorer';\n\nimport { API_LIMIT } from '../../constants';\nimport { ExtendedTransaction } from '../interfaces';\n\nexport class ExplorerNetwork {\n  private api;\n\n  constructor(url: string) {\n    this.api = ergoExplorerClientFactory(url);\n  }\n\n  /**\n   * convert explorer api output boxes to OutputBox interface\n   * @param box\n   * @returns OutputBox\n   */\n  private convertOutputBox = (box: V1.OutputInfo): OutputBox => {\n    return {\n      boxId: box.boxId,\n      creationHeight: box.creationHeight,\n      ergoTree: box.ergoTree,\n      index: box.index,\n      transactionId: box.transactionId,\n      value: box.value,\n      additionalRegisters: mapValues(\n        box.additionalRegisters,\n        'serializedValue',\n      ),\n      assets:\n        box.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ?? [],\n    };\n  };\n\n  /**\n   * convert explorer api input boxes to OutputBox interface\n   * @param box\n   * @returns OutputBox\n   */\n  private convertInputBox = (box: V1.InputInfo): OutputBox => {\n    return {\n      boxId: box.boxId,\n      creationHeight: box.outputCreatedAt,\n      ergoTree: box.ergoTree,\n      index: box.outputIndex,\n      transactionId: box.outputTransactionId,\n      value: box.value,\n      additionalRegisters: mapValues(\n        box.additionalRegisters,\n        'serializedValue',\n      ),\n      assets:\n        box.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ?? [],\n    };\n  };\n\n  /**\n   * convert explorer transaction to extractor transaction type\n   * @param tx\n   */\n  private convertTransaction = (\n    tx: V1.TransactionInfo,\n  ): ExtendedTransaction => {\n    return {\n      id: tx.id,\n      inclusionHeight: tx.inclusionHeight,\n      blockId: tx.blockId,\n      dataInputs:\n        tx.dataInputs?.map((dataInput) => ({\n          boxId: dataInput.boxId,\n        })) ?? [],\n      // TODO: Add input extension to explorer local/ergo/rosen-bridge/scanner/-/issues/156\n      inputs: tx.inputs?.map((input) => this.convertInputBox(input)) ?? [],\n      outputs: tx.outputs?.map((output) => this.convertOutputBox(output)) ?? [],\n    };\n  };\n\n  /**\n   * convert explorer block transaction to transaction type\n   * @param tx\n   */\n  private convertBlockTransaction = (tx: V1.TransactionInfo1): Transaction => {\n    return {\n      id: tx.id,\n      dataInputs:\n        tx.dataInputs?.map((dataInput) => ({\n          boxId: dataInput.id,\n        })) ?? [],\n      // TODO: Add input extension local/ergo/rosen-bridge/scanner/-/issues/156\n      inputs: tx.inputs?.map((input) => ({ boxId: input.id })) ?? [],\n      outputs:\n        tx.outputs?.map((output) => ({\n          boxId: output.id,\n          transactionId: output.txId,\n          additionalRegisters: output.additionalRegisters,\n          assets:\n            output.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ??\n            [],\n          ergoTree: output.ergoTree,\n          creationHeight: output.creationHeight,\n          index: output.index,\n          value: output.value,\n        })) ?? [],\n    };\n  };\n\n  /**\n   * use explorer api to return related transactions of the specified address in the height range\n   * @param tokenId\n   * @param offset\n   * @param limit\n   * @returns related transactions\n   */\n  getAddressTransactionsWithHeight = async (\n    address: string,\n    fromHeight: number,\n    toHeight: number,\n    limit = API_LIMIT,\n  ): Promise<{ items: Array<ExtendedTransaction>; total: number }> => {\n    const txs = await this.api.v1.getApiV1AddressesP1Transactions(address, {\n      fromHeight,\n      toHeight,\n      limit: limit,\n    });\n    if (!txs.items)\n      throw new Error(\n        'Explorer AddressTransactions api expected to have items',\n      );\n    return {\n      items: txs.items.map((tx) => this.convertTransaction(tx)),\n      total: txs.total,\n    };\n  };\n\n  /**\n   * use explorer api to get the block id at the specified height\n   * @param height\n   * @returns block id\n   */\n  getBlockIdAtHeight = async (height: number): Promise<string> => {\n    const id = await this.api.v0.getApiV0BlocksAtP1(height);\n    return id[0];\n  };\n\n  /**\n   * use explorer api to return all transactions in a block\n   * @param blockId\n   * @returns converted transactions\n   */\n  getBlockTxs = async (blockId: string): Promise<Array<Transaction>> => {\n    const block = await this.api.v1.getApiV1BlocksP1(blockId);\n    if (!block.block.blockTransactions) {\n      throw new Error(\n        `Expected explorer block api to include block transactions for block ${blockId}`,\n      );\n    }\n    return block.block.blockTransactions.map((tx) =>\n      this.convertBlockTransaction(tx),\n    );\n  };\n}\n"]}

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

@@ -0,0 +1,3 @@
+export * from './explorerNetwork';
+export * from './nodeNetwork';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/ergo/networks/index.js

@@ -0,0 +1,3 @@
+export * from './explorerNetwork';
+export * from './nodeNetwork';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby9uZXR3b3Jrcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9leHBsb3Jlck5ldHdvcmsnO1xuZXhwb3J0ICogZnJvbSAnLi9ub2RlTmV0d29yayc7XG4iXX0=

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

@@ -0,0 +1,28 @@
+import { ExtendedTransaction } from '../interfaces';
+export declare class NodeNetwork {
+    private api;
+    constructor(url: string);
+    /**
+     * convert node api boxes to OutputBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    private convertBox;
+    /**
+     * convert Node transaction to extractor transaction type
+     * @param tx
+     */
+    private convertTransaction;
+    /**
+     * use node api to return related transactions of the specified address with limit offset
+     * @param address
+     * @param offset
+     * @param limit
+     * @returns related transactions
+     */
+    getAddressTransactionsWithOffsetLimit: (address: string, offset: number, limit: number) => Promise<{
+        items: Array<ExtendedTransaction>;
+        total: number;
+    }>;
+}
+//# sourceMappingURL=nodeNetwork.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeNetwork.d.ts","sourceRoot":"","sources":["../../../lib/ergo/networks/nodeNetwork.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,qBAAa,WAAW;IACtB,OAAO,CAAC,GAAG,CAAC;gBAEA,GAAG,EAAE,MAAM;IAIvB;;;;OAIG;IACH,OAAO,CAAC,UAAU,CAWhB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAYxB;IAEF;;;;;;OAMG;IACH,qCAAqC,GACnC,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,OAAO,MAAM,KACZ,OAAO,CAAC;QAAE,KAAK,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAa9D;CACH"}

package/dist/ergo/networks/nodeNetwork.js

@@ -0,0 +1,59 @@
+import ergoNodeClientFactory from '@rosen-clients/ergo-node';
+export class NodeNetwork {
+    api;
+    constructor(url) {
+        this.api = ergoNodeClientFactory(url);
+    }
+    /**
+     * convert node api boxes to OutputBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    convertBox = (box) => {
+        return {
+            transactionId: box.transactionId || '',
+            index: box.index || 0,
+            value: box.value || 0n,
+            ergoTree: box.ergoTree || '',
+            creationHeight: box.creationHeight || 0,
+            assets: box.assets || [],
+            additionalRegisters: box.additionalRegisters,
+            boxId: box.boxId || '',
+        };
+    };
+    /**
+     * convert Node transaction to extractor transaction type
+     * @param tx
+     */
+    convertTransaction = (tx) => {
+        return {
+            id: tx.id || '',
+            inclusionHeight: tx.inclusionHeight,
+            blockId: tx.blockId,
+            outputs: tx.outputs.map((output) => this.convertBox(output)),
+            // TODO: Add input extension local/ergo/rosen-bridge/scanner/-/issues/156
+            inputs: tx.inputs.map((input) => this.convertBox(input)),
+            dataInputs: tx.dataInputs,
+        };
+    };
+    /**
+     * use node api to return related transactions of the specified address with limit offset
+     * @param address
+     * @param offset
+     * @param limit
+     * @returns related transactions
+     */
+    getAddressTransactionsWithOffsetLimit = async (address, offset, limit) => {
+        const txs = await this.api.getTxsByAddress(address, {
+            offset,
+            limit,
+        });
+        if (!txs.items)
+            throw new Error('Explorer AddressTransactions api expected to have items');
+        return {
+            items: txs.items.map((tx) => this.convertTransaction(tx)),
+            total: txs.total,
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ergo/utils.d.ts

@@ -1,3 +1,4 @@
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
 import { OutputBox } from '@rosen-bridge/scanner-interfaces';
 /**
  * Check box to have specified tokens
@@ -5,4 +6,18 @@ import { OutputBox } from '@rosen-bridge/scanner-interfaces';
  * @return true if box has the required token and false otherwise
  */
 export declare const boxHasToken: (box: OutputBox, tokenIds: string[]) => boolean;
+/**
+ * Create delay in procedures based on the specified time in milliseconds
+ * @param time
+ */
+export declare const delay: (time: number) => Promise<unknown>;
+/**
+ * Retry the request in case of failure
+ * Throw error if request fails after RETRIAL_COUNT retrials
+ * Wait for 1 second between each trial
+ * @param request
+ * @param logger
+ * @returns
+ */
+export declare const requestWithRetrial: <returnT>(request: () => Promise<returnT>, logger?: DummyLogger) => Promise<returnT>;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/ergo/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,SAAS,EAAE,UAAU,MAAM,EAAE,YAM7D,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/ergo/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAI7D;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,SAAS,EAAE,UAAU,MAAM,EAAE,YAM7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,KAAK,GAAU,MAAM,MAAM,qBACa,CAAC;AAEtD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAU,OAAO,EAC9C,SAAS,MAAM,OAAO,CAAC,OAAO,CAAC,EAC/B,oBAA0B,KACzB,OAAO,CAAC,OAAO,CAkBjB,CAAC"}

package/dist/ergo/utils.js

@@ -1,4 +1,6 @@
 import { intersection } from 'lodash-es';
+import { DummyLogger } from '@rosen-bridge/abstract-logger';
+import { RETRIAL_COUNT } from '../constants';
 /**
  * Check box to have specified tokens
  * @param box
@@ -13,4 +15,35 @@ export const boxHasToken = (box, tokenIds) => {
         return true;
     return false;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvZXJnby91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBSXpDOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsQ0FBQyxHQUFjLEVBQUUsUUFBa0IsRUFBRSxFQUFFO0lBQ2hFLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTTtRQUFFLE9BQU8sS0FBSyxDQUFDO0lBQzlCLE1BQU0sU0FBUyxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0QsTUFBTSxjQUFjLEdBQUcsWUFBWSxDQUFDLFFBQVEsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUN6RCxJQUFJLGNBQWMsQ0FBQyxNQUFNLElBQUksUUFBUSxDQUFDLE1BQU07UUFBRSxPQUFPLElBQUksQ0FBQztJQUMxRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGludGVyc2VjdGlvbiB9IGZyb20gJ2xvZGFzaC1lcyc7XG5cbmltcG9ydCB7IE91dHB1dEJveCB9IGZyb20gJ0Byb3Nlbi1icmlkZ2Uvc2Nhbm5lci1pbnRlcmZhY2VzJztcblxuLyoqXG4gKiBDaGVjayBib3ggdG8gaGF2ZSBzcGVjaWZpZWQgdG9rZW5zXG4gKiBAcGFyYW0gYm94XG4gKiBAcmV0dXJuIHRydWUgaWYgYm94IGhhcyB0aGUgcmVxdWlyZWQgdG9rZW4gYW5kIGZhbHNlIG90aGVyd2lzZVxuICovXG5leHBvcnQgY29uc3QgYm94SGFzVG9rZW4gPSAoYm94OiBPdXRwdXRCb3gsIHRva2VuSWRzOiBzdHJpbmdbXSkgPT4ge1xuICBpZiAoIWJveC5hc3NldHMpIHJldHVybiBmYWxzZTtcbiAgY29uc3QgYm94VG9rZW5zID0gYm94LmFzc2V0cy5tYXAoKHRva2VuKSA9PiB0b2tlbi50b2tlbklkKTtcbiAgY29uc3QgcmVxdWlyZWRUb2tlbnMgPSBpbnRlcnNlY3Rpb24odG9rZW5JZHMsIGJveFRva2Vucyk7XG4gIGlmIChyZXF1aXJlZFRva2Vucy5sZW5ndGggPT0gdG9rZW5JZHMubGVuZ3RoKSByZXR1cm4gdHJ1ZTtcbiAgcmV0dXJuIGZhbHNlO1xufTtcbiJdfQ==
+/**
+ * Create delay in procedures based on the specified time in milliseconds
+ * @param time
+ */
+export const delay = async (time) => new Promise((resolve) => setTimeout(resolve, time));
+/**
+ * Retry the request in case of failure
+ * Throw error if request fails after RETRIAL_COUNT retrials
+ * Wait for 1 second between each trial
+ * @param request
+ * @param logger
+ * @returns
+ */
+export const requestWithRetrial = async (request, logger = new DummyLogger()) => {
+    let trial = 0;
+    let lastErrorMessage;
+    while (trial < RETRIAL_COUNT) {
+        try {
+            const result = await request();
+            return result;
+        }
+        catch (e) {
+            lastErrorMessage = e instanceof Error ? e.message : String(e);
+            trial++;
+            logger.warn(`request failed with error ${lastErrorMessage}`);
+            logger.debug(`Retrying the request with retrial step ${trial}`);
+            await delay(1000);
+        }
+    }
+    throw new Error(`request failed after ${trial} retrials with error: ${lastErrorMessage}`);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/abstract-extractor",
-  "version": "2.1.2",
+  "version": "3.0.0-8f3c7016",
   "description": "Rosen Bridge extractor interfaces to work with scanner",
   "repository": {
     "type": "git",
@@ -34,7 +34,9 @@
     "@rosen-bridge/scanner-interfaces": "^0.2.1",
     "@rosen-clients/ergo-explorer": "^2.1.0",
     "@rosen-clients/ergo-node": "^3.1.0",
+    "await-semaphore": "^0.1.3",
     "lodash-es": "^4.17.21",
+    "p-queue": "^9.0.0",
     "uuid": "^9.0.0"
   },
   "devDependencies": {

package/dist/ergo/abstractErgoExtractor.d.ts

@@ -1,80 +0,0 @@
-import { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';
-import { Transaction, OutputBox, InputExtension, BlockInfo } from '@rosen-bridge/scanner-interfaces';
-import { AbstractExtractor } from '../abstractExtractor';
-import { AbstractErgoExtractorAction } from './abstractErgoExtractorAction';
-import { AbstractErgoExtractorEntity } from './abstractErgoExtractorEntity';
-import { AbstractBoxData, CallbackType, CallbackMap, CallbackDataMap, TxExtra } from './interfaces';
-export declare abstract class AbstractErgoExtractor<ExtractedData extends AbstractBoxData, ExtractorEntity extends AbstractErgoExtractorEntity> extends AbstractExtractor<Transaction> {
-    protected abstract actions: AbstractErgoExtractorAction<ExtractedData, ExtractorEntity>;
-    protected logger: AbstractLogger;
-    protected callbacks: {
-        [K in CallbackType]: Map<string, CallbackMap<ExtractedData>[K]>;
-    };
-    private callbackMutex;
-    constructor(logger?: DummyLogger);
-    /**
-     * hook a new callback on a callback type
-     * @param type
-     * @param id
-     * @param callback
-     * @returns callback registered id
-     */
-    hook: <T extends CallbackType>(type: T, callback: CallbackMap<ExtractedData>[T]) => Promise<string>;
-    /**
-     * unhook a callback on a type
-     * returns false if there is no registered callback with the id
-     * @param type
-     * @param id
-     * @returns success status
-     */
-    unhook: (type: CallbackType, id: string) => Promise<boolean>;
-    /**
-     * trigger all callbacks registered on a specific type with the provided data
-     * @param type
-     * @param data
-     */
-    protected triggerCallbacks<T extends CallbackType>(type: T, data: CallbackDataMap<ExtractedData>[T]): void;
-    /**
-     * extract box data to proper format (not including spending information)
-     * @param box
-     * @param inputExtensions all input box extensions in transaction
-     * @return extracted data in proper format
-     */
-    abstract extractBoxData: (box: OutputBox, inputExtensions: InputExtension[], txExtra?: TxExtra) => ExtractedData | undefined;
-    /**
-     * check proper data format in the box
-     * @param box
-     * @return true if the box has the required data and false otherwise
-     */
-    abstract hasData: (box: OutputBox) => boolean;
-    /**
-     * create spend info array for the transaction
-     * @param tx
-     * @returns spend info array of the transaction
-     */
-    getTransactionSpendInfo: (tx: Transaction) => {
-        txId: string;
-        boxId: string;
-        index: number;
-    }[];
-    /**
-     * extract transaction extra information
-     * override this function if there is extra needed information
-     * @param tx
-     * @returns
-     */
-    getTransactionExtraData: (tx: Transaction) => TxExtra;
-    /**
-     * process a list of transactions in a block and store required information
-     * @param txs list of transactions in the block
-     * @param block
-     * @return true if the process is completed successfully and false otherwise
-     */
-    processTransactions: (txs: Transaction[], block: BlockInfo) => Promise<boolean>;
-    /**
-     * fork one block and remove all stored information for this block
-     * @param hash block hash
-     */
-    forkBlock: (hash: string) => Promise<void>;
-}
-//# sourceMappingURL=abstractErgoExtractor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"abstractErgoExtractor.d.ts","sourceRoot":"","sources":["../../lib/ergo/abstractErgoExtractor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,EACL,WAAW,EACX,SAAS,EACT,cAAc,EACd,SAAS,EACV,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,eAAe,EAEf,YAAY,EACZ,WAAW,EACX,eAAe,EACf,OAAO,EACR,MAAM,cAAc,CAAC;AAEtB,8BAAsB,qBAAqB,CACzC,aAAa,SAAS,eAAe,EACrC,eAAe,SAAS,2BAA2B,CACnD,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CACrD,aAAa,EACb,eAAe,CAChB,CAAC;IACF,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;IACjC,SAAS,CAAC,SAAS,EAAE;SAClB,CAAC,IAAI,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;KAChE,CAKC;IACF,OAAO,CAAC,aAAa,CAAe;gBAExB,MAAM,cAAoB;IAKtC;;;;;;OAMG;IACH,IAAI,GAAU,CAAC,SAAS,YAAY,EAClC,MAAM,CAAC,EACP,UAAU,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KACtC,OAAO,CAAC,MAAM,CAAC,CAOhB;IAEF;;;;;;OAMG;IACH,MAAM,GAAU,MAAM,YAAY,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CAY/D;IAEF;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,SAAS,YAAY,EAC/C,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GACtC,IAAI;IAOP;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,SAAS,EACd,eAAe,EAAE,cAAc,EAAE,EACjC,OAAO,CAAC,EAAE,OAAO,KACd,aAAa,GAAG,SAAS,CAAC;IAE/B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC;IAE9C;;;;OAIG;IACH,uBAAuB,GAAI,IAAI,WAAW;;;;QAQxC;IAEF;;;;;OAKG;IACH,uBAAuB,GACrB,IAAI,WAAW,KACd,OAAO,CAER;IAEF;;;;;OAKG;IACH,mBAAmB,GACjB,KAAK,WAAW,EAAE,EAClB,OAAO,SAAS,KACf,OAAO,CAAC,OAAO,CAAC,CAwDjB;IAEF;;;OAGG;IACH,SAAS,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC,CAM7C;CACH"}

package/dist/ergo/abstractErgoExtractor.js

@@ -1,142 +0,0 @@
-import { Mutex } from 'await-semaphore';
-import { v4 as uuidv4 } from 'uuid';
-import { DummyLogger } from '@rosen-bridge/abstract-logger';
-import JsonBigInt from '@rosen-bridge/json-bigint';
-import { AbstractExtractor } from '../abstractExtractor';
-import { CallbackType, } from './interfaces';
-export class AbstractErgoExtractor extends AbstractExtractor {
-    logger;
-    callbacks = {
-        [CallbackType.Update]: new Map(),
-        [CallbackType.Insert]: new Map(),
-        [CallbackType.Delete]: new Map(),
-        [CallbackType.Spend]: new Map(),
-    };
-    callbackMutex = new Mutex();
-    constructor(logger = new DummyLogger()) {
-        super();
-        this.logger = logger;
-    }
-    /**
-     * hook a new callback on a callback type
-     * @param type
-     * @param id
-     * @param callback
-     * @returns callback registered id
-     */
-    hook = async (type, callback) => {
-        const release = await this.callbackMutex.acquire();
-        const callbackMap = this.callbacks[type];
-        const id = uuidv4();
-        callbackMap.set(id, callback);
-        release();
-        return id;
-    };
-    /**
-     * unhook a callback on a type
-     * returns false if there is no registered callback with the id
-     * @param type
-     * @param id
-     * @returns success status
-     */
-    unhook = async (type, id) => {
-        const release = await this.callbackMutex.acquire();
-        const callbackMap = this.callbacks[type];
-        if (!callbackMap.has(id)) {
-            this.logger.warn(`Callback with Id [${id}] is not registered for type [${type}].`);
-            return false;
-        }
-        callbackMap.delete(id);
-        release();
-        return true;
-    };
-    /**
-     * trigger all callbacks registered on a specific type with the provided data
-     * @param type
-     * @param data
-     */
-    triggerCallbacks(type, data) {
-        const callbackMap = this.callbacks[type];
-        callbackMap.forEach((callback) => {
-            callback(data);
-        });
-    }
-    /**
-     * create spend info array for the transaction
-     * @param tx
-     * @returns spend info array of the transaction
-     */
-    getTransactionSpendInfo = (tx) => {
-        let boxIndex = 1;
-        const spendInfoArray = [];
-        for (const input of tx.inputs) {
-            spendInfoArray.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });
-            boxIndex += 1;
-        }
-        return spendInfoArray;
-    };
-    /**
-     * extract transaction extra information
-     * override this function if there is extra needed information
-     * @param tx
-     * @returns
-     */
-    getTransactionExtraData = (tx) => {
-        return {};
-    };
-    /**
-     * process a list of transactions in a block and store required information
-     * @param txs list of transactions in the block
-     * @param block
-     * @return true if the process is completed successfully and false otherwise
-     */
-    processTransactions = async (txs, block) => {
-        try {
-            const boxes = [];
-            const spentInfos = [];
-            for (const tx of txs) {
-                const inputExtensions = tx.inputs.map((input) => input.extension || {});
-                for (const output of tx.outputs) {
-                    if (!this.hasData(output)) {
-                        continue;
-                    }
-                    this.logger.debug(`Trying to extract data from box ${output.boxId}`);
-                    const extractedData = this.extractBoxData(output, inputExtensions, this.getTransactionExtraData(tx));
-                    if (extractedData) {
-                        this.logger.debug(`Extracted data ${JsonBigInt.stringify(extractedData)} from box ${output.boxId}`);
-                        boxes.push(extractedData);
-                    }
-                }
-                spentInfos.push(...this.getTransactionSpendInfo(tx));
-            }
-            if (boxes.length > 0) {
-                if (!(await this.actions.storeBoxes(boxes, block, this.getId()))) {
-                    this.logger.warn(`Data insertion failed for ${this.getId()} at the block ${block.height}`);
-                    return false;
-                }
-                this.triggerCallbacks(CallbackType.Insert, boxes);
-            }
-            const spentData = await this.actions.spendBoxes(spentInfos, block, this.getId());
-            if (spentData.length > 0) {
-                this.triggerCallbacks(CallbackType.Spend, spentData);
-            }
-        }
-        catch (e) {
-            this.logger.error(`Processing transactions failed for ${this.getId()} at the block ${block.height} with error: ${e}`);
-            return false;
-        }
-        return true;
-    };
-    /**
-     * fork one block and remove all stored information for this block
-     * @param hash block hash
-     */
-    forkBlock = async (hash) => {
-        const result = await this.actions.deleteBlockBoxes(hash, this.getId());
-        if (result.deletedData.length > 0)
-            this.triggerCallbacks(CallbackType.Delete, result.deletedData);
-        if (result.updatedData.length > 0)
-            this.triggerCallbacks(CallbackType.Update, result.updatedData);
-    };
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractErgoExtractor.js","sourceRoot":"","sources":["../../lib/ergo/abstractErgoExtractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Mutex } from 'await-semaphore';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport { AbstractLogger, DummyLogger } from '@rosen-bridge/abstract-logger';\nimport JsonBigInt from '@rosen-bridge/json-bigint';\nimport {\n  Transaction,\n  OutputBox,\n  InputExtension,\n  BlockInfo,\n} from '@rosen-bridge/scanner-interfaces';\n\nimport { AbstractExtractor } from '../abstractExtractor';\nimport { AbstractErgoExtractorAction } from './abstractErgoExtractorAction';\nimport { AbstractErgoExtractorEntity } from './abstractErgoExtractorEntity';\nimport {\n  AbstractBoxData,\n  SpendInfo,\n  CallbackType,\n  CallbackMap,\n  CallbackDataMap,\n  TxExtra,\n} from './interfaces';\n\nexport abstract class AbstractErgoExtractor<\n  ExtractedData extends AbstractBoxData,\n  ExtractorEntity extends AbstractErgoExtractorEntity,\n> extends AbstractExtractor<Transaction> {\n  protected abstract actions: AbstractErgoExtractorAction<\n    ExtractedData,\n    ExtractorEntity\n  >;\n  protected logger: AbstractLogger;\n  protected callbacks: {\n    [K in CallbackType]: Map<string, CallbackMap<ExtractedData>[K]>;\n  } = {\n    [CallbackType.Update]: new Map(),\n    [CallbackType.Insert]: new Map(),\n    [CallbackType.Delete]: new Map(),\n    [CallbackType.Spend]: new Map(),\n  };\n  private callbackMutex = new Mutex();\n\n  constructor(logger = new DummyLogger()) {\n    super();\n    this.logger = logger;\n  }\n\n  /**\n   * hook a new callback on a callback type\n   * @param type\n   * @param id\n   * @param callback\n   * @returns callback registered id\n   */\n  hook = async <T extends CallbackType>(\n    type: T,\n    callback: CallbackMap<ExtractedData>[T],\n  ): Promise<string> => {\n    const release = await this.callbackMutex.acquire();\n    const callbackMap = this.callbacks[type];\n    const id = uuidv4();\n    callbackMap.set(id, callback);\n    release();\n    return id;\n  };\n\n  /**\n   * unhook a callback on a type\n   * returns false if there is no registered callback with the id\n   * @param type\n   * @param id\n   * @returns success status\n   */\n  unhook = async (type: CallbackType, id: string): Promise<boolean> => {\n    const release = await this.callbackMutex.acquire();\n    const callbackMap = this.callbacks[type];\n    if (!callbackMap.has(id)) {\n      this.logger.warn(\n        `Callback with Id [${id}] is not registered for type [${type}].`,\n      );\n      return false;\n    }\n    callbackMap.delete(id);\n    release();\n    return true;\n  };\n\n  /**\n   * trigger all callbacks registered on a specific type with the provided data\n   * @param type\n   * @param data\n   */\n  protected triggerCallbacks<T extends CallbackType>(\n    type: T,\n    data: CallbackDataMap<ExtractedData>[T],\n  ): void {\n    const callbackMap = this.callbacks[type];\n    callbackMap.forEach((callback) => {\n      callback(data);\n    });\n  }\n\n  /**\n   * extract box data to proper format (not including spending information)\n   * @param box\n   * @param inputExtensions all input box extensions in transaction\n   * @return extracted data in proper format\n   */\n  abstract extractBoxData: (\n    box: OutputBox,\n    inputExtensions: InputExtension[],\n    txExtra?: TxExtra,\n  ) => ExtractedData | undefined;\n\n  /**\n   * check proper data format in the box\n   * @param box\n   * @return true if the box has the required data and false otherwise\n   */\n  abstract hasData: (box: OutputBox) => boolean;\n\n  /**\n   * create spend info array for the transaction\n   * @param tx\n   * @returns spend info array of the transaction\n   */\n  getTransactionSpendInfo = (tx: Transaction) => {\n    let boxIndex = 1;\n    const spendInfoArray = [];\n    for (const input of tx.inputs) {\n      spendInfoArray.push({ txId: tx.id, boxId: input.boxId, index: boxIndex });\n      boxIndex += 1;\n    }\n    return spendInfoArray;\n  };\n\n  /**\n   * extract transaction extra information\n   * override this function if there is extra needed information\n   * @param tx\n   * @returns\n   */\n  getTransactionExtraData = (\n    tx: Transaction, // eslint-disable-line @typescript-eslint/no-unused-vars\n  ): TxExtra => {\n    return {};\n  };\n\n  /**\n   * process a list of transactions in a block and store required information\n   * @param txs list of transactions in the block\n   * @param block\n   * @return true if the process is completed successfully and false otherwise\n   */\n  processTransactions = async (\n    txs: Transaction[],\n    block: BlockInfo,\n  ): Promise<boolean> => {\n    try {\n      const boxes: Array<ExtractedData> = [];\n      const spentInfos: Array<SpendInfo> = [];\n      for (const tx of txs) {\n        const inputExtensions = tx.inputs.map((input) => input.extension || {});\n        for (const output of tx.outputs) {\n          if (!this.hasData(output)) {\n            continue;\n          }\n          this.logger.debug(`Trying to extract data from box ${output.boxId}`);\n          const extractedData = this.extractBoxData(\n            output,\n            inputExtensions,\n            this.getTransactionExtraData(tx),\n          );\n          if (extractedData) {\n            this.logger.debug(\n              `Extracted data ${JsonBigInt.stringify(extractedData)} from box ${\n                output.boxId\n              }`,\n            );\n            boxes.push(extractedData);\n          }\n        }\n        spentInfos.push(...this.getTransactionSpendInfo(tx));\n      }\n\n      if (boxes.length > 0) {\n        if (!(await this.actions.storeBoxes(boxes, block, this.getId()))) {\n          this.logger.warn(\n            `Data insertion failed for ${this.getId()} at the block ${\n              block.height\n            }`,\n          );\n          return false;\n        }\n        this.triggerCallbacks(CallbackType.Insert, boxes);\n      }\n      const spentData = await this.actions.spendBoxes(\n        spentInfos,\n        block,\n        this.getId(),\n      );\n      if (spentData.length > 0) {\n        this.triggerCallbacks(CallbackType.Spend, spentData);\n      }\n    } catch (e) {\n      this.logger.error(\n        `Processing transactions failed for ${this.getId()} at the block ${\n          block.height\n        } with error: ${e}`,\n      );\n      return false;\n    }\n    return true;\n  };\n\n  /**\n   * fork one block and remove all stored information for this block\n   * @param hash block hash\n   */\n  forkBlock = async (hash: string): Promise<void> => {\n    const result = await this.actions.deleteBlockBoxes(hash, this.getId());\n    if (result.deletedData.length > 0)\n      this.triggerCallbacks(CallbackType.Delete, result.deletedData);\n    if (result.updatedData.length > 0)\n      this.triggerCallbacks(CallbackType.Update, result.updatedData);\n  };\n}\n"]}