@xchainjs/xchain-utxo-providers 0.1.1 → 0.2.0

package/lib/index.js

@@ -1,14 +1,1057 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var xchainUtil = require('@xchainjs/xchain-util');
+var axios = require('axios');
+var xchainClient = require('@xchainjs/xchain-client');
+var PromisePool = require('@supercharge/promise-pool');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var PromisePool__default = /*#__PURE__*/_interopDefaultLegacy(PromisePool);
+
+exports.SochainNetwork = void 0;
+(function (SochainNetwork) {
+    SochainNetwork["BTC"] = "BTC";
+    SochainNetwork["BTCTEST"] = "BTCTEST";
+    SochainNetwork["LTC"] = "LTC";
+    SochainNetwork["LTCTEST"] = "LTCTEST";
+    SochainNetwork["DOGE"] = "DOGE";
+    SochainNetwork["DOGETEST"] = "DOGETEST";
+})(exports.SochainNetwork || (exports.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$2 = ({ apiKey, sochainUrl, network, hash }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/transaction/${network}/${hash}`;
+    const response = yield axios__default["default"].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$2 = ({ 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__default["default"].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$2 = ({ apiKey, sochainUrl, network, address, confirmedOnly, assetDecimals, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/balance/${network}/${address}`;
+    const response = yield axios__default["default"].get(url, { headers: { 'API-KEY': apiKey } });
+    const balanceResponse = response.data;
+    const confirmed = xchainUtil.assetAmount(balanceResponse.data.confirmed, assetDecimals);
+    const unconfirmed = xchainUtil.assetAmount(balanceResponse.data.unconfirmed, assetDecimals);
+    const netAmt = confirmedOnly ? confirmed : confirmed.plus(unconfirmed);
+    const result = xchainUtil.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$1 = ({ 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__default["default"].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$1({
+            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$2 = ({ apiKey, sochainUrl, network, txHex, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = `${sochainUrl}/broadcast_transaction/${network}`;
+    const response = yield axios__default["default"].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$2({
+                apiKey: this._apiKey,
+                sochainUrl: this.baseUrl,
+                network: this.sochainNetwork,
+                txHex,
+            });
+        });
+    }
+    getConfirmedUnspentTxs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allUnspent = yield getUnspentTxs$1({
+                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$1({
+                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$2({
+                    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$2({
+                        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$2({
+                    apiKey: this._apiKey,
+                    sochainUrl: this.baseUrl,
+                    network: this.sochainNetwork,
+                    hash: txId,
+                });
+                return {
+                    asset: this.asset,
+                    from: rawTx.inputs.map((i) => ({
+                        from: i.address,
+                        amount: xchainUtil.assetToBase(xchainUtil.assetAmount(i.value, this.assetDecimals)),
+                    })),
+                    to: rawTx.outputs
+                        .filter((i) => i.type !== 'nulldata') //filter out op_return outputs
+                        .map((i) => ({ to: i.address, amount: xchainUtil.assetToBase(xchainUtil.assetAmount(i.value, this.assetDecimals)) })),
+                    date: new Date(rawTx.time * 1000),
+                    type: xchainClient.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: xchainUtil.assetToBase(xchainUtil.assetAmount(utxo.value, this.assetDecimals)).amount().toNumber(),
+            witnessUtxo: {
+                value: xchainUtil.assetToBase(xchainUtil.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
+ */
+exports.HaskoinNetwork = void 0;
+(function (HaskoinNetwork) {
+    HaskoinNetwork["BTC"] = "btc";
+    HaskoinNetwork["BTCTEST"] = "btctest";
+    HaskoinNetwork["BCH"] = "bch";
+    HaskoinNetwork["BCHTEST"] = "bchtest";
+})(exports.HaskoinNetwork || (exports.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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./providers"), exports);
-//# sourceMappingURL=index.js.map
+/**
+ * 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__default["default"].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__default["default"].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__default["default"].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__default["default"].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__default["default"].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__default["default"].get(`${haskoinUrl}/${haskoinNetwork}/address/${address}/balance`);
+    const confirmedAmount = xchainUtil.baseAmount(confirmed, assetDecimals);
+    const unconfirmedAmount = xchainUtil.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 = ({ 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__default["default"].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({
+        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__default["default"].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__default["default"].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 xchainUtil.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({
+                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: xchainUtil.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: xchainUtil.baseAmount(i.value, this.assetDecimals) })),
+            date: new Date(rawTx.time),
+            type: xchainClient.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: xchainUtil.baseAmount(utxo.value, this.assetDecimals).amount().toNumber(),
+                    witnessUtxo: {
+                        value: xchainUtil.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 }),
+                });
+            })));
+        });
+    }
+}
+
+/**
+ * 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 = ({ 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__default["default"].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 = ({ 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__default["default"].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 = ({ 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__default["default"].get(url, { params });
+    const balanceResponse = response.data;
+    const confirmedAmount = xchainUtil.baseAmount(balanceResponse.balance, assetDecimals);
+    const finalBalance = xchainUtil.baseAmount(balanceResponse.final_balance, assetDecimals);
+    return confirmedOnly ? confirmedAmount : finalBalance;
+});
+const broadcastTx = ({ 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__default["default"].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({
+                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({
+                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({
+                    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: xchainUtil.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: xchainUtil.baseAmount(i.value, this.assetDecimals) })),
+            date: new Date(rawTx.confirmed),
+            type: xchainClient.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: xchainUtil.baseAmount(output.value, this.assetDecimals).amount().toNumber(),
+                        witnessUtxo: {
+                            value: xchainUtil.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({
+                    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__default["default"].for(txHashesToFetch)
+                .withConcurrency(3)
+                .useCorrespondingResults()
+                .process((hash) => __awaiter(this, void 0, void 0, function* () {
+                yield this.delay(1000);
+                const rawTx = yield getTx({
+                    apiKey: this._apiKey,
+                    baseUrl: this.baseUrl,
+                    network: this.blockcypherNetwork,
+                    hash,
+                });
+                return rawTx;
+            }));
+            return batchResult.results;
+        });
+    }
+}
+
+exports.BlockcypherNetwork = void 0;
+(function (BlockcypherNetwork) {
+    BlockcypherNetwork["BTC"] = "btc/main";
+    BlockcypherNetwork["BTCTEST"] = "btc/test3";
+    BlockcypherNetwork["LTC"] = "ltc/main";
+    BlockcypherNetwork["DOGE"] = "doge/main";
+})(exports.BlockcypherNetwork || (exports.BlockcypherNetwork = {}));
+
+exports.BlockcypherProvider = BlockcypherProvider;
+exports.HaskoinProvider = HaskoinProvider;
+exports.SochainProvider = SochainProvider;
+exports.broadcastTx = broadcastTx$1;
+exports.getAccount = getAccount;
+exports.getAddress = getAddress;
+exports.getBalance = getBalance$1;
+exports.getConfirmedTxStatus = getConfirmedTxStatus;
+exports.getConfirmedUnspentTxs = getConfirmedUnspentTxs;
+exports.getIsTxConfirmed = getIsTxConfirmed;
+exports.getTx = getTx$1;
+exports.getTxs = getTxs$1;
+exports.getUnspentTxs = getUnspentTxs;