@xchainjs/xchain-utxo-providers 0.1.1 → 0.1.2

package/lib/index.esm.js

@@ -0,0 +1,1874 @@
+import { assetAmount, assetToBase, baseAmount, delay } from '@xchainjs/xchain-util';
+import axios from 'axios';
+import { TxType } from '@xchainjs/xchain-client';
+
+var SochainNetwork;
+(function (SochainNetwork) {
+    SochainNetwork["BTC"] = "BTC";
+    SochainNetwork["BTCTEST"] = "BTCTEST";
+    SochainNetwork["LTC"] = "LTC";
+    SochainNetwork["LTCTEST"] = "LTCTEST";
+    SochainNetwork["DOGE"] = "DOGE";
+    SochainNetwork["DOGETEST"] = "DOGETEST";
+})(SochainNetwork || (SochainNetwork = {}));
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+/**
+ * Get transaction by hash.
+ *
+ * @see https://sochain.com/api#get-tx
+ *
+ * @param {string} sochainUrl The sochain node url.
+ * @param {string} network network id
+ * @param {string} hash The transaction hash.
+ * @returns {Transactions}
+ */
+const getTx = ({ apiKey, sochainUrl, network, hash }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/transaction/${network}/${hash}`;
+    const response = yield axios.get(url, { headers: { 'API-KEY': apiKey } });
+    const tx = response.data;
+    return tx.data;
+});
+/**
+ * Get transactions
+ *
+ * @see https://sochain.com/api#get-tx
+ *
+ * @param {string} sochainUrl The sochain node url.
+ * @param {string} network network id
+ * @param {string} hash The transaction hash.
+ * @returns {Transactions}
+ */
+const getTxs = ({ apiKey, address, sochainUrl, network, page, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/transactions/${network}/${address}/${page}`; //TODO support paging
+    const response = yield axios.get(url, { headers: { 'API-KEY': apiKey } });
+    const txs = response.data;
+    return txs.data;
+});
+/**
+ * Get address balance.
+ *
+ * @see https://sochain.com/api#get-balance
+ *
+ * @param {string} sochainUrl The sochain node url.
+ * @param {string} network Network
+ * @param {string} address Address
+ * @param {boolean} confirmedOnly Flag whether to get balances of confirmed txs only or for all
+ * @returns {number}
+ */
+const getBalance = ({ apiKey, sochainUrl, network, address, confirmedOnly, assetDecimals, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/balance/${network}/${address}`;
+    const response = yield axios.get(url, { headers: { 'API-KEY': apiKey } });
+    const balanceResponse = response.data;
+    const confirmed = assetAmount(balanceResponse.data.confirmed, assetDecimals);
+    const unconfirmed = assetAmount(balanceResponse.data.unconfirmed, assetDecimals);
+    const netAmt = confirmedOnly ? confirmed : confirmed.plus(unconfirmed);
+    const result = assetToBase(netAmt);
+    return result;
+});
+/**
+ * Get unspent txs
+ *
+ * @see https://sochain.com/api#get-unspent-tx
+ *
+ * @param {string} sochainUrl The sochain node url.
+ * @param {string} network
+ * @param {string} address
+ * @returns {AddressUTXO[]}
+ */
+const getUnspentTxs = ({ apiKey, sochainUrl, network, address, page, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = [sochainUrl, 'unspent_outputs', network, address, page].filter((v) => !!v).join('/');
+    const resp = yield axios.get(url, { headers: { 'API-KEY': apiKey } });
+    const response = resp.data;
+    const txs = response.data.outputs;
+    if (txs.length === 10) {
+        //fetch the next batch
+        const nextBatch = yield getUnspentTxs({
+            apiKey,
+            sochainUrl,
+            network,
+            address,
+            page: page + 1,
+        });
+        return txs.concat(nextBatch);
+    }
+    else {
+        return txs;
+    }
+});
+/**
+ * Get address balance.
+ *
+ * @see https://sochain.com/api#get-balance
+ *
+ * @param {string} sochainUrl The sochain node url.
+ * @param {string} network Network
+ * @param {string} address Address
+ * @param {boolean} confirmedOnly Flag whether to get balances of confirmed txs only or for all
+ * @returns {number}
+ */
+const broadcastTx = ({ apiKey, sochainUrl, network, txHex, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/broadcast_transaction/${network}`;
+    const response = yield axios.post(url, { tx_hex: txHex }, { headers: { 'API-KEY': apiKey } });
+    const broadcastResponse = response.data;
+    return broadcastResponse.tx_hex;
+});
+
+class SochainProvider {
+    constructor(baseUrl = 'https://sochain.com/api/v3', apiKey, chain, asset, assetDecimals, sochainNetwork) {
+        this.baseUrl = baseUrl;
+        this._apiKey = apiKey;
+        this.chain = chain;
+        this.asset = asset;
+        this.assetDecimals = assetDecimals;
+        this.sochainNetwork = sochainNetwork;
+        this.asset;
+        this.chain;
+    }
+    get apiKey() {
+        return this._apiKey;
+    }
+    set apiKey(value) {
+        this._apiKey = value;
+    }
+    broadcastTx(txHex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield broadcastTx({
+                apiKey: this._apiKey,
+                sochainUrl: this.baseUrl,
+                network: this.sochainNetwork,
+                txHex,
+            });
+        });
+    }
+    getConfirmedUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield getUnspentTxs({
+                apiKey: this._apiKey,
+                sochainUrl: this.baseUrl,
+                network: this.sochainNetwork,
+                address,
+                page: 1,
+            });
+            const confirmedUnspent = allUnspent.filter((i) => i.block); //if it has a block noumber it's been confirmed
+            return this.mapUTXOs(confirmedUnspent);
+        });
+    }
+    getUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield getUnspentTxs({
+                apiKey: this._apiKey,
+                sochainUrl: this.baseUrl,
+                network: this.sochainNetwork,
+                address,
+                page: 1,
+            });
+            return this.mapUTXOs(allUnspent);
+        });
+    }
+    getBalance(address, assets /*ignored*/, confirmedOnly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const amount = yield getBalance({
+                    apiKey: this._apiKey,
+                    sochainUrl: this.baseUrl,
+                    network: this.sochainNetwork,
+                    address,
+                    confirmedOnly: !!confirmedOnly,
+                    assetDecimals: this.assetDecimals,
+                });
+                return [{ amount, asset: this.asset }];
+            }
+            catch (error) {
+                throw new Error(`Could not get balances for address ${address}`);
+            }
+        });
+    }
+    /**
+     * Get transaction history of a given address with pagination options.
+     * By default it will return the transaction history of the current wallet.
+     *
+     * @param {TxHistoryParams} params The options to get transaction history. (optional)
+     * @returns {TxsPage} The transaction history.
+     */
+    getTransactions(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const offset = (_a = params === null || params === void 0 ? void 0 : params.offset) !== null && _a !== void 0 ? _a : 0;
+            const limit = (params === null || params === void 0 ? void 0 : params.limit) || 10;
+            if (offset < 0 || limit < 0)
+                throw Error('ofset and limit must be equal or greater than 0');
+            const firstPage = Math.floor(offset / 10) + 1;
+            const lastPage = limit > 10 ? firstPage + Math.floor(limit / 10) : firstPage;
+            const offsetOnFirstPage = offset % 10;
+            const txHashesToFetch = [];
+            let page = firstPage;
+            try {
+                while (page <= lastPage) {
+                    const response = yield getTxs({
+                        apiKey: this._apiKey,
+                        sochainUrl: this.baseUrl,
+                        network: this.sochainNetwork,
+                        address: `${params === null || params === void 0 ? void 0 : params.address}`,
+                        page,
+                    });
+                    if (response.transactions.length === 0)
+                        break;
+                    if (page === firstPage && response.transactions.length > offsetOnFirstPage) {
+                        //start from offset
+                        const txsToGet = response.transactions.slice(offsetOnFirstPage);
+                        this.addArrayUpToLimit(txHashesToFetch, txsToGet.map((i) => i.hash), limit);
+                    }
+                    else {
+                        this.addArrayUpToLimit(txHashesToFetch, response.transactions.map((i) => i.hash), limit);
+                    }
+                    page++;
+                }
+            }
+            catch (error) {
+                console.error(error);
+                //an errors means no more results
+            }
+            const total = txHashesToFetch.length;
+            const transactions = yield Promise.all(txHashesToFetch.map((hash) => this.getTransactionData(hash)));
+            const result = {
+                total,
+                txs: transactions,
+            };
+            return result;
+        });
+    }
+    /**
+     * Get the transaction details of a given transaction id.
+     *
+     * @param {string} txId The transaction id.
+     * @returns {Tx} The transaction details of the given transaction id.
+     */
+    getTransactionData(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const rawTx = yield getTx({
+                    apiKey: this._apiKey,
+                    sochainUrl: this.baseUrl,
+                    network: this.sochainNetwork,
+                    hash: txId,
+                });
+                return {
+                    asset: this.asset,
+                    from: rawTx.inputs.map((i) => ({
+                        from: i.address,
+                        amount: assetToBase(assetAmount(i.value, this.assetDecimals)),
+                    })),
+                    to: rawTx.outputs
+                        .filter((i) => i.type !== 'nulldata') //filter out op_return outputs
+                        .map((i) => ({ to: i.address, amount: assetToBase(assetAmount(i.value, this.assetDecimals)) })),
+                    date: new Date(rawTx.time * 1000),
+                    type: TxType.Transfer,
+                    hash: rawTx.hash,
+                };
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+    mapUTXOs(utxos) {
+        return utxos.map((utxo) => ({
+            hash: utxo.hash,
+            index: utxo.index,
+            value: assetToBase(assetAmount(utxo.value, this.assetDecimals)).amount().toNumber(),
+            witnessUtxo: {
+                value: assetToBase(assetAmount(utxo.value, this.assetDecimals)).amount().toNumber(),
+                script: Buffer.from(utxo.script, 'hex'),
+            },
+            txHex: utxo.tx_hex,
+        }));
+    }
+    /**
+     * helper function tto limit adding to an array
+     *
+     * @param arr array to be added to
+     * @param toAdd elements to add
+     * @param limit do not add more than this limit
+     */
+    addArrayUpToLimit(arr, toAdd, limit) {
+        for (let index = 0; index < toAdd.length; index++) {
+            const element = toAdd[index];
+            if (arr.length < limit) {
+                arr.push(element);
+            }
+        }
+    }
+}
+
+/**
+ * Haskoin API types
+ */
+var HaskoinNetwork;
+(function (HaskoinNetwork) {
+    HaskoinNetwork["BTC"] = "btc";
+    HaskoinNetwork["BTCTEST"] = "btctest";
+    HaskoinNetwork["BCH"] = "bch";
+    HaskoinNetwork["BCHTEST"] = "bchtest";
+})(HaskoinNetwork || (HaskoinNetwork = {}));
+
+/**
+ * Module to interact with Haskoin API
+ *
+ * Doc (SwaggerHub) https://app.swaggerhub.com/apis/eligecode/blockchain-api/0.0.1-oas3
+ *
+ */
+/**
+ * Check error response.
+ *
+ * @param {any} response The api response.
+ * @returns {boolean}
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isErrorResponse = (response) => {
+    return !!response.error;
+};
+/**
+ * Get account from address.
+ *
+ * @param {string} haskoinUrl The haskoin API url.
+ * @param {string} address The BCH address.
+ * @returns {AddressBalance}
+ *
+ * @throws {"failed to query account by a given address"} thrown if failed to query account by a given address
+ */
+const getAccount = ({ haskoinUrl, network, address }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${haskoinUrl}/${network}/address/${address}/balance`;
+    const result = (yield axios.get(url)).data;
+    if (!result || isErrorResponse(result))
+        throw new Error(`failed to query account by given address ${address}`);
+    return result;
+});
+/**
+ * Get address information.
+ *
+ * @param {string} haskoinUrl The haskoin node url.
+ * @param {string} network
+ * @param {string} address
+ * @returns {AddressDTO}
+ */
+const getAddress = ({ haskoinUrl, network, address }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${haskoinUrl}/${network}/address/${address}/balance`;
+    const response = yield axios.get(url);
+    const addressResponse = response.data;
+    return addressResponse.data;
+});
+/**
+ * Get transaction by hash.
+ *
+ * @param {string} haskoinUrl The haskoin API url.
+ * @param {string} txId The transaction id.
+ * @returns {Transaction}
+ *
+ * @throws {"failed to query transaction by a given hash"} thrown if failed to query transaction by a given hash
+ */
+const getTx$1 = ({ haskoinUrl, txId, network }) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = (yield axios.get(`${haskoinUrl}/${network}/transaction/${txId}`)).data;
+    if (!result || isErrorResponse(result))
+        throw new Error(`failed to query transaction by a given hash ${txId}`);
+    return result;
+});
+/**
+ * Get raw transaction by hash.
+ *
+ * @param {string} haskoinUrl The haskoin API url.
+ * @param {string} txId The transaction id.
+ * @returns {Transaction}
+ *
+ * @throws {"failed to query transaction by a given hash"} thrown if failed to query raw transaction by a given hash
+ */
+const getRawTransaction = ({ haskoinUrl, network, txId }) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = (yield axios.get(`${haskoinUrl}/${network}/transaction/${txId}/raw`))
+        .data;
+    if (!result || isErrorResponse(result))
+        throw new Error(`failed to query transaction by a given hash ${txId}`);
+    return result.result;
+});
+/**
+ * Get transactions
+ *
+ * @see https://haskoin.com/api#get-tx
+ *
+ * @param {string} haskoinUrl The haskoin node url.
+ * @param {string} network network id
+ * @param {string} hash The transaction hash.
+ * @returns {Transactions}
+ */
+const getTxs$1 = ({ address, haskoinUrl, network, limit, offset, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = { limit: `${limit}`, offset: `${offset}` };
+    const url = `${haskoinUrl}/${network}/address/${address}/transactions/full`;
+    const result = (yield axios.get(url, { params })).data;
+    if (!result || isErrorResponse(result))
+        throw new Error('failed to query transactions');
+    return result;
+});
+/**
+ *
+ * @param param
+ * @returns Returns BaseAmount
+ */
+const getBalance$1 = ({ haskoinUrl, haskoinNetwork, address, confirmedOnly, assetDecimals, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { data: { confirmed, unconfirmed }, } = yield axios.get(`${haskoinUrl}/${haskoinNetwork}/address/${address}/balance`);
+    const confirmedAmount = baseAmount(confirmed, assetDecimals);
+    const unconfirmedAmount = baseAmount(unconfirmed, assetDecimals);
+    return confirmedOnly ? confirmedAmount : confirmedAmount.plus(unconfirmedAmount);
+});
+/**
+ * Get unspent transactions.
+ *
+ * @param {string} haskoinUrl The haskoin API url.
+ * @param {string} address The BCH address.
+ * @returns {TxUnspent[]}
+ *
+ * @throws {"failed to query unspent transactions"} thrown if failed to query unspent transactions
+ */
+const getUnspentTxs$1 = ({ haskoinUrl, network, address }) => __awaiter(void 0, void 0, void 0, function* () {
+    // Get transaction count for a given address.
+    const account = yield getAccount({ haskoinUrl, network, address });
+    // Set limit to the transaction count to be all the utxos.
+    const result = (yield axios.get(`${haskoinUrl}/${network}/address/${address}/unspent?limit${account === null || account === void 0 ? void 0 : account.utxo}`)).data;
+    if (!result || isErrorResponse(result))
+        throw new Error('failed to query unspent transactions');
+    return result;
+});
+/**
+ * Get Tx Confirmation status
+ *
+ * @param {string} haskoinUrl The haskoin node url.
+ * @param {Network} network
+ * @param {string} hash tx id
+ * @returns {TxConfirmedStatus}
+ */
+const getIsTxConfirmed = ({ haskoinUrl, network, txId }) => __awaiter(void 0, void 0, void 0, function* () {
+    const tx = yield getTx$1({ haskoinUrl, network, txId });
+    return {
+        network: network,
+        txid: txId,
+        confirmations: tx.confirmations,
+        is_confirmed: tx.confirmations >= 1,
+    };
+});
+/**
+ * List of confirmed txs
+ *
+ * Stores a list of confirmed txs (hashes) in memory to avoid requesting same data
+ */
+const confirmedTxs = [];
+/**
+ * Helper to get `confirmed` status of a tx.
+ *
+ * It will get it from cache or try to get it from haskoin (if not cached before)
+ */
+const getConfirmedTxStatus = ({ txHash, haskoinUrl, network, }) => __awaiter(void 0, void 0, void 0, function* () {
+    // try to get it from cache
+    if (confirmedTxs.includes(txHash))
+        return true;
+    // or get status from haskoin
+    const { is_confirmed } = yield getIsTxConfirmed({
+        haskoinUrl,
+        network,
+        txId: txHash,
+    });
+    // cache status
+    confirmedTxs.push(txHash);
+    return is_confirmed;
+});
+/**
+ * Get unspent txs and filter out pending UTXOs
+ *
+ * @see https://haskoin.com/api#get-unspent-tx
+ *
+ * @param {string} haskoinUrl The haskoin node url.
+ * @param {Network} network
+ * @param {string} address
+ * @returns {AddressUTXO[]}
+ */
+const getConfirmedUnspentTxs = ({ haskoinUrl, network, address }) => __awaiter(void 0, void 0, void 0, function* () {
+    const txs = yield getUnspentTxs$1({
+        haskoinUrl,
+        network,
+        address,
+    });
+    const confirmedUTXOs = [];
+    yield Promise.all(txs.map((tx) => __awaiter(void 0, void 0, void 0, function* () {
+        const confirmed = yield getConfirmedTxStatus({
+            haskoinUrl,
+            network,
+            txHash: tx.txid,
+        });
+        if (confirmed) {
+            confirmedUTXOs.push(tx);
+        }
+    })));
+    return confirmedUTXOs;
+});
+// Stores list of txHex in memory to avoid requesting same data
+const txHexMap = {};
+/**
+ * Helper to get `hex` of `Tx`
+ *
+ * It will try to get it from cache before requesting it from Sochain
+ */
+const getTxHex = ({ haskoinUrl, network, txId }) => __awaiter(void 0, void 0, void 0, function* () {
+    // try to get hex from cache
+    let txHex = txHexMap[txId];
+    if (!!txHex)
+        return txHex;
+    // or get it from Haskoin
+    txHex = yield getRawTransaction({ haskoinUrl, txId: txId, network: network });
+    // cache it
+    txHexMap[txId] = txHex;
+    return txHex;
+});
+/**
+ * Get unspent transactions.
+ *
+ * @param {string} haskoinUrl The haskoin API url.
+ * @param {string} address The BCH address.
+ * @returns {TxUnspent[]}
+ *
+ * @throws {"failed to query unspent transactions"} thrown if failed to query unspent transactions
+ */
+const getUnspentTransactions = ({ haskoinUrl, network, address }) => __awaiter(void 0, void 0, void 0, function* () {
+    // Get transaction count for a given address.
+    const account = yield getAccount({ haskoinUrl, network, address });
+    // Set limit to the transaction count to be all the utxos.
+    const result = (yield axios.get(`${haskoinUrl}/${network}/address/${address}/unspent?limit${account === null || account === void 0 ? void 0 : account.utxo}`)).data;
+    if (!result || isErrorResponse(result))
+        throw new Error('failed to query unspent transactions');
+    return result;
+});
+/**
+ * Broadcast transaction.
+ *
+ * @see https://app.swaggerhub.com/apis/eligecode/blockchain-api/0.0.1-oas3#/blockchain/sendTransaction
+ *
+ * Note: Because of an Haskoin issue (@see https://github.com/haskoin/haskoin-store/issues/25),
+ * we need to broadcast same tx several times in case of `500` errors
+ * @see https://github.com/xchainjs/xchainjs-lib/issues/492
+ *
+ * @param {BroadcastTxParams} params
+ * @returns {TxHash} Transaction hash.
+ */
+const broadcastTx$1 = ({ txHex, haskoinUrl, haskoinNetwork, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const MAX_RETRIES = 5;
+    let retries = 0;
+    const axiosInstance = axios.create();
+    const url = `${haskoinUrl}/${haskoinNetwork}/transactions`;
+    while (retries < MAX_RETRIES) {
+        try {
+            const response = yield axiosInstance.post(url, txHex);
+            const { txid } = response.data;
+            return txid;
+        }
+        catch (error) {
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 500) {
+                retries++;
+                yield delay(200 * retries);
+            }
+            else {
+                return Promise.reject(error);
+            }
+        }
+    }
+    return Promise.reject(new Error('Max retries exceeded'));
+});
+
+class HaskoinProvider {
+    constructor(baseUrl = 'https://api.haskoin.com/', chain, asset, assetDecimals, haskoinNetwork) {
+        this.baseUrl = baseUrl;
+        this.chain = chain;
+        this.asset = asset;
+        this.assetDecimals = assetDecimals;
+        this.haskoinNetwork = haskoinNetwork;
+        this.asset;
+        this.chain;
+    }
+    broadcastTx(txHex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield broadcastTx$1({
+                haskoinUrl: this.baseUrl,
+                haskoinNetwork: this.haskoinNetwork,
+                txHex,
+            });
+        });
+    }
+    getConfirmedUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield getUnspentTransactions({
+                haskoinUrl: this.baseUrl,
+                network: this.haskoinNetwork,
+                address,
+            });
+            const confirmedUnspent = allUnspent.filter((i) => i.block); //if it has a block noumber it's been confirmed
+            return this.mapUTXOs(confirmedUnspent);
+        });
+    }
+    getUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield getUnspentTxs$1({
+                haskoinUrl: this.baseUrl,
+                network: this.haskoinNetwork,
+                address,
+            });
+            return yield this.mapUTXOs(allUnspent);
+        });
+    }
+    getBalance(address, assets /*ignored*/, confirmedOnly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const amount = yield getBalance$1({
+                haskoinUrl: this.baseUrl,
+                haskoinNetwork: this.haskoinNetwork,
+                address,
+                confirmedOnly: !!confirmedOnly,
+                assetDecimals: this.assetDecimals,
+            });
+            return [{ amount, asset: this.asset }];
+        });
+    }
+    /**
+     * Get transaction history of a given address with pagination options.
+     * By default it will return the transaction history of the current wallet.
+     *
+     * @param {TxHistoryParams} params The options to get transaction history. (optional)
+     * @returns {TxsPage} The transaction history.
+     */
+    getTransactions(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const offset = (_a = params === null || params === void 0 ? void 0 : params.offset) !== null && _a !== void 0 ? _a : 0;
+            const limit = (params === null || params === void 0 ? void 0 : params.limit) || 10;
+            if (offset + limit > 2000)
+                throw Error('cannot fetch more than last 2000 txs');
+            if (offset < 0 || limit < 0)
+                throw Error('ofset and limit must be equal or greater than 0');
+            const response = yield getTxs$1({
+                address: `${params === null || params === void 0 ? void 0 : params.address}`,
+                haskoinUrl: this.baseUrl,
+                network: this.haskoinNetwork,
+                limit: limit,
+                offset,
+            });
+            const txs = response.map((i) => this.mapTransactionToTx(i));
+            const result = {
+                total: txs.length,
+                txs: txs,
+            };
+            return result;
+        });
+    }
+    mapTransactionToTx(rawTx) {
+        return {
+            asset: this.asset,
+            from: rawTx.inputs.map((i) => ({
+                from: i.address,
+                amount: baseAmount(i.value, this.assetDecimals),
+            })),
+            to: rawTx.outputs
+                .filter((i) => i.script !== 'null-data') //filter out op_return outputs
+                .map((i) => ({ to: i.address, amount: baseAmount(i.value, this.assetDecimals) })),
+            date: new Date(rawTx.time),
+            type: TxType.Transfer,
+            hash: rawTx.txid,
+        };
+    }
+    /**
+     * Get the transaction details of a given transaction id.
+     *
+     * @param {string} txId The transaction id.
+     * @returns {Tx} The transaction details of the given transaction id.
+     */
+    getTransactionData(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const rawTx = yield getTx$1({
+                    haskoinUrl: this.baseUrl,
+                    network: this.haskoinNetwork,
+                    txId: txId,
+                });
+                return this.mapTransactionToTx(rawTx);
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+    /**
+     *
+     * @param utxos
+     * @returns utxo array
+     */
+    mapUTXOs(utxos) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Promise.all(utxos.map((utxo) => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    hash: utxo.txid,
+                    index: utxo.index,
+                    value: baseAmount(utxo.value, this.assetDecimals).amount().toNumber(),
+                    witnessUtxo: {
+                        value: baseAmount(utxo.value, this.assetDecimals).amount().toNumber(),
+                        script: Buffer.from(utxo.pkscript, 'hex'),
+                    },
+                    txHex: yield getTxHex({ haskoinUrl: this.baseUrl, txId: utxo.txid, network: this.haskoinNetwork }),
+                });
+            })));
+        });
+    }
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function unwrapExports (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var promisePoolError = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePoolError = void 0;
+class PromisePoolError extends Error {
+    /**
+     * Create a new instance for the given `message` and `item`.
+     *
+     * @param error  The original error
+     * @param item   The item causing the error
+     */
+    constructor(error, item) {
+        super();
+        this.raw = error;
+        this.item = item;
+        this.name = this.constructor.name;
+        this.message = this.messageFrom(error);
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /**
+     * Returns a new promise pool error instance wrapping the `error` and `item`.
+     *
+     * @param {*} error
+     * @param {*} item
+     *
+     * @returns {PromisePoolError}
+     */
+    static createFrom(error, item) {
+        return new this(error, item);
+    }
+    /**
+     * Returns the error message from the given `error`.
+     *
+     * @param {*} error
+     *
+     * @returns {String}
+     */
+    messageFrom(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'object') {
+            return error.message;
+        }
+        if (typeof error === 'string' || typeof error === 'number') {
+            return error.toString();
+        }
+        return '';
+    }
+}
+exports.PromisePoolError = PromisePoolError;
+});
+
+unwrapExports(promisePoolError);
+var promisePoolError_1 = promisePoolError.PromisePoolError;
+
+var stopThePromisePoolError = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopThePromisePoolError = void 0;
+class StopThePromisePoolError extends Error {
+}
+exports.StopThePromisePoolError = StopThePromisePoolError;
+});
+
+unwrapExports(stopThePromisePoolError);
+var stopThePromisePoolError_1 = stopThePromisePoolError.StopThePromisePoolError;
+
+var validationError = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+class ValidationError extends Error {
+    /**
+     * Create a new instance for the given `message`.
+     *
+     * @param message  The error message
+     */
+    constructor(message) {
+        super(message);
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /**
+     * Returns a validation error with the given `message`.
+     */
+    static createFrom(message) {
+        return new this(message);
+    }
+}
+exports.ValidationError = ValidationError;
+});
+
+unwrapExports(validationError);
+var validationError_1 = validationError.ValidationError;
+
+var promisePoolExecutor = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePoolExecutor = void 0;
+
+
+
+
+class PromisePoolExecutor {
+    /**
+     * Creates a new promise pool executer instance with a default concurrency of 10.
+     */
+    constructor() {
+        this.meta = {
+            tasks: [],
+            items: [],
+            errors: [],
+            results: [],
+            stopped: false,
+            concurrency: 10,
+            shouldResultsCorrespond: false,
+            processedItems: [],
+            taskTimeout: 0
+        };
+        this.handler = () => { };
+        this.errorHandler = undefined;
+        this.onTaskStartedHandlers = [];
+        this.onTaskFinishedHandlers = [];
+    }
+    /**
+     * Set the number of tasks to process concurrently the promise pool.
+     *
+     * @param {Integer} concurrency
+     *
+     * @returns {PromisePoolExecutor}
+     */
+    useConcurrency(concurrency) {
+        if (!this.isValidConcurrency(concurrency)) {
+            throw validationError.ValidationError.createFrom(`"concurrency" must be a number, 1 or up. Received "${concurrency}" (${typeof concurrency})`);
+        }
+        this.meta.concurrency = concurrency;
+        return this;
+    }
+    /**
+     * Determine whether the given `concurrency` value is valid.
+     *
+     * @param {Number} concurrency
+     *
+     * @returns {Boolean}
+     */
+    isValidConcurrency(concurrency) {
+        return typeof concurrency === 'number' && concurrency >= 1;
+    }
+    /**
+     * Set the timeout in ms for the pool handler
+     *
+     * @param {Number} timeout
+     *
+     * @returns {PromisePool}
+     */
+    withTaskTimeout(timeout) {
+        this.meta.taskTimeout = timeout;
+        return this;
+    }
+    /**
+     * Returns the number of concurrently processed tasks.
+     *
+     * @returns {Number}
+     */
+    concurrency() {
+        return this.meta.concurrency;
+    }
+    /**
+     * Assign whether to keep corresponding results between source items and resulting tasks.
+     */
+    useCorrespondingResults(shouldResultsCorrespond) {
+        this.meta.shouldResultsCorrespond = shouldResultsCorrespond;
+        return this;
+    }
+    /**
+     * Determine whether to keep corresponding results between source items and resulting tasks.
+     */
+    shouldUseCorrespondingResults() {
+        return this.meta.shouldResultsCorrespond;
+    }
+    /**
+     * Returns the task timeout in milliseconds.
+     */
+    taskTimeout() {
+        return this.meta.taskTimeout;
+    }
+    /**
+     * Set the items to be processed in the promise pool.
+     *
+     * @param {Array} items
+     *
+     * @returns {PromisePoolExecutor}
+     */
+    for(items) {
+        this.meta.items = items;
+        return this;
+    }
+    /**
+     * Returns the list of items to process.
+     *
+     * @returns {T[]}
+     */
+    items() {
+        return this.meta.items;
+    }
+    /**
+     * Returns the number of items to process.
+     *
+     * @returns {Number}
+     */
+    itemsCount() {
+        return this.items().length;
+    }
+    /**
+     * Returns the list of active tasks.
+     *
+     * @returns {Array}
+     */
+    tasks() {
+        return this.meta.tasks;
+    }
+    /**
+     * Returns the number of currently active tasks.
+     *
+     * @returns {Number}
+     *
+     * @deprecated use the `activeTasksCount()` method (plural naming) instead
+     */
+    activeTaskCount() {
+        return this.activeTasksCount();
+    }
+    /**
+     * Returns the number of currently active tasks.
+     *
+     * @returns {Number}
+     */
+    activeTasksCount() {
+        return this.tasks().length;
+    }
+    /**
+     * Returns the list of processed items.
+     *
+     * @returns {T[]}
+     */
+    processedItems() {
+        return this.meta.processedItems;
+    }
+    /**
+     * Returns the number of processed items.
+     *
+     * @returns {Number}
+     */
+    processedCount() {
+        return this.processedItems().length;
+    }
+    /**
+     * Returns the percentage progress of items that have been processed.
+     */
+    processedPercentage() {
+        return (this.processedCount() / this.itemsCount()) * 100;
+    }
+    /**
+     * Returns the list of results.
+     *
+     * @returns {R[]}
+     */
+    results() {
+        return this.meta.results;
+    }
+    /**
+     * Returns the list of errors.
+     *
+     * @returns {Array<PromisePoolError<T>>}
+     */
+    errors() {
+        return this.meta.errors;
+    }
+    /**
+     * Set the handler that is applied to each item.
+     *
+     * @param {Function} action
+     *
+     * @returns {PromisePoolExecutor}
+     */
+    withHandler(action) {
+        this.handler = action;
+        return this;
+    }
+    /**
+     * Determine whether a custom error handle is available.
+     *
+     * @returns {Boolean}
+     */
+    hasErrorHandler() {
+        return !!this.errorHandler;
+    }
+    /**
+     * Set the error handler function to execute when an error occurs.
+     *
+     * @param {Function} errorHandler
+     *
+     * @returns {PromisePoolExecutor}
+     */
+    handleError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    /**
+     * Set the handler function to execute when started a task.
+     *
+     * @param {Function} handler
+     *
+     * @returns {this}
+     */
+    onTaskStarted(handlers) {
+        this.onTaskStartedHandlers = handlers;
+        return this;
+    }
+    /**
+      * Assign the given callback `handler` function to run when a task finished.
+     *
+     * @param {OnProgressCallback<T>} handlers
+     *
+     * @returns {this}
+     */
+    onTaskFinished(handlers) {
+        this.onTaskFinishedHandlers = handlers;
+        return this;
+    }
+    /**
+     * Determines whether the number of active tasks is greater or equal to the concurrency limit.
+     *
+     * @returns {Boolean}
+     */
+    hasReachedConcurrencyLimit() {
+        return this.activeTasksCount() >= this.concurrency();
+    }
+    /**
+     * Stop a promise pool processing.
+     */
+    stop() {
+        this.markAsStopped();
+        throw new stopThePromisePoolError.StopThePromisePoolError();
+    }
+    /**
+     * Mark the promise pool as stopped.
+     *
+     * @returns {PromisePoolExecutor}
+     */
+    markAsStopped() {
+        this.meta.stopped = true;
+        return this;
+    }
+    /**
+     * Determine whether the pool is stopped.
+     *
+     * @returns {Boolean}
+     */
+    isStopped() {
+        return this.meta.stopped;
+    }
+    /**
+     * Start processing the promise pool.
+     *
+     * @returns {ReturnValue}
+     */
+    async start() {
+        return await this
+            .validateInputs()
+            .prepareResultsArray()
+            .process();
+    }
+    /**
+     * Determine whether the pool should stop.
+     *
+     * @returns {PromisePoolExecutor}
+     *
+     * @throws
+     */
+    validateInputs() {
+        if (typeof this.handler !== 'function') {
+            throw validationError.ValidationError.createFrom('The first parameter for the .process(fn) method must be a function');
+        }
+        const timeout = this.taskTimeout();
+        if (!(timeout == null || (typeof timeout === 'number' && timeout >= 0))) {
+            throw validationError.ValidationError.createFrom(`"timeout" must be undefined or a number. A number must be 0 or up. Received "${String(timeout)}" (${typeof timeout})`);
+        }
+        if (!Array.isArray(this.items())) {
+            throw validationError.ValidationError.createFrom(`"items" must be an array. Received "${typeof this.items()}"`);
+        }
+        if (this.errorHandler && typeof this.errorHandler !== 'function') {
+            throw validationError.ValidationError.createFrom(`The error handler must be a function. Received "${typeof this.errorHandler}"`);
+        }
+        this.onTaskStartedHandlers.forEach(handler => {
+            if (handler && typeof handler !== 'function') {
+                throw validationError.ValidationError.createFrom(`The onTaskStarted handler must be a function. Received "${typeof handler}"`);
+            }
+        });
+        this.onTaskFinishedHandlers.forEach(handler => {
+            if (handler && typeof handler !== 'function') {
+                throw validationError.ValidationError.createFrom(`The error handler must be a function. Received "${typeof handler}"`);
+            }
+        });
+        return this;
+    }
+    /**
+     * Prefill the results array with `notRun` symbol values if results should correspond.
+     */
+    prepareResultsArray() {
+        if (this.shouldUseCorrespondingResults()) {
+            this.meta.results = Array(this.items().length).fill(promisePool.PromisePool.notRun);
+        }
+        return this;
+    }
+    /**
+     * Starts processing the promise pool by iterating over the items
+     * and running each item through the async `callback` function.
+     *
+     * @param {Function} callback
+     *
+     * @returns {Promise}
+     */
+    async process() {
+        for (const [index, item] of this.items().entries()) {
+            if (this.isStopped()) {
+                break;
+            }
+            await this.waitForProcessingSlot();
+            this.startProcessing(item, index);
+        }
+        return await this.drained();
+    }
+    /**
+     * Wait for one of the active tasks to finish processing.
+     */
+    async waitForProcessingSlot() {
+        /**
+         * We’re using a while loop here because it’s possible to decrease the pool’s
+         * concurrency at runtime. We need to wait for as many tasks as needed to
+         * finish processing before moving on to process the remaining tasks.
+         */
+        while (this.hasReachedConcurrencyLimit()) {
+            await this.waitForActiveTaskToFinish();
+        }
+    }
+    /**
+     * Wait for the next, currently active task to finish processing.
+     */
+    async waitForActiveTaskToFinish() {
+        await Promise.race(this.tasks());
+    }
+    /**
+     * Create a processing function for the given `item`.
+     *
+     * @param {T} item
+     * @param {number} index
+     */
+    startProcessing(item, index) {
+        const task = this.createTaskFor(item, index)
+            .then(result => {
+            this.save(result, index).removeActive(task);
+        })
+            .catch(async (error) => {
+            await this.handleErrorFor(error, item, index);
+            this.removeActive(task);
+        })
+            .finally(() => {
+            this.processedItems().push(item);
+            this.runOnTaskFinishedHandlers(item);
+        });
+        this.tasks().push(task);
+        this.runOnTaskStartedHandlers(item);
+    }
+    /**
+     * Ensures a returned promise for the processing of the given `item`.
+     *
+     * @param {T} item
+     * @param {number} index
+     *
+     * @returns {*}
+     */
+    async createTaskFor(item, index) {
+        if (this.taskTimeout() === undefined) {
+            return this.handler(item, index, this);
+        }
+        return Promise.race([
+            this.handler(item, index, this),
+            this.createTaskTimeout(item)
+        ]);
+    }
+    /**
+     * Returns a promise that times-out after the configured task timeout.
+     */
+    async createTaskTimeout(item) {
+        return new Promise((_resolve, reject) => {
+            setTimeout(() => {
+                reject(new promisePoolError.PromisePoolError(`Promise in pool timed out after ${this.taskTimeout()}ms`, item));
+            }, this.taskTimeout());
+        });
+    }
+    /**
+     * Save the given calculation `result`, possibly at the provided `position`.
+     *
+     * @param {*} result
+     * @param {number} position
+     *
+     * @returns {PromisePoolExecutor}
+     */
+    save(result, position) {
+        this.shouldUseCorrespondingResults()
+            ? this.results()[position] = result
+            : this.results().push(result);
+        return this;
+    }
+    /**
+     * Remove the given `task` from the list of active tasks.
+     *
+     * @param {Promise} task
+     */
+    removeActive(task) {
+        this.tasks().splice(this.tasks().indexOf(task), 1);
+        return this;
+    }
+    /**
+     * Create and save an error for the the given `item`.
+     *
+     * @param {Error} error
+     * @param {T} item
+     * @param {number} index
+     */
+    async handleErrorFor(error, item, index) {
+        if (this.shouldUseCorrespondingResults()) {
+            this.results()[index] = promisePool.PromisePool.failed;
+        }
+        if (this.isStoppingThePoolError(error)) {
+            return;
+        }
+        if (this.isValidationError(error)) {
+            this.markAsStopped();
+            throw error;
+        }
+        this.hasErrorHandler()
+            ? await this.runErrorHandlerFor(error, item)
+            : this.saveErrorFor(error, item);
+    }
+    /**
+     * Determine whether the given `error` is a `StopThePromisePoolError` instance.
+     *
+     * @param {Error} error
+     *
+     * @returns {Boolean}
+     */
+    isStoppingThePoolError(error) {
+        return error instanceof stopThePromisePoolError.StopThePromisePoolError;
+    }
+    /**
+     * Determine whether the given `error` is a `ValidationError` instance.
+     *
+     * @param {Error} error
+     *
+     * @returns {Boolean}
+     */
+    isValidationError(error) {
+        return error instanceof validationError.ValidationError;
+    }
+    /**
+     * Run the user’s error handler, if available.
+     *
+     * @param {Error} processingError
+     * @param {T} item
+     */
+    async runErrorHandlerFor(processingError, item) {
+        var _a;
+        try {
+            await ((_a = this.errorHandler) === null || _a === void 0 ? void 0 : _a.call(this, processingError, item, this));
+        }
+        catch (error) {
+            this.rethrowIfNotStoppingThePool(error);
+        }
+    }
+    /**
+     * Run the onTaskStarted handlers.
+     */
+    runOnTaskStartedHandlers(item) {
+        this.onTaskStartedHandlers.forEach(handler => {
+            handler(item, this);
+        });
+    }
+    /**
+     * Run the onTaskFinished handlers.
+     */
+    runOnTaskFinishedHandlers(item) {
+        this.onTaskFinishedHandlers.forEach(handler => {
+            handler(item, this);
+        });
+    }
+    /**
+     * Rethrow the given `error` if it’s not an instance of `StopThePromisePoolError`.
+     *
+     * @param {Error} error
+     */
+    rethrowIfNotStoppingThePool(error) {
+        if (this.isStoppingThePoolError(error)) {
+            return;
+        }
+        throw error;
+    }
+    /**
+     * Create and save an error for the the given `item`.
+     *
+     * @param {T} item
+     */
+    saveErrorFor(error, item) {
+        this.errors().push(promisePoolError.PromisePoolError.createFrom(error, item));
+    }
+    /**
+     * Wait for all active tasks to finish. Once all the tasks finished
+     * processing, returns an object containing the results and errors.
+     *
+     * @returns {Object}
+     */
+    async drained() {
+        await this.drainActiveTasks();
+        return {
+            errors: this.errors(),
+            results: this.results()
+        };
+    }
+    /**
+     * Wait for all of the active tasks to finish processing.
+     */
+    async drainActiveTasks() {
+        await Promise.all(this.tasks());
+    }
+}
+exports.PromisePoolExecutor = PromisePoolExecutor;
+});
+
+unwrapExports(promisePoolExecutor);
+var promisePoolExecutor_1 = promisePoolExecutor.PromisePoolExecutor;
+
+var promisePool = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePool = void 0;
+
+class PromisePool {
+    /**
+     * Instantiates a new promise pool with a default `concurrency: 10` and `items: []`.
+     *
+     * @param {Object} options
+     */
+    constructor(items) {
+        this.timeout = undefined;
+        this.concurrency = 10;
+        this.shouldResultsCorrespond = false;
+        this.items = items !== null && items !== void 0 ? items : [];
+        this.errorHandler = undefined;
+        this.onTaskStartedHandlers = [];
+        this.onTaskFinishedHandlers = [];
+    }
+    /**
+     * Set the number of tasks to process concurrently in the promise pool.
+     *
+     * @param {Integer} concurrency
+     *
+     * @returns {PromisePool}
+     */
+    withConcurrency(concurrency) {
+        this.concurrency = concurrency;
+        return this;
+    }
+    /**
+     * Set the number of tasks to process concurrently in the promise pool.
+     *
+     * @param {Number} concurrency
+     *
+     * @returns {PromisePool}
+     */
+    static withConcurrency(concurrency) {
+        return new this().withConcurrency(concurrency);
+    }
+    /**
+     * Set the timeout in milliseconds for the pool handler.
+     *
+     * @param {Number} timeout
+     *
+     * @returns {PromisePool}
+     */
+    withTaskTimeout(timeout) {
+        this.timeout = timeout;
+        return this;
+    }
+    /**
+     * Set the timeout in milliseconds for the pool handler.
+     *
+     * @param {Number} timeout
+     *
+     * @returns {PromisePool}
+     */
+    static withTaskTimeout(timeout) {
+        return new this().withTaskTimeout(timeout);
+    }
+    /**
+     * Set the items to be processed in the promise pool.
+     *
+     * @param {T[]} items
+     *
+     * @returns {PromisePool}
+     */
+    for(items) {
+        return typeof this.timeout === 'number'
+            ? new PromisePool(items).withConcurrency(this.concurrency).withTaskTimeout(this.timeout)
+            : new PromisePool(items).withConcurrency(this.concurrency);
+    }
+    /**
+     * Set the items to be processed in the promise pool.
+     *
+     * @param {T[]} items
+     *
+     * @returns {PromisePool}
+     */
+    static for(items) {
+        return new this().for(items);
+    }
+    /**
+     * Set the error handler function to execute when an error occurs.
+     *
+     * @param {ErrorHandler<T>} handler
+     *
+     * @returns {PromisePool}
+     */
+    handleError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    /**
+     * Assign the given callback `handler` function to run when a task starts.
+     *
+     * @param {OnProgressCallback<T>} handler
+     *
+     * @returns {PromisePool}
+     */
+    onTaskStarted(handler) {
+        this.onTaskStartedHandlers.push(handler);
+        return this;
+    }
+    /**
+     * Assign the given callback `handler` function to run when a task finished.
+     *
+     * @param {OnProgressCallback<T>} handler
+     *
+     * @returns {PromisePool}
+     */
+    onTaskFinished(handler) {
+        this.onTaskFinishedHandlers.push(handler);
+        return this;
+    }
+    /**
+     * Assign whether to keep corresponding results between source items and resulting tasks.
+     */
+    useCorrespondingResults() {
+        this.shouldResultsCorrespond = true;
+        return this;
+    }
+    /**
+     * Starts processing the promise pool by iterating over the items
+     * and running each item through the async `callback` function.
+     *
+     * @param {ProcessHandler} The async processing function receiving each item from the `items` array.
+     *
+     * @returns Promise<{ results, errors }>
+     */
+    async process(callback) {
+        return new promisePoolExecutor.PromisePoolExecutor()
+            .useConcurrency(this.concurrency)
+            .useCorrespondingResults(this.shouldResultsCorrespond)
+            .withTaskTimeout(this.timeout)
+            .withHandler(callback)
+            .handleError(this.errorHandler)
+            .onTaskStarted(this.onTaskStartedHandlers)
+            .onTaskFinished(this.onTaskFinishedHandlers)
+            .for(this.items)
+            .start();
+    }
+}
+exports.PromisePool = PromisePool;
+PromisePool.notRun = Symbol('notRun');
+PromisePool.failed = Symbol('failed');
+});
+
+unwrapExports(promisePool);
+var promisePool_1 = promisePool.PromisePool;
+
+var contracts = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+unwrapExports(contracts);
+
+var returnValue = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+unwrapExports(returnValue);
+
+var dist = createCommonjsModule(function (module, exports) {
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+exports.default = promisePool.PromisePool;
+__exportStar(contracts, exports);
+__exportStar(promisePool, exports);
+__exportStar(promisePoolError, exports);
+__exportStar(returnValue, exports);
+__exportStar(stopThePromisePoolError, exports);
+__exportStar(validationError, exports);
+});
+
+var PromisePool = unwrapExports(dist);
+
+/**
+ * Get transaction by hash.
+ *
+ *
+ * @param {string} baseUrl The sochain node url.
+ * @param {string} network network id
+ * @param {string} hash The transaction hash.
+ * @returns {Transactions}
+ */
+const getTx$2 = ({ apiKey, baseUrl, network, hash }) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = { includeHex: 'true' };
+    if (apiKey)
+        params['token'] = apiKey;
+    const url = `${baseUrl}/${network}/txs/${hash}`;
+    const response = yield axios.get(url, { params });
+    const tx = response.data;
+    return tx;
+});
+/**
+ * Get transactions
+ *
+ *
+ * @param {string} baseUrl The sochain node url.
+ * @param {string} network network id
+ * @param {string} hash The transaction hash.
+ * @returns {Transactions}
+ */
+const getTxs$2 = ({ apiKey, address, baseUrl, network, beforeBlock, limit, unspentOnly, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = { limit: `${limit}`, unspentOnly: `${unspentOnly}` };
+    const url = `${baseUrl}/${network}/addrs/${address}`;
+    if (apiKey)
+        params['token'] = apiKey;
+    if (beforeBlock)
+        params['before'] = `${beforeBlock}`;
+    const response = yield axios.get(url, { params });
+    const txs = response.data;
+    return txs;
+});
+/**
+ * Get address balance.
+ *
+ *
+ * @param {string} baseUrl The sochain node url.
+ * @param {string} network Network
+ * @param {string} address Address
+ * @param {boolean} confirmedOnly Flag whether to get balances of confirmed txs only or for all
+ * @returns {number}
+ */
+const getBalance$2 = ({ apiKey, baseUrl, network, address, confirmedOnly, assetDecimals, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = {};
+    const url = `${baseUrl}/${network}/addrs/${address}/balance`;
+    if (apiKey)
+        params['token'] = apiKey;
+    const response = yield axios.get(url, { params });
+    const balanceResponse = response.data;
+    const confirmedAmount = baseAmount(balanceResponse.balance, assetDecimals);
+    const finalBalance = baseAmount(balanceResponse.final_balance, assetDecimals);
+    return confirmedOnly ? confirmedAmount : finalBalance;
+});
+const broadcastTx$2 = ({ apiKey, baseUrl, network, txHex, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = {};
+    const url = `${baseUrl}/${network}/txs/push`;
+    if (apiKey)
+        params['token'] = apiKey;
+    const response = yield axios.post(url, { tx: txHex }, { params });
+    const broadcastResponse = response.data;
+    return broadcastResponse.tx.hash;
+});
+
+class BlockcypherProvider {
+    constructor(baseUrl = 'https://api.blockcypher.com/v1/', chain, asset, assetDecimals, blockcypherNetwork, apiKey) {
+        this.baseUrl = baseUrl;
+        this._apiKey = apiKey;
+        this.chain = chain;
+        this.asset = asset;
+        this.assetDecimals = assetDecimals;
+        this.blockcypherNetwork = blockcypherNetwork;
+        this.asset;
+        this.chain;
+    }
+    get apiKey() {
+        return this._apiKey;
+    }
+    set apiKey(value) {
+        this._apiKey = value;
+    }
+    broadcastTx(txHex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield broadcastTx$2({
+                apiKey: this._apiKey,
+                baseUrl: this.baseUrl,
+                network: this.blockcypherNetwork,
+                txHex,
+            });
+        });
+    }
+    getConfirmedUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield this.getRawTransactions({ address, offset: 0, limit: 2000 }, true);
+            return this.mapUTXOs(address, allUnspent.filter((i) => i.confirmed));
+        });
+    }
+    getUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield this.getRawTransactions({ address, offset: 0, limit: 2000 }, true);
+            return this.mapUTXOs(address, allUnspent);
+        });
+    }
+    getBalance(address, assets /*ignored*/, confirmedOnly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const amount = yield getBalance$2({
+                apiKey: this._apiKey,
+                baseUrl: this.baseUrl,
+                network: this.blockcypherNetwork,
+                address,
+                confirmedOnly: !!confirmedOnly,
+                assetDecimals: this.assetDecimals,
+            });
+            return [{ amount, asset: this.asset }];
+        });
+    }
+    /**
+     * Get transaction history of a given address with pagination options.
+     * By default it will return the transaction history of the current wallet.
+     *
+     * @param {TxHistoryParams} params The options to get transaction history. (optional)
+     * @returns {TxsPage} The transaction history.
+     */
+    getTransactions(params, unspentOnly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rawTxs = yield this.getRawTransactions(params, unspentOnly);
+            const txs = rawTxs.map((i) => this.mapTransactionToTx(i));
+            const result = {
+                total: txs.length,
+                txs,
+            };
+            return result;
+        });
+    }
+    /**
+     * Get the transaction details of a given transaction id.
+     *
+     * @param {string} txId The transaction id.
+     * @returns {Tx} The transaction details of the given transaction id.
+     */
+    getTransactionData(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const rawTx = yield getTx$2({
+                    apiKey: this._apiKey,
+                    baseUrl: this.baseUrl,
+                    network: this.blockcypherNetwork,
+                    hash: txId,
+                });
+                return this.mapTransactionToTx(rawTx);
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+    mapTransactionToTx(rawTx) {
+        return {
+            asset: this.asset,
+            from: rawTx.inputs.map((i) => ({
+                from: i.addresses[0],
+                amount: baseAmount(i.output_value, this.assetDecimals),
+            })),
+            to: rawTx.outputs
+                .filter((i) => i.script_type !== 'null-data') //filter out op_return outputs
+                .map((i) => ({ to: i.addresses[0], amount: baseAmount(i.value, this.assetDecimals) })),
+            date: new Date(rawTx.confirmed),
+            type: TxType.Transfer,
+            hash: rawTx.hash,
+        };
+    }
+    mapUTXOs(address, utxos) {
+        const utxosOut = [];
+        for (let index = 0; index < utxos.length; index++) {
+            const utxo = utxos[index];
+            for (let index2 = 0; index2 < utxo.outputs.length; index2++) {
+                const output = utxo.outputs[index2];
+                if (output.addresses && output.addresses[0] === address) {
+                    const utxoOut = {
+                        hash: utxo.hash,
+                        index: index2,
+                        value: baseAmount(output.value, this.assetDecimals).amount().toNumber(),
+                        witnessUtxo: {
+                            value: baseAmount(output.value, this.assetDecimals).amount().toNumber(),
+                            script: Buffer.from(output.script, 'hex'),
+                        },
+                        txHex: utxo.hex,
+                    };
+                    utxosOut.push(utxoOut);
+                }
+            }
+        }
+        return utxosOut;
+    }
+    /**
+     * helper function tto limit adding to an array
+     *
+     * @param arr array to be added to
+     * @param toAdd elements to add
+     * @param limit do not add more than this limit
+     */
+    addArrayUpToLimit(arr, toAdd, limit) {
+        for (let index = 0; index < toAdd.length; index++) {
+            const element = toAdd[index];
+            if (arr.length < limit) {
+                arr.push(element);
+            }
+        }
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Get transaction history of a given address with pagination options.
+     * By default it will return the transaction history of the current wallet.
+     *
+     * @param {TxHistoryParams} params The options to get transaction history. (optional)
+     * @returns {TxsPage} The transaction history.
+     */
+    getRawTransactions(params, unspentOnly = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const offset = (_a = params === null || params === void 0 ? void 0 : params.offset) !== null && _a !== void 0 ? _a : 0;
+            const limit = (params === null || params === void 0 ? void 0 : params.limit) || 10;
+            if (offset + limit > 2000)
+                throw Error('cannot fetch more than last 2000 txs');
+            if (offset < 0 || limit < 0)
+                throw Error('ofset and limit must be equal or greater than 0');
+            const txHashesToFetch = [];
+            try {
+                const response = yield getTxs$2({
+                    apiKey: this._apiKey,
+                    baseUrl: this.baseUrl,
+                    network: this.blockcypherNetwork,
+                    address: `${params === null || params === void 0 ? void 0 : params.address}`,
+                    limit: 2000,
+                    unspentOnly,
+                });
+                //remove duplicates
+                const txs = response.txrefs.map((i) => i.tx_hash);
+                const uniqTxs = [...new Set(txs)];
+                const start = offset >= uniqTxs.length ? uniqTxs.length : offset;
+                const end = offset + limit >= uniqTxs.length ? uniqTxs.length : offset + limit;
+                const txsToFetch = uniqTxs.slice(start, end);
+                // console.log(JSON.stringify(txsToFetch, null, 2))
+                this.addArrayUpToLimit(txHashesToFetch, txsToFetch, limit);
+            }
+            catch (error) {
+                console.error(error);
+                //an errors means no more results
+            }
+            //note: blockcypher has rate of 3 req/sec --> https://www.blockcypher.com/dev/bitcoin/#rate-limits-and-tokens
+            const batchResult = yield PromisePool.for(txHashesToFetch)
+                .withConcurrency(3)
+                .useCorrespondingResults()
+                .process((hash) => __awaiter(this, void 0, void 0, function* () {
+                yield this.delay(1000);
+                const rawTx = yield getTx$2({
+                    apiKey: this._apiKey,
+                    baseUrl: this.baseUrl,
+                    network: this.blockcypherNetwork,
+                    hash,
+                });
+                return rawTx;
+            }));
+            return batchResult.results;
+        });
+    }
+}
+
+var BlockcypherNetwork;
+(function (BlockcypherNetwork) {
+    BlockcypherNetwork["BTC"] = "btc/main";
+    BlockcypherNetwork["BTCTEST"] = "btc/test3";
+    BlockcypherNetwork["LTC"] = "ltc/main";
+    BlockcypherNetwork["DOGE"] = "doge/main";
+})(BlockcypherNetwork || (BlockcypherNetwork = {}));
+
+export { BlockcypherNetwork, BlockcypherProvider, HaskoinNetwork, HaskoinProvider, SochainNetwork, SochainProvider, broadcastTx$1 as broadcastTx, getAccount, getAddress, getBalance$1 as getBalance, getConfirmedTxStatus, getConfirmedUnspentTxs, getIsTxConfirmed, getTx$1 as getTx, getTxs$1 as getTxs, getUnspentTxs$1 as getUnspentTxs };