@rosen-bridge/abstract-extractor 2.0.1 → 2.0.3-52fc0239

package/dist/lib/ergo/network/ExplorerNetwork.js

@@ -0,0 +1,185 @@
+import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';
+import { AbstractNetwork } from './AbstractNetwork';
+import { mapValues, pick } from 'lodash-es';
+import { API_LIMIT } from '../../constants';
+export class ExplorerNetwork extends AbstractNetwork {
+    api;
+    constructor(url) {
+        super();
+        this.api = ergoExplorerClientFactory(url);
+    }
+    /**
+     * return spending information of a specified box by having spendTxId
+     * @param boxId
+     * @param spendTxId
+     */
+    getSpendingInfo = async (boxId, spendTxId) => {
+        const tx = await this.api.v1.getApiV1TransactionsP1(spendTxId);
+        const spendIndex = tx.inputs?.findIndex((box) => box.boxId === boxId);
+        if (spendIndex == undefined)
+            throw Error(`Impossible behavior, the box [${boxId}] should have been spent in tx [${spendTxId}]`);
+        return {
+            hash: tx.blockId,
+            height: tx.inclusionHeight,
+            spendIndex,
+        };
+    };
+    /**
+     * convert explorer api boxes to ErgoBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    convertBox = async (box) => {
+        const spendInfo = box.spentTransactionId
+            ? await this.getSpendingInfo(box.boxId, box.spentTransactionId)
+            : undefined;
+        return {
+            blockId: box.blockId,
+            boxId: box.boxId,
+            creationHeight: box.creationHeight,
+            inclusionHeight: box.settlementHeight,
+            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'])) ?? [],
+            spentHeight: spendInfo?.height,
+            spentBlockId: spendInfo?.hash,
+            spentTransactionId: box.spentTransactionId,
+            spentIndex: spendInfo?.spendIndex,
+        };
+    };
+    /**
+     * 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) => ({ boxId: input.boxId })) ?? [],
+            outputs: tx.outputs?.map((output) => ({
+                boxId: output.boxId,
+                transactionId: output.transactionId,
+                additionalRegisters: mapValues(output.additionalRegisters, 'serializedValue'),
+                assets: output.assets?.map((asset) => pick(asset, ['tokenId', 'amount'])) ??
+                    [],
+                ergoTree: output.ergoTree,
+                creationHeight: output.creationHeight,
+                index: output.index,
+                value: output.value,
+            })) ?? [],
+        };
+    };
+    /**
+     * 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) => {
+        const txs = await this.api.v1.getApiV1AddressesP1Transactions(address, {
+            fromHeight,
+            toHeight,
+            limit: API_LIMIT,
+        });
+        if (!txs.items)
+            throw new Error('Explorer AddressTransactions api expected to have items');
+        return txs.items.map((tx) => this.convertTransaction(tx));
+    };
+    /**
+     * 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));
+    };
+    /**
+     * use explorer api to return related boxes by specified address
+     * @param address
+     * @param offset
+     * @param limit
+     * @returns related boxes
+     */
+    getBoxesByAddress = async (address, offset, limit) => {
+        const boxes = await this.api.v1.getApiV1BoxesUnspentByaddressP1(address, {
+            offset: offset,
+            limit: limit,
+            sortDirection: 'desc',
+        });
+        if (!boxes.items)
+            throw new Error('Explorer BoxesByAddress api expected to have items');
+        const resultBoxes = [];
+        for (const box of boxes.items) {
+            resultBoxes.push(await this.convertBox(box));
+        }
+        return { boxes: resultBoxes, hasNextBatch: boxes.total > offset + limit };
+    };
+    /**
+     * use explorer api to return related boxes by specified token id
+     * @param tokenId
+     * @param offset
+     * @param limit
+     * @returns related boxes
+     */
+    getBoxesByTokenId = async (tokenId, offset, limit) => {
+        const boxes = await this.api.v1.getApiV1BoxesBytokenidP1(tokenId, {
+            offset: offset,
+            limit: limit,
+        });
+        if (!boxes.items)
+            throw new Error('Explorer BoxesByTokeId api expected to have items');
+        const resultBoxes = [];
+        for (const box of boxes.items) {
+            resultBoxes.push(await this.convertBox(box));
+        }
+        return { boxes: resultBoxes, hasNextBatch: boxes.total > offset + limit };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExplorerNetwork.js","sourceRoot":"","sources":["../../../../lib/ergo/network/ExplorerNetwork.ts"],"names":[],"mappings":"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","sourcesContent":["import ergoExplorerClientFactory from '@rosen-clients/ergo-explorer';\nimport { AbstractNetwork } from './AbstractNetwork';\nimport { V1 } from '@rosen-clients/ergo-explorer';\nimport { BlockInfo, Transaction } from '@rosen-bridge/scanner-interfaces';\n\nimport { ErgoBox, ExtendedTransaction } from '../interfaces';\nimport { mapValues, pick } from 'lodash-es';\nimport { API_LIMIT } from '../../constants';\n\nexport class ExplorerNetwork extends AbstractNetwork {\n  private api;\n\n  constructor(url: string) {\n    super();\n    this.api = ergoExplorerClientFactory(url);\n  }\n\n  /**\n   * return spending information of a specified box by having spendTxId\n   * @param boxId\n   * @param spendTxId\n   */\n  getSpendingInfo = async (\n    boxId: string,\n    spendTxId: string\n  ): Promise<BlockInfo & { spendIndex: number }> => {\n    const tx = await this.api.v1.getApiV1TransactionsP1(spendTxId);\n    const spendIndex = tx.inputs?.findIndex((box) => box.boxId === boxId);\n    if (spendIndex == undefined)\n      throw Error(\n        `Impossible behavior, the box [${boxId}] should have been spent in tx [${spendTxId}]`\n      );\n    return {\n      hash: tx.blockId,\n      height: tx.inclusionHeight,\n      spendIndex,\n    };\n  };\n\n  /**\n   * convert explorer api boxes to ErgoBox interface\n   * @param box\n   * @returns ErgoBox\n   */\n  private convertBox = async (box: V1.OutputInfo): Promise<ErgoBox> => {\n    const spendInfo = box.spentTransactionId\n      ? await this.getSpendingInfo(box.boxId, box.spentTransactionId)\n      : undefined;\n    return {\n      blockId: box.blockId,\n      boxId: box.boxId,\n      creationHeight: box.creationHeight,\n      inclusionHeight: box.settlementHeight,\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      spentHeight: spendInfo?.height,\n      spentBlockId: spendInfo?.hash,\n      spentTransactionId: box.spentTransactionId,\n      spentIndex: spendInfo?.spendIndex,\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) => ({ boxId: input.boxId })) ?? [],\n      outputs:\n        tx.outputs?.map((output) => ({\n          boxId: output.boxId,\n          transactionId: output.transactionId,\n          additionalRegisters: mapValues(\n            output.additionalRegisters,\n            'serializedValue'\n          ),\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   * 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  ): Promise<Array<ExtendedTransaction>> => {\n    const txs = await this.api.v1.getApiV1AddressesP1Transactions(address, {\n      fromHeight,\n      toHeight,\n      limit: API_LIMIT,\n    });\n    if (!txs.items)\n      throw new Error(\n        'Explorer AddressTransactions api expected to have items'\n      );\n    return txs.items.map((tx) => this.convertTransaction(tx));\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  /**\n   * use explorer api to return related boxes by specified address\n   * @param address\n   * @param offset\n   * @param limit\n   * @returns related boxes\n   */\n  getBoxesByAddress = async (\n    address: string,\n    offset: number,\n    limit: number\n  ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {\n    const boxes = await this.api.v1.getApiV1BoxesUnspentByaddressP1(address, {\n      offset: offset,\n      limit: limit,\n      sortDirection: 'desc',\n    });\n    if (!boxes.items)\n      throw new Error('Explorer BoxesByAddress api expected to have items');\n    const resultBoxes: Array<ErgoBox> = [];\n    for (const box of boxes.items) {\n      resultBoxes.push(await this.convertBox(box));\n    }\n    return { boxes: resultBoxes, hasNextBatch: boxes.total > offset + limit };\n  };\n\n  /**\n   * use explorer api to return related boxes by specified token id\n   * @param tokenId\n   * @param offset\n   * @param limit\n   * @returns related boxes\n   */\n  getBoxesByTokenId = async (\n    tokenId: string,\n    offset: number,\n    limit: number\n  ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {\n    const boxes = await this.api.v1.getApiV1BoxesBytokenidP1(tokenId, {\n      offset: offset,\n      limit: limit,\n    });\n    if (!boxes.items)\n      throw new Error('Explorer BoxesByTokeId api expected to have items');\n    const resultBoxes: Array<ErgoBox> = [];\n    for (const box of boxes.items) {\n      resultBoxes.push(await this.convertBox(box));\n    }\n    return { boxes: resultBoxes, hasNextBatch: boxes.total > offset + limit };\n  };\n}\n"]}

package/dist/lib/ergo/network/NodeNetwork.d.ts

@@ -0,0 +1,60 @@
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { ErgoBox, ExtendedTransaction } from '../interfaces';
+import { AbstractNetwork } from './AbstractNetwork';
+export declare class NodeNetwork extends AbstractNetwork {
+    private api;
+    constructor(url: string);
+    /**
+     * convert node api boxes to ErgoBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    private convertBox;
+    /**
+     * convert Node transaction to extractor transaction type
+     * @param tx
+     */
+    private convertTransaction;
+    /**
+     * return spending information of a specified box by having spendTxId
+     * @param boxId
+     * @param spendTxId
+     */
+    getSpendingInfo: (boxId: string, spendTxId: string) => Promise<BlockInfo & {
+        spendIndex: number;
+    }>;
+    /**
+     * use node api to return related boxes by specified address
+     * @param address
+     * @param offset
+     * @param limit
+     * @returns related boxes
+     */
+    getBoxesByAddress: (address: string, offset: number, limit: number) => Promise<{
+        boxes: ErgoBox[];
+        hasNextBatch: boolean;
+    }>;
+    /**
+     * use node api to return related boxes by specified token id
+     * @param tokenId
+     * @param offset
+     * @param limit
+     * @returns related boxes
+     */
+    getBoxesByTokenId: (tokenId: string, offset: number, limit: number) => Promise<{
+        boxes: ErgoBox[];
+        hasNextBatch: boolean;
+    }>;
+    /**
+     * use node api to return related transactions of the specified address with limit offset
+     * @param tokenId
+     * @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/lib/ergo/network/NodeNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeNetwork.d.ts","sourceRoot":"","sources":["../../../../lib/ergo/network/NodeNetwork.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,OAAO,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,GAAG,CAAC;gBAEA,GAAG,EAAE,MAAM;IAKvB;;;;OAIG;IACH,OAAO,CAAC,UAAU,CAqBhB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAqBxB;IAEF;;;;OAIG;IACH,eAAe,UACN,MAAM,aACF,MAAM;oBACkB,MAAM;OAYzC;IAEF;;;;;;OAMG;IACH,iBAAiB,YACN,MAAM,UACP,MAAM,SACP,MAAM;eACK,OAAO,EAAE;sBAAgB,OAAO;OAYlD;IAEF;;;;;;OAMG;IACH,iBAAiB,YACN,MAAM,UACP,MAAM,SACP,MAAM;eACK,OAAO,EAAE;sBAAgB,OAAO;OAWlD;IAEF;;;;;;OAMG;IACH,qCAAqC,YAC1B,MAAM,UACP,MAAM,SACP,MAAM,KACZ,QAAQ;QAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAa9D;CACH"}

package/dist/lib/ergo/network/NodeNetwork.js

@@ -0,0 +1,131 @@
+import ergoNodeClientFactory from '@rosen-clients/ergo-node';
+import { AbstractNetwork } from './AbstractNetwork';
+export class NodeNetwork extends AbstractNetwork {
+    api;
+    constructor(url) {
+        super();
+        this.api = ergoNodeClientFactory(url);
+    }
+    /**
+     * convert node api boxes to ErgoBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    convertBox = async (box) => {
+        const tx = await await this.api.getTxById(box.transactionId);
+        const spendInfo = box.spentTransactionId
+            ? await this.getSpendingInfo(box.boxId, box.spentTransactionId)
+            : undefined;
+        return {
+            transactionId: box.transactionId || '',
+            index: box.index || 0,
+            value: box.value || 0n,
+            ergoTree: box.ergoTree || '',
+            creationHeight: box.creationHeight || 0,
+            inclusionHeight: tx.inclusionHeight,
+            assets: box.assets || [],
+            additionalRegisters: box.additionalRegisters,
+            boxId: box.boxId || '',
+            blockId: tx.blockId,
+            spentBlockId: spendInfo?.hash,
+            spentHeight: spendInfo?.height,
+            spentTransactionId: box.spentTransactionId,
+            spentIndex: spendInfo?.spendIndex,
+        };
+    };
+    /**
+     * 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) => ({
+                transactionId: output.transactionId || '',
+                index: output.index || 0,
+                value: output.value || 0n,
+                ergoTree: output.ergoTree || '',
+                creationHeight: output.creationHeight || 0,
+                assets: output.assets || [],
+                additionalRegisters: output.additionalRegisters,
+                boxId: output.boxId || '',
+            })),
+            // TODO: Add input extension local/ergo/rosen-bridge/scanner/-/issues/156
+            inputs: tx.inputs.map((input) => ({ boxId: input.boxId })) ?? [],
+            dataInputs: tx.dataInputs,
+        };
+    };
+    /**
+     * return spending information of a specified box by having spendTxId
+     * @param boxId
+     * @param spendTxId
+     */
+    getSpendingInfo = async (boxId, spendTxId) => {
+        const tx = await this.api.getTxById(spendTxId);
+        const spendIndex = tx.inputs?.findIndex((box) => box.boxId == boxId);
+        if (spendIndex == undefined)
+            throw Error(`Impossible behavior, the box [${boxId}] should have been spent in tx [${spendTxId}]`);
+        return {
+            hash: tx.blockId,
+            height: tx.inclusionHeight,
+            spendIndex,
+        };
+    };
+    /**
+     * use node api to return related boxes by specified address
+     * @param address
+     * @param offset
+     * @param limit
+     * @returns related boxes
+     */
+    getBoxesByAddress = async (address, offset, limit) => {
+        const boxes = await this.api.getBoxesByAddressUnspent(address, {
+            offset: offset,
+            limit: limit,
+            sortDirection: 'desc',
+        });
+        if (!boxes)
+            throw new Error('Ergo node BoxesByAddress api expected to have items');
+        const ergoBoxes = await Promise.all(boxes.map(async (box) => await this.convertBox(box)));
+        return { boxes: ergoBoxes, hasNextBatch: boxes.length > 0 };
+    };
+    /**
+     * use node api to return related boxes by specified token id
+     * @param tokenId
+     * @param offset
+     * @param limit
+     * @returns related boxes
+     */
+    getBoxesByTokenId = async (tokenId, offset, limit) => {
+        const boxes = await this.api.getBoxesByTokenId(tokenId, {
+            offset: offset,
+            limit: limit,
+        });
+        if (!boxes.items)
+            throw new Error('Ergo node BoxesByTokenId api expected to have items');
+        const ergoBoxes = await Promise.all(boxes.items.map(async (box) => await this.convertBox(box)));
+        return { boxes: ergoBoxes, hasNextBatch: boxes.items.length > 0 };
+    };
+    /**
+     * use node api to return related transactions of the specified address with limit offset
+     * @param tokenId
+     * @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,{"version":3,"file":"NodeNetwork.js","sourceRoot":"","sources":["../../../../lib/ergo/network/NodeNetwork.ts"],"names":[],"mappings":"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","sourcesContent":["import ergoNodeClientFactory, {\n  IndexedErgoBox,\n  IndexedErgoTransaction,\n} from '@rosen-clients/ergo-node';\nimport { BlockInfo } from '@rosen-bridge/scanner-interfaces';\n\nimport { ErgoBox, ExtendedTransaction } from '../interfaces';\nimport { AbstractNetwork } from './AbstractNetwork';\n\nexport class NodeNetwork extends AbstractNetwork {\n  private api;\n\n  constructor(url: string) {\n    super();\n    this.api = ergoNodeClientFactory(url);\n  }\n\n  /**\n   * convert node api boxes to ErgoBox interface\n   * @param box\n   * @returns ErgoBox\n   */\n  private convertBox = async (box: IndexedErgoBox): Promise<ErgoBox> => {\n    const tx = await await this.api.getTxById(box.transactionId!);\n    const spendInfo = box.spentTransactionId\n      ? await this.getSpendingInfo(box.boxId!, box.spentTransactionId)\n      : undefined;\n    return {\n      transactionId: box.transactionId || '',\n      index: box.index || 0,\n      value: box.value || 0n,\n      ergoTree: box.ergoTree || '',\n      creationHeight: box.creationHeight || 0,\n      inclusionHeight: tx.inclusionHeight,\n      assets: box.assets || [],\n      additionalRegisters: box.additionalRegisters,\n      boxId: box.boxId || '',\n      blockId: tx.blockId,\n      spentBlockId: spendInfo?.hash,\n      spentHeight: spendInfo?.height,\n      spentTransactionId: box.spentTransactionId,\n      spentIndex: spendInfo?.spendIndex,\n    };\n  };\n\n  /**\n   * convert Node transaction to extractor transaction type\n   * @param tx\n   */\n  private convertTransaction = (\n    tx: IndexedErgoTransaction\n  ): ExtendedTransaction => {\n    return {\n      id: tx.id || '',\n      inclusionHeight: tx.inclusionHeight,\n      blockId: tx.blockId,\n      outputs: tx.outputs.map((output) => ({\n        transactionId: output.transactionId || '',\n        index: output.index || 0,\n        value: output.value || 0n,\n        ergoTree: output.ergoTree || '',\n        creationHeight: output.creationHeight || 0,\n        assets: output.assets || [],\n        additionalRegisters: output.additionalRegisters,\n        boxId: output.boxId || '',\n      })),\n      // TODO: Add input extension local/ergo/rosen-bridge/scanner/-/issues/156\n      inputs: tx.inputs.map((input) => ({ boxId: input.boxId! })) ?? [],\n      dataInputs: tx.dataInputs,\n    };\n  };\n\n  /**\n   * return spending information of a specified box by having spendTxId\n   * @param boxId\n   * @param spendTxId\n   */\n  getSpendingInfo = async (\n    boxId: string,\n    spendTxId: string\n  ): Promise<BlockInfo & { spendIndex: number }> => {\n    const tx = await this.api.getTxById(spendTxId);\n    const spendIndex = tx.inputs?.findIndex((box) => box.boxId == boxId);\n    if (spendIndex == undefined)\n      throw Error(\n        `Impossible behavior, the box [${boxId}] should have been spent in tx [${spendTxId}]`\n      );\n    return {\n      hash: tx.blockId,\n      height: tx.inclusionHeight,\n      spendIndex,\n    };\n  };\n\n  /**\n   * use node api to return related boxes by specified address\n   * @param address\n   * @param offset\n   * @param limit\n   * @returns related boxes\n   */\n  getBoxesByAddress = async (\n    address: string,\n    offset: number,\n    limit: number\n  ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {\n    const boxes = await this.api.getBoxesByAddressUnspent(address, {\n      offset: offset,\n      limit: limit,\n      sortDirection: 'desc',\n    });\n    if (!boxes)\n      throw new Error('Ergo node BoxesByAddress api expected to have items');\n    const ergoBoxes = await Promise.all(\n      boxes.map(async (box) => await this.convertBox(box))\n    );\n    return { boxes: ergoBoxes, hasNextBatch: boxes.length > 0 };\n  };\n\n  /**\n   * use node api to return related boxes by specified token id\n   * @param tokenId\n   * @param offset\n   * @param limit\n   * @returns related boxes\n   */\n  getBoxesByTokenId = async (\n    tokenId: string,\n    offset: number,\n    limit: number\n  ): Promise<{ boxes: ErgoBox[]; hasNextBatch: boolean }> => {\n    const boxes = await this.api.getBoxesByTokenId(tokenId, {\n      offset: offset,\n      limit: limit,\n    });\n    if (!boxes.items)\n      throw new Error('Ergo node BoxesByTokenId api expected to have items');\n    const ergoBoxes = await Promise.all(\n      boxes.items.map(async (box) => await this.convertBox(box))\n    );\n    return { boxes: ergoBoxes, hasNextBatch: boxes.items.length > 0 };\n  };\n\n  /**\n   * use node api to return related transactions of the specified address with limit offset\n   * @param tokenId\n   * @param offset\n   * @param limit\n   * @returns related transactions\n   */\n  getAddressTransactionsWithOffsetLimit = async (\n    address: string,\n    offset: number,\n    limit: number\n  ): Promise<{ items: Array<ExtendedTransaction>; total: number }> => {\n    const txs = await this.api.getTxsByAddress(address, {\n      offset,\n      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"]}

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

@@ -0,0 +1,8 @@
+import { OutputBox } from '@rosen-bridge/scanner-interfaces';
+/**
+ * Check box to have specified tokens
+ * @param box
+ * @return true if box has the required token and false otherwise
+ */
+export declare const boxHasToken: (box: OutputBox, tokenIds: string[]) => boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/ergo/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,WAAW,QAAS,SAAS,YAAY,MAAM,EAAE,YAM7D,CAAC"}

package/dist/lib/ergo/utils.js

@@ -0,0 +1,16 @@
+import { intersection } from 'lodash-es';
+/**
+ * Check box to have specified tokens
+ * @param box
+ * @return true if box has the required token and false otherwise
+ */
+export const boxHasToken = (box, tokenIds) => {
+    if (!box.assets)
+        return false;
+    const boxTokens = box.assets.map((token) => token.tokenId);
+    const requiredTokens = intersection(tokenIds, boxTokens);
+    if (requiredTokens.length == tokenIds.length)
+        return true;
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvZXJnby91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBR3pDOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsQ0FBQyxHQUFjLEVBQUUsUUFBa0IsRUFBRSxFQUFFO0lBQ2hFLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTTtRQUFFLE9BQU8sS0FBSyxDQUFDO0lBQzlCLE1BQU0sU0FBUyxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0QsTUFBTSxjQUFjLEdBQUcsWUFBWSxDQUFDLFFBQVEsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUN6RCxJQUFJLGNBQWMsQ0FBQyxNQUFNLElBQUksUUFBUSxDQUFDLE1BQU07UUFBRSxPQUFPLElBQUksQ0FBQztJQUMxRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGludGVyc2VjdGlvbiB9IGZyb20gJ2xvZGFzaC1lcyc7XG5pbXBvcnQgeyBPdXRwdXRCb3ggfSBmcm9tICdAcm9zZW4tYnJpZGdlL3NjYW5uZXItaW50ZXJmYWNlcyc7XG5cbi8qKlxuICogQ2hlY2sgYm94IHRvIGhhdmUgc3BlY2lmaWVkIHRva2Vuc1xuICogQHBhcmFtIGJveFxuICogQHJldHVybiB0cnVlIGlmIGJveCBoYXMgdGhlIHJlcXVpcmVkIHRva2VuIGFuZCBmYWxzZSBvdGhlcndpc2VcbiAqL1xuZXhwb3J0IGNvbnN0IGJveEhhc1Rva2VuID0gKGJveDogT3V0cHV0Qm94LCB0b2tlbklkczogc3RyaW5nW10pID0+IHtcbiAgaWYgKCFib3guYXNzZXRzKSByZXR1cm4gZmFsc2U7XG4gIGNvbnN0IGJveFRva2VucyA9IGJveC5hc3NldHMubWFwKCh0b2tlbikgPT4gdG9rZW4udG9rZW5JZCk7XG4gIGNvbnN0IHJlcXVpcmVkVG9rZW5zID0gaW50ZXJzZWN0aW9uKHRva2VuSWRzLCBib3hUb2tlbnMpO1xuICBpZiAocmVxdWlyZWRUb2tlbnMubGVuZ3RoID09IHRva2VuSWRzLmxlbmd0aCkgcmV0dXJuIHRydWU7XG4gIHJldHVybiBmYWxzZTtcbn07XG4iXX0=

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ergo';
+export * from './constants';
+export * from './abstractExtractor';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC"}

package/dist/lib/index.js

@@ -0,0 +1,4 @@
+export * from './ergo';
+export * from './constants';
+export * from './abstractExtractor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXJnbyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2Fic3RyYWN0RXh0cmFjdG9yJztcbiJdfQ==

package/dist/tests/AbstractErgoExtractor.mock.d.ts

@@ -0,0 +1,11 @@
+import { V1 } from '@rosen-clients/ergo-explorer';
+import { BlockInfo, OutputBox } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoExtractor, AbstractBoxData, AbstractErgoExtractorAction, AbstractErgoExtractorEntity } from '../lib';
+export declare class MockedErgoExtractor extends AbstractErgoExtractor<AbstractBoxData, AbstractErgoExtractorEntity> {
+    actions: AbstractErgoExtractorAction<AbstractBoxData, AbstractErgoExtractorEntity>;
+    getId: () => string;
+    initializeBoxes: (initialBlock: BlockInfo) => Promise<void>;
+    hasData: (box: V1.OutputInfo | OutputBox) => boolean;
+    extractBoxData: (box: V1.OutputInfo | OutputBox) => AbstractBoxData | undefined;
+}
+//# sourceMappingURL=AbstractErgoExtractor.mock.d.ts.map

package/dist/tests/AbstractErgoExtractor.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractErgoExtractor.mock.d.ts","sourceRoot":"","sources":["../../tests/AbstractErgoExtractor.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,8BAA8B,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,2BAA2B,EAC3B,2BAA2B,EAC5B,MAAM,QAAQ,CAAC;AAEhB,qBAAa,mBAAoB,SAAQ,qBAAqB,CAC5D,eAAe,EACf,2BAA2B,CAC5B;IACC,OAAO,EAAE,2BAA2B,CAClC,eAAe,EACf,2BAA2B,CAC5B,CAAC;IAEF,KAAK,eAAgB;IAErB,eAAe,EAAE,CAAC,YAAY,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5D,OAAO,QACA,GAAG,UAAU,GAAG,SAAS,aACrB;IAEX,cAAc,QACP,GAAG,UAAU,GAAG,SAAS,KAC7B,eAAe,GAAG,SAAS,CAE5B;CACH"}

package/dist/tests/AbstractErgoExtractor.mock.js

@@ -0,0 +1,13 @@
+import { AbstractErgoExtractor, } from '../lib';
+export class MockedErgoExtractor extends AbstractErgoExtractor {
+    actions;
+    getId = () => 'Test';
+    initializeBoxes;
+    hasData = (box // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => false;
+    extractBoxData = (box // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => {
+        return undefined;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RFcmdvRXh0cmFjdG9yLm1vY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90ZXN0cy9BYnN0cmFjdEVyZ29FeHRyYWN0b3IubW9jay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQ0wscUJBQXFCLEdBSXRCLE1BQU0sUUFBUSxDQUFDO0FBRWhCLE1BQU0sT0FBTyxtQkFBb0IsU0FBUSxxQkFHeEM7SUFDQyxPQUFPLENBR0w7SUFFRixLQUFLLEdBQUcsR0FBRyxFQUFFLENBQUMsTUFBTSxDQUFDO0lBRXJCLGVBQWUsQ0FBNkM7SUFFNUQsT0FBTyxHQUFHLENBQ1IsR0FBOEIsQ0FBQyx3REFBd0Q7TUFDdkYsRUFBRSxDQUFDLEtBQUssQ0FBQztJQUVYLGNBQWMsR0FBRyxDQUNmLEdBQThCLENBQUMsd0RBQXdEO01BQzFELEVBQUU7UUFDL0IsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQyxDQUFDO0NBQ0giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWMSB9IGZyb20gJ0Byb3Nlbi1jbGllbnRzL2VyZ28tZXhwbG9yZXInO1xuaW1wb3J0IHsgQmxvY2tJbmZvLCBPdXRwdXRCb3ggfSBmcm9tICdAcm9zZW4tYnJpZGdlL3NjYW5uZXItaW50ZXJmYWNlcyc7XG5cbmltcG9ydCB7XG4gIEFic3RyYWN0RXJnb0V4dHJhY3RvcixcbiAgQWJzdHJhY3RCb3hEYXRhLFxuICBBYnN0cmFjdEVyZ29FeHRyYWN0b3JBY3Rpb24sXG4gIEFic3RyYWN0RXJnb0V4dHJhY3RvckVudGl0eSxcbn0gZnJvbSAnLi4vbGliJztcblxuZXhwb3J0IGNsYXNzIE1vY2tlZEVyZ29FeHRyYWN0b3IgZXh0ZW5kcyBBYnN0cmFjdEVyZ29FeHRyYWN0b3I8XG4gIEFic3RyYWN0Qm94RGF0YSxcbiAgQWJzdHJhY3RFcmdvRXh0cmFjdG9yRW50aXR5XG4+IHtcbiAgYWN0aW9uczogQWJzdHJhY3RFcmdvRXh0cmFjdG9yQWN0aW9uPFxuICAgIEFic3RyYWN0Qm94RGF0YSxcbiAgICBBYnN0cmFjdEVyZ29FeHRyYWN0b3JFbnRpdHlcbiAgPjtcblxuICBnZXRJZCA9ICgpID0+ICdUZXN0JztcblxuICBpbml0aWFsaXplQm94ZXM6IChpbml0aWFsQmxvY2s6IEJsb2NrSW5mbykgPT4gUHJvbWlzZTx2b2lkPjtcblxuICBoYXNEYXRhID0gKFxuICAgIGJveDogVjEuT3V0cHV0SW5mbyB8IE91dHB1dEJveCAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuICApID0+IGZhbHNlO1xuXG4gIGV4dHJhY3RCb3hEYXRhID0gKFxuICAgIGJveDogVjEuT3V0cHV0SW5mbyB8IE91dHB1dEJveCAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuICApOiBBYnN0cmFjdEJveERhdGEgfCB1bmRlZmluZWQgPT4ge1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH07XG59XG4iXX0=

package/dist/tests/AbstractErgoExtractor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AbstractErgoExtractor.spec.d.ts.map

package/dist/tests/AbstractErgoExtractor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractErgoExtractor.spec.d.ts","sourceRoot":"","sources":["../../tests/AbstractErgoExtractor.spec.ts"],"names":[],"mappings":""}