@my-packages-changeit/abstract-extractor 3.2.3

package/dist/ergo/networks/explorerNetwork.js

@@ -0,0 +1,132 @@
+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'),
+            spendingProof: box.spendingProof,
+            extension: {},
+            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,
+                spendingProof: input.spendingProof,
+            })) ?? [],
+            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 {\n  InputBox,\n  OutputBox,\n  Transaction,\n} 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 & InputBox => {\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      spendingProof: box.spendingProof,\n      extension: {},\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:\n        tx.inputs?.map((input) => ({\n          boxId: input.id,\n          spendingProof: input.spendingProof,\n        })) ?? [],\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,34 @@
+import { ExtendedTransaction } from '../interfaces';
+export declare class NodeNetwork {
+    private api;
+    constructor(url: string);
+    /**
+     * convert node api input boxes to OutputBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    private convertInputBox;
+    /**
+     * convert node api output boxes to OutputBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    private convertOutputBox;
+    /**
+     * 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,eAAe,CAarB;IAEF;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAWtB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAWxB;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,77 @@
+import ergoNodeClientFactory from '@rosen-clients/ergo-node';
+export class NodeNetwork {
+    api;
+    constructor(url) {
+        this.api = ergoNodeClientFactory(url);
+    }
+    /**
+     * convert node api input boxes to OutputBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    convertInputBox = (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 || '',
+            extension: box.spendingProof?.extension,
+            spendingProof: box.spendingProof?.proofBytes,
+        };
+    };
+    /**
+     * convert node api output boxes to OutputBox interface
+     * @param box
+     * @returns ErgoBox
+     */
+    convertOutputBox = (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.convertOutputBox(output)),
+            inputs: tx.inputs.map((input) => this.convertInputBox(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

@@ -0,0 +1,23 @@
+import { AbstractLogger } from '@rosen-bridge/abstract-logger';
+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;
+/**
+ * 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?: AbstractLogger) => Promise<returnT>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/ergo/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC5E,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,SAAQ,cAAkC,KACzC,OAAO,CAAC,OAAO,CAkBjB,CAAC"}

package/dist/ergo/utils.js

@@ -0,0 +1,49 @@
+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
+ * @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;
+};
+/**
+ * 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/dist/index.d.ts

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

package/dist/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/index.js

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