@xchainjs/xchain-doge 0.5.11 → 0.5.13

package/lib/index.esm.js

@@ -1,11 +1,10 @@
-import { ExplorerProvider, Network, standardFeeRates, calcFees, UTXOClient, checkFeeBounds } from '@xchainjs/xchain-client';
+import { TxType, ExplorerProvider, Network, standardFeeRates, calcFees, UTXOClient, checkFeeBounds } from '@xchainjs/xchain-client';
 import crypto$1$1 from 'crypto';
 import buffer from 'buffer';
 import axios from 'axios';
 import readableStream from 'readable-stream';
 import stream from 'stream';
 import string_decoder from 'string_decoder';
-import { SochainProvider, SochainNetwork, BlockcypherProvider, BlockcypherNetwork } from '@xchainjs/xchain-utxo-providers';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -77961,55 +77960,6 @@ var accumulative = function accumulative (utxos, outputs, feeRate) {
   return { fee: feeRate * bytesAccum }
 };
 
-/**
- * Minimum transaction fee
- * 100000 satoshi/kB (similar to current `minrelaytxfee`)
- * @see https://github.com/dogecoin/dogecoin/blob/master/src/validation.h#L58
- */
-const MIN_TX_FEE = 100000;
-const DOGE_DECIMAL = 8;
-const LOWER_FEE_BOUND = 40000;
-const UPPER_FEE_BOUND = 20000000;
-/**
- * Chain identifier for Dogecoin
- *
- */
-const DOGEChain = 'DOGE';
-/**
- * Base "chain" asset on dogecoin
- *
- * Based on definition in Thorchain `common`
- * @see https://gitlab.com/thorchain/thornode/-/blob/master/common/asset.go#L12-24
- */
-const AssetDOGE = { chain: DOGEChain, symbol: 'DOGE', ticker: 'DOGE', synth: false };
-// https://blockchair.com/
-const DOGE_MAINNET_EXPLORER = new ExplorerProvider('https://blockchair.com/dogecoin', 'https://blockchair.com/dogecoin/address/%%ADDRESS%%', 'https://blockchair.com/dogecoin/transaction/%%TX_ID%%');
-const DOGE_TESTNET_EXPLORER = new ExplorerProvider('https://blockexplorer.one/dogecoin/testnet', 'https://blockexplorer.one/dogecoin/testnet/address/%%ADDRESS%%', 'https://blockexplorer.one/dogecoin/testnet/tx/%%TX_ID%%');
-const blockstreamExplorerProviders = {
-    [Network.Testnet]: DOGE_TESTNET_EXPLORER,
-    [Network.Stagenet]: DOGE_MAINNET_EXPLORER,
-    [Network.Mainnet]: DOGE_MAINNET_EXPLORER,
-};
-//======================
-// sochain
-//======================
-const testnetSochainProvider = new SochainProvider('https://sochain.com/api/v3', 'PLACEHOLDER_APIKEY', DOGEChain, AssetDOGE, 8, SochainNetwork.DOGETEST);
-const mainnetSochainProvider = new SochainProvider('https://sochain.com/api/v3', 'PLACEHOLDER_APIKEY', DOGEChain, AssetDOGE, 8, SochainNetwork.DOGE);
-const sochainDataProviders = {
-    [Network.Testnet]: testnetSochainProvider,
-    [Network.Stagenet]: mainnetSochainProvider,
-    [Network.Mainnet]: mainnetSochainProvider,
-};
-//======================
-// Blockcypher
-//======================
-const mainnetBlockcypherProvider = new BlockcypherProvider('https://api.blockcypher.com/v1', DOGEChain, AssetDOGE, 8, BlockcypherNetwork.DOGE);
-const blockcypherDataProviders = {
-    [Network.Testnet]: undefined,
-    [Network.Stagenet]: mainnetBlockcypherProvider,
-    [Network.Mainnet]: mainnetBlockcypherProvider,
-};
-
 var bignumber$1 = createCommonjsModule$1(function (module) {
 (function (globalObject) {
 
@@ -80977,6 +80927,31 @@ const isBigNumberValue = (v) => typeof v === 'string' || typeof v === 'number' |
  * ```
  * */
 const ASSET_DECIMAL = 8;
+/**
+ * Factory to create values of assets (e.g. RUNE)
+ *
+ * @param {string|number|BigNumber|undefined} value - The asset amount, If the value is undefined, AssetAmount with value `0` will be returned.
+ * @param {number} decimal The decimal places. (optional)
+ * @returns {AssetAmount} The asset amount from the given value and decimal.
+ *
+ **/
+const assetAmount = (value, decimal = ASSET_DECIMAL) => {
+    const amount = fixedBN(value, decimal);
+    return {
+        type: Denomination.Asset,
+        amount: () => amount,
+        plus: (v, d = decimal) => assetAmount(amount.plus(isBigNumberValue(v) ? v : v.amount()), d),
+        minus: (v, d = decimal) => assetAmount(amount.minus(isBigNumberValue(v) ? v : v.amount()), d),
+        times: (v, d = decimal) => assetAmount(amount.times(isBigNumberValue(v) ? v : v.amount()), d),
+        div: (v, d = decimal) => assetAmount(amount.div(isBigNumberValue(v) ? v : v.amount()), d),
+        lt: (v) => amount.lt(isBigNumberValue(v) ? v : v.amount()),
+        lte: (v) => amount.lte(isBigNumberValue(v) ? v : v.amount()),
+        gt: (v) => amount.gt(isBigNumberValue(v) ? v : v.amount()),
+        gte: (v) => amount.gte(isBigNumberValue(v) ? v : v.amount()),
+        eq: (v) => amount.eq(isBigNumberValue(v) ? v : v.amount()),
+        decimal,
+    };
+};
 /**
  * Factory to create base amounts (e.g. tor)
  *
@@ -81001,6 +80976,19 @@ const baseAmount = (value, decimal = ASSET_DECIMAL) => {
         decimal,
     };
 };
+/**
+ * Helper to convert asset to base values (e.g. tor -> RUNE)
+ *
+ * @param {AssetAmount} asset
+ * @returns {BaseAmount} The base amount from the given AssetAmount.
+ * */
+const assetToBase = (asset) => {
+    const value = asset
+        .amount()
+        .multipliedBy(Math.pow(10, asset.decimal))
+        .integerValue();
+    return baseAmount(value, asset.decimal);
+};
 /**
  * Currency symbols currently supported
  */
@@ -81013,6 +81001,1513 @@ var AssetCurrencySymbol;
     AssetCurrencySymbol["USD"] = "$";
 })(AssetCurrencySymbol || (AssetCurrencySymbol = {}));
 
+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$1(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$1(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$1(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$1(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$1(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$1(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$1(this, void 0, void 0, function* () {
+            return yield broadcastTx({
+                apiKey: this._apiKey,
+                sochainUrl: this.baseUrl,
+                network: this.sochainNetwork,
+                txHex,
+            });
+        });
+    }
+    getConfirmedUnspentTxs(address) {
+        return __awaiter$1(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$1(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$1(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$1(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$1(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 = {}));
+
+var commonjsGlobal$2 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function unwrapExports$2 (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule$2(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var promisePoolError = createCommonjsModule$2(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$2(promisePoolError);
+var promisePoolError_1 = promisePoolError.PromisePoolError;
+
+var stopThePromisePoolError = createCommonjsModule$2(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopThePromisePoolError = void 0;
+class StopThePromisePoolError extends Error {
+}
+exports.StopThePromisePoolError = StopThePromisePoolError;
+});
+
+unwrapExports$2(stopThePromisePoolError);
+var stopThePromisePoolError_1 = stopThePromisePoolError.StopThePromisePoolError;
+
+var validationError = createCommonjsModule$2(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$2(validationError);
+var validationError_1 = validationError.ValidationError;
+
+var promisePoolExecutor = createCommonjsModule$2(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$2(promisePoolExecutor);
+var promisePoolExecutor_1 = promisePoolExecutor.PromisePoolExecutor;
+
+var promisePool = createCommonjsModule$2(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$2(promisePool);
+var promisePool_1 = promisePool.PromisePool;
+
+var contracts = createCommonjsModule$2(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+unwrapExports$2(contracts);
+
+var returnValue = createCommonjsModule$2(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+unwrapExports$2(returnValue);
+
+var dist$2 = createCommonjsModule$2(function (module, exports) {
+var __createBinding = (commonjsGlobal$2 && commonjsGlobal$2.__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$2 && commonjsGlobal$2.__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$2(dist$2);
+
+/**
+ * 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$1(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$1(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$1(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$1(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$1(this, void 0, void 0, function* () {
+            return yield broadcastTx$2({
+                apiKey: this._apiKey,
+                baseUrl: this.baseUrl,
+                network: this.blockcypherNetwork,
+                txHex,
+            });
+        });
+    }
+    getConfirmedUnspentTxs(address) {
+        return __awaiter$1(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$1(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$1(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$1(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$1(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$1(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$1(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 = {}));
+
+/**
+ * Minimum transaction fee
+ * 100000 satoshi/kB (similar to current `minrelaytxfee`)
+ * @see https://github.com/dogecoin/dogecoin/blob/master/src/validation.h#L58
+ */
+const MIN_TX_FEE = 100000;
+const DOGE_DECIMAL = 8;
+const LOWER_FEE_BOUND = 40000;
+const UPPER_FEE_BOUND = 20000000;
+/**
+ * Chain identifier for Dogecoin
+ *
+ */
+const DOGEChain = 'DOGE';
+/**
+ * Base "chain" asset on dogecoin
+ *
+ * Based on definition in Thorchain `common`
+ * @see https://gitlab.com/thorchain/thornode/-/blob/master/common/asset.go#L12-24
+ */
+const AssetDOGE = { chain: DOGEChain, symbol: 'DOGE', ticker: 'DOGE', synth: false };
+// https://blockchair.com/
+const DOGE_MAINNET_EXPLORER = new ExplorerProvider('https://blockchair.com/dogecoin', 'https://blockchair.com/dogecoin/address/%%ADDRESS%%', 'https://blockchair.com/dogecoin/transaction/%%TX_ID%%');
+const DOGE_TESTNET_EXPLORER = new ExplorerProvider('https://blockexplorer.one/dogecoin/testnet', 'https://blockexplorer.one/dogecoin/testnet/address/%%ADDRESS%%', 'https://blockexplorer.one/dogecoin/testnet/tx/%%TX_ID%%');
+const blockstreamExplorerProviders = {
+    [Network.Testnet]: DOGE_TESTNET_EXPLORER,
+    [Network.Stagenet]: DOGE_MAINNET_EXPLORER,
+    [Network.Mainnet]: DOGE_MAINNET_EXPLORER,
+};
+//======================
+// sochain
+//======================
+const testnetSochainProvider = new SochainProvider('https://sochain.com/api/v3', 'PLACEHOLDER_APIKEY', DOGEChain, AssetDOGE, 8, SochainNetwork.DOGETEST);
+const mainnetSochainProvider = new SochainProvider('https://sochain.com/api/v3', 'PLACEHOLDER_APIKEY', DOGEChain, AssetDOGE, 8, SochainNetwork.DOGE);
+const sochainDataProviders = {
+    [Network.Testnet]: testnetSochainProvider,
+    [Network.Stagenet]: mainnetSochainProvider,
+    [Network.Mainnet]: mainnetSochainProvider,
+};
+//======================
+// Blockcypher
+//======================
+const mainnetBlockcypherProvider = new BlockcypherProvider('https://api.blockcypher.com/v1', DOGEChain, AssetDOGE, 8, BlockcypherNetwork.DOGE);
+const blockcypherDataProviders = {
+    [Network.Testnet]: undefined,
+    [Network.Stagenet]: mainnetBlockcypherProvider,
+    [Network.Mainnet]: mainnetBlockcypherProvider,
+};
+
 /*
   info from:
     https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/chainparams.cpp