@xchainjs/xchain-thorchain-query 0.1.0-alpha

package/lib/index.js

@@ -0,0 +1,1735 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var xchainThornode = require('@xchainjs/xchain-thornode');
+var xchainUtil = require('@xchainjs/xchain-util');
+var BigNumber = require('bignumber.js');
+var xchainClient = require('@xchainjs/xchain-client');
+var xchainMidgard = require('@xchainjs/xchain-midgard');
+var axios = require('axios');
+var axiosRetry = require('axios-retry');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var axiosRetry__default = /*#__PURE__*/_interopDefaultLegacy(axiosRetry);
+
+/*! *****************************************************************************
+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());
+    });
+}
+
+const DefaultChainAttributes = {
+    BCH: {
+        blockReward: 6.25,
+        avgBlockTimeInSecs: 600,
+    },
+    BTC: {
+        blockReward: 6.25,
+        avgBlockTimeInSecs: 600,
+    },
+    ETH: {
+        blockReward: 2,
+        avgBlockTimeInSecs: 13,
+    },
+    AVAX: {
+        blockReward: 2,
+        avgBlockTimeInSecs: 3,
+    },
+    LTC: {
+        blockReward: 12.5,
+        avgBlockTimeInSecs: 150,
+    },
+    DOGE: {
+        blockReward: 10000,
+        avgBlockTimeInSecs: 60,
+    },
+    GAIA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
+    TERRA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 0,
+    },
+    BNB: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
+    THOR: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
+};
+
+/**
+ * Utility Class to combine an amount (asset/base) with the Asset
+ *
+ */
+class CryptoAmount {
+    constructor(amount, asset) {
+        this.asset = asset;
+        this.baseAmount = amount;
+    }
+    plus(v) {
+        this.check(v);
+        const baseAmountResult = this.baseAmount.plus(v.baseAmount);
+        return new CryptoAmount(baseAmountResult, this.asset);
+    }
+    minus(v) {
+        this.check(v);
+        const baseAmountResult = this.baseAmount.minus(v.baseAmount);
+        return new CryptoAmount(baseAmountResult, this.asset);
+    }
+    times(v) {
+        this.check(v);
+        if (v instanceof CryptoAmount) {
+            const baseAmountResult = this.baseAmount.times(v.baseAmount);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+        else {
+            const baseAmountResult = this.baseAmount.times(v);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+    }
+    div(v) {
+        this.check(v);
+        if (v instanceof CryptoAmount) {
+            const baseAmountResult = this.baseAmount.div(v.baseAmount);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+        else {
+            const baseAmountResult = this.baseAmount.div(v);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+    }
+    lt(v) {
+        this.check(v);
+        return this.baseAmount.lt(v.baseAmount);
+    }
+    lte(v) {
+        this.check(v);
+        return this.baseAmount.lte(v.baseAmount);
+    }
+    gt(v) {
+        this.check(v);
+        return this.baseAmount.gt(v.baseAmount);
+    }
+    gte(v) {
+        this.check(v);
+        return this.baseAmount.gte(v.baseAmount);
+    }
+    eq(v) {
+        this.check(v);
+        return this.baseAmount.eq(v.baseAmount);
+    }
+    formatedAssetString() {
+        return xchainUtil.formatAssetAmountCurrency({
+            amount: this.assetAmount,
+            asset: this.asset,
+            trimZeros: true,
+        });
+    }
+    assetAmountFixedString() {
+        return this.assetAmount.amount().toFixed();
+    }
+    get assetAmount() {
+        return xchainUtil.baseToAsset(this.baseAmount);
+    }
+    /**
+     * This guard protects against trying to perform math with different assets
+     *
+     * Example.
+     * const x = new CryptoAmount(baseAmount(1),AssetBTC)
+     * const y = new CryptoAmount(baseAmount(1),AssetETH)
+     *
+     * x.plus(y) <- will throw error "cannot perform math on 2 diff assets BTC.BTC ETH.ETH
+     *
+     * @param v - CryptoNumeric
+     */
+    check(v) {
+        if (v instanceof CryptoAmount) {
+            if (!xchainUtil.eqAsset(this.asset, v.asset)) {
+                throw Error(`cannot perform math on 2 diff assets ${xchainUtil.assetToString(this.asset)} ${xchainUtil.assetToString(v.asset)}`);
+            }
+        }
+    }
+}
+
+(function (TxStage) {
+    TxStage[TxStage["INBOUND_CHAIN_UNCONFIRMED"] = 0] = "INBOUND_CHAIN_UNCONFIRMED";
+    TxStage[TxStage["CONF_COUNTING"] = 1] = "CONF_COUNTING";
+    TxStage[TxStage["TC_PROCESSING"] = 2] = "TC_PROCESSING";
+    TxStage[TxStage["OUTBOUND_QUEUED"] = 3] = "OUTBOUND_QUEUED";
+    TxStage[TxStage["OUTBOUND_CHAIN_UNCONFIRMED"] = 4] = "OUTBOUND_CHAIN_UNCONFIRMED";
+    TxStage[TxStage["OUTBOUND_CHAIN_CONFIRMED"] = 5] = "OUTBOUND_CHAIN_CONFIRMED";
+})(exports.TxStage || (exports.TxStage = {}));
+
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns
+ */
+const getSwapFee = (inputAmount, pool, toRune) => {
+    // formula: (x * x * Y) / (x + X) ^ 2
+    // const isInputRune = isAssetRuneNative(inputAmount.asset)
+    const x = inputAmount.baseAmount.amount();
+    const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
+    const Y = toRune ? pool.runeBalance.amount() : pool.assetBalance.amount(); // output is rune if toRune
+    const units = toRune ? xchainUtil.AssetRuneNative : pool.asset;
+    const decimals = toRune || !pool.decimals ? 8 : pool.decimals;
+    const numerator = x.times(x).multipliedBy(Y);
+    const denominator = x.plus(X).pow(2);
+    const result = numerator.div(denominator);
+    const swapFee = new CryptoAmount(xchainUtil.baseAmount(result, decimals), units);
+    // console.log(` swapFee ${swapFee.assetAmountFixedString()} ${assetToString(units)}`)
+    return swapFee;
+};
+/**
+ * Works out the swap slip for a given swap.
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns The amount of slip. Needs to * 100 to get percentage.
+ */
+const getSwapSlip = (inputAmount, pool, toRune) => {
+    // formula: (x) / (x + X)
+    const x = inputAmount.baseAmount.amount();
+    const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
+    const result = x.div(x.plus(X));
+    return new BigNumber.BigNumber(result);
+};
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns The output amount
+ */
+const getSwapOutput = (inputAmount, pool, toRune) => {
+    // formula: (x * X * Y) / (x + X) ^ 2
+    const x = inputAmount.baseAmount.amount();
+    const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
+    const Y = toRune ? pool.runeBalance.amount() : pool.assetBalance.amount(); // output is rune if toRune
+    const units = toRune ? xchainUtil.AssetRuneNative : pool.asset;
+    const decimals = toRune || !pool.decimals ? 8 : pool.decimals;
+    const numerator = x.times(X).times(Y);
+    const denominator = x.plus(X).pow(2);
+    const result = numerator.div(denominator);
+    return new CryptoAmount(xchainUtil.baseAmount(result, decimals), units);
+};
+const getDoubleSwapOutput = (inputAmount, pool1, pool2) => {
+    // formula: getSwapOutput(pool1) => getSwapOutput(pool2)
+    const r = getSwapOutput(inputAmount, pool1, true);
+    const output = getSwapOutput(r, pool2, false);
+    return output;
+};
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @returns swap output object - output - fee - slip
+ */
+const getSingleSwap = (inputAmount, pool, toRune) => {
+    const output = getSwapOutput(inputAmount, pool, toRune);
+    const fee = getSwapFee(inputAmount, pool, toRune);
+    const slip = getSwapSlip(inputAmount, pool, toRune);
+    const swapOutput = {
+        output: output,
+        swapFee: fee,
+        slip: slip,
+    };
+    return swapOutput;
+};
+const getDoubleSwapSlip = (inputAmount, pool1, pool2) => {
+    // formula: getSwapSlip1(input1) + getSwapSlip2(getSwapOutput1 => input2)
+    const swapOutput1 = getSingleSwap(inputAmount, pool1, true);
+    const swapOutput2 = getSingleSwap(swapOutput1.output, pool2, false);
+    const result = swapOutput2.slip.plus(swapOutput1.slip);
+    return result;
+};
+const getDoubleSwapFee = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(void 0, void 0, void 0, function* () {
+    // formula: getSwapFee1 + getSwapFee2
+    const fee1InRune = getSwapFee(inputAmount, pool1, true);
+    const swapOutput = getSwapOutput(inputAmount, pool1, true);
+    const fee2InAsset = getSwapFee(swapOutput, pool2, false);
+    const fee2InRune = yield thorchainCache.convert(fee2InAsset, xchainUtil.AssetRuneNative);
+    const result = fee1InRune.plus(fee2InRune);
+    return result;
+});
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns swap output object - output - fee - slip
+ */
+const getDoubleSwap = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(void 0, void 0, void 0, function* () {
+    const doubleOutput = getDoubleSwapOutput(inputAmount, pool1, pool2);
+    const doubleFee = yield getDoubleSwapFee(inputAmount, pool1, pool2, thorchainCache);
+    const doubleSlip = getDoubleSwapSlip(inputAmount, pool1, pool2);
+    const SwapOutput = {
+        output: doubleOutput,
+        swapFee: doubleFee,
+        slip: doubleSlip,
+    };
+    return SwapOutput;
+});
+/**
+ * Works out the required inbound or outbound fee based on the chain.
+ * Call getInboundDetails to get the current gasRate
+ *
+ * @param sourceAsset
+ * @param gasRate
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+const calcNetworkFee = (asset, gasRate) => {
+    if (asset.synth)
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+    switch (asset.chain) {
+        case xchainUtil.Chain.Bitcoin:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(1000)), xchainUtil.AssetBTC);
+        case xchainUtil.Chain.BitcoinCash:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(1500)), xchainUtil.AssetBCH);
+        case xchainUtil.Chain.Litecoin:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetLTC);
+        case xchainUtil.Chain.Doge:
+            // NOTE: UTXO chains estimate fees with a 250 byte size
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(1000)), xchainUtil.AssetDOGE);
+        case xchainUtil.Chain.Binance:
+            //flat fee
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate), xchainUtil.AssetBNB);
+        case xchainUtil.Chain.Ethereum:
+            const gasRateinETHGwei = gasRate;
+            const gasRateinETHWei = xchainUtil.baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
+            if (xchainUtil.eqAsset(asset, xchainUtil.AssetETH)) {
+                return new CryptoAmount(gasRateinETHWei.times(21000), xchainUtil.AssetETH);
+            }
+            else {
+                return new CryptoAmount(gasRateinETHWei.times(70000), xchainUtil.AssetETH);
+            }
+        case xchainUtil.Chain.Avalanche:
+            const gasRateinAVAXGwei = gasRate;
+            const gasRateinAVAXWei = xchainUtil.baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
+            if (xchainUtil.eqAsset(asset, xchainUtil.AssetAVAX)) {
+                return new CryptoAmount(gasRateinAVAXWei.times(21000), xchainUtil.AssetETH);
+            }
+            else {
+                return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainUtil.AssetETH);
+            }
+        case xchainUtil.Chain.Terra:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate), xchainUtil.AssetLUNA);
+        case xchainUtil.Chain.Cosmos:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate), xchainUtil.AssetAtom);
+        case xchainUtil.Chain.THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+    }
+    throw new Error(`could not calculate inbound fee for ${asset.chain}`);
+};
+/**
+ * Return the chain for a given Asset This method should live somewhere else.
+ * @param chain
+ * @returns the gas asset type for the given chain
+ */
+const getChainAsset = (chain) => {
+    switch (chain) {
+        case xchainUtil.BNBChain:
+            return xchainUtil.AssetBNB;
+        case xchainUtil.BTCChain:
+            return xchainUtil.AssetBTC;
+        case xchainUtil.ETHChain:
+            return xchainUtil.AssetETH;
+        case xchainUtil.THORChain:
+            return xchainUtil.AssetRuneNative;
+        case xchainUtil.CosmosChain:
+            return xchainUtil.AssetAtom;
+        case xchainUtil.BCHChain:
+            return xchainUtil.AssetBCH;
+        case xchainUtil.LTCChain:
+            return xchainUtil.AssetLTC;
+        case xchainUtil.DOGEChain:
+            return xchainUtil.AssetDOGE;
+        case xchainUtil.TerraChain:
+            return xchainUtil.AssetLUNA;
+        case xchainUtil.AvalancheChain:
+            return xchainUtil.AssetAVAX;
+        default:
+            throw Error('Unknown chain');
+    }
+};
+/**
+ *
+ * @param chain - input chain string
+ * @returns - returns correct chain from string
+ */
+const getChain = (chain) => {
+    switch (chain) {
+        case 'BNB':
+            return xchainUtil.BNBChain;
+        case 'BTC':
+            return xchainUtil.BTCChain;
+        case 'ETH':
+            return xchainUtil.ETHChain;
+        case 'THOR':
+            return xchainUtil.THORChain;
+        case 'GAIA':
+            return xchainUtil.CosmosChain;
+        case 'BCH':
+            return xchainUtil.BCHChain;
+        case 'LTC':
+            return xchainUtil.LTCChain;
+        case 'DOGE':
+            return xchainUtil.DOGEChain;
+        case 'TERRA':
+            return xchainUtil.TerraChain;
+        default:
+            throw Error('Unknown chain');
+    }
+};
+
+// import { Network } from '@xchainjs/xchain-client'
+const BN_1 = new BigNumber.BigNumber(1);
+/**
+ * THORChain Class for interacting with THORChain.
+ * Recommended main class to use for swapping with THORChain
+ * Has access to Midgard and THORNode data
+ */
+class ThorchainQuery {
+    /**
+     * Contructor to create a ThorchainAMM
+     *
+     * @param thorchainCache - an instance of the ThorchainCache (could be pointing to stagenet,testnet,mainnet)
+     * @param chainAttributes - atrributes used to calculate waitTime & conf counting
+     * @returns ThorchainAMM
+     */
+    constructor(thorchainCache, chainAttributes = DefaultChainAttributes) {
+        this.thorchainCache = thorchainCache;
+        this.chainAttributes = chainAttributes;
+    }
+    /**
+     * Provides a swap estimate for the given swap detail. Will check the params for errors before trying to get the estimate.
+     * Uses current pool data, works out inbound and outboud fee, affiliate fees and works out the expected wait time for the swap (in and out)
+     *
+     * @param params - amount to swap
+  
+     * @returns The SwapEstimate
+     */
+    estimateSwap(params, destinationAddress = '', affiliateAddress = '', interfaceID = 999) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isValidSwap(params);
+            const inboundDetails = yield this.thorchainCache.getInboundDetails();
+            const sourceInboundDetails = inboundDetails[params.input.asset.chain];
+            // console.log(JSON.stringify(sourceInboundDetails, null, 2))
+            const destinationInboundDetails = inboundDetails[params.destinationAsset.chain];
+            // console.log(JSON.stringify(destinationInboundDetails, null, 2))
+            const swapEstimate = yield this.calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails);
+            // Remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
+            const affiliateFee = params.input.baseAmount.times(params.affiliateFeePercent || 0);
+            // Calculate expiry time
+            const currentDatetime = new Date();
+            const minutesToAdd = 15;
+            const expiryDatetime = new Date(currentDatetime.getTime() + minutesToAdd * 60000);
+            // Check for errors
+            const errors = yield this.getSwapEstimateErrors(params, swapEstimate, sourceInboundDetails, destinationInboundDetails);
+            const txDetails = {
+                memo: '',
+                toAddress: '',
+                expiry: expiryDatetime,
+                txEstimate: swapEstimate,
+            };
+            if (errors.length > 0) {
+                txDetails.txEstimate.canSwap = false;
+                txDetails.txEstimate.errors = errors;
+            }
+            else {
+                txDetails.txEstimate.canSwap = true;
+                // Retrieve inbound Asgard address.
+                const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.input.asset.chain];
+                txDetails.toAddress = (inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address) || '';
+                // Work out LIM from the slip percentage
+                let limPercentage = BN_1;
+                if (params.slipLimit) {
+                    limPercentage = BN_1.minus(params.slipLimit || 1);
+                } // else allowed slip is 100%
+                const limAssetAmount = swapEstimate.netOutput.times(limPercentage);
+                const inboundDelay = yield this.confCounting(params.input);
+                const outboundDelay = yield this.outboundDelay(limAssetAmount);
+                txDetails.txEstimate.waitTimeSeconds = outboundDelay + inboundDelay;
+                // Construct memo
+                txDetails.memo = this.constructSwapMemo({
+                    input: params.input,
+                    destinationAsset: params.destinationAsset,
+                    limit: limAssetAmount.baseAmount,
+                    destinationAddress,
+                    affiliateAddress,
+                    affiliateFee,
+                    interfaceID,
+                });
+            }
+            return txDetails;
+        });
+    }
+    /**
+     * Basic Checks for swap information
+     * @param params
+     */
+    isValidSwap(params) {
+        // TODO validate all input fields
+        if (xchainUtil.eqAsset(params.input.asset, params.destinationAsset))
+            throw Error(`sourceAsset and destinationAsset cannot be the same`);
+        if (params.input.baseAmount.lte(0))
+            throw Error('inputAmount must be greater than 0');
+        if (params.affiliateFeePercent && (params.affiliateFeePercent < 0 || params.affiliateFeePercent > 0.1))
+            throw Error(`affiliateFee must be between 0 and 1000`);
+    }
+    /**
+     * Does the calculations for the swap.
+     * Used by estimateSwap
+     *
+     * @param params
+     * @param sourceInboundDetails
+     * @param destinationInboundDetails
+     * @param sourcePool
+     * @param destinationPool
+     * @returns
+     */
+    calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //NOTE need to convert the asset to 8 decimals places for all calcs
+            const input = yield this.thorchainCache.convert(params.input, params.input.asset);
+            const inputInRune = yield this.thorchainCache.convert(input, xchainUtil.AssetRuneNative);
+            const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails.gas_rate);
+            let outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails.gas_rate);
+            outboundFeeInAsset = outboundFeeInAsset.times(3);
+            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, xchainUtil.AssetRuneNative);
+            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, xchainUtil.AssetRuneNative);
+            // ---------- Remove Fees from inbound before doing the swap -----------
+            // TODO confirm with chris about this change
+            // const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune)
+            const inputMinusInboundFeeInRune = inputInRune;
+            // remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
+            const affiliateFeeInRune = inputMinusInboundFeeInRune.times(params.affiliateFeePercent || 0);
+            // remove the affiliate fee from the input.
+            const inputNetAmountInRune = inputMinusInboundFeeInRune.minus(affiliateFeeInRune);
+            // convert back to input asset
+            const inputNetInAsset = yield this.thorchainCache.convert(inputNetAmountInRune, input.asset);
+            // Check outbound fee is equal too or greater than 1 USD * need to find a more permanent solution to this. referencing just 1 stable coin pool has problems
+            if (params.destinationAsset.chain !== xchainUtil.Chain.THORChain && !params.destinationAsset.synth) {
+                const deepestUSDPOOL = yield this.thorchainCache.getDeepestUSDPool();
+                const usdAsset = deepestUSDPOOL.asset;
+                const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
+                const usdMinFee = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINIMUML1OUTBOUNDFEEUSD']), usdAsset);
+                // const FeeInUSD = await this.convert(outboundFeeInRune, usdAsset)
+                const checkOutboundFee = (yield this.convert(outboundFeeInRune, usdAsset)).gte(usdMinFee);
+                if (!checkOutboundFee) {
+                    const newFee = usdMinFee;
+                    outboundFeeInRune = yield this.convert(newFee, xchainUtil.AssetRuneNative);
+                }
+            }
+            // Now calculate swapfee based on inputNetAmount
+            const swapOutput = yield this.thorchainCache.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
+            const swapFeeInRune = yield this.thorchainCache.convert(swapOutput.swapFee, xchainUtil.AssetRuneNative);
+            const outputInRune = yield this.thorchainCache.convert(swapOutput.output, xchainUtil.AssetRuneNative);
+            // ---------------- Remove Outbound Fee ---------------------- /
+            const netOutputInRune = outputInRune.minus(outboundFeeInRune);
+            const netOutputInAsset = yield this.thorchainCache.convert(netOutputInRune, params.destinationAsset);
+            const totalFees = {
+                inboundFee: inboundFeeInRune,
+                swapFee: swapFeeInRune,
+                outboundFee: outboundFeeInRune,
+                affiliateFee: affiliateFeeInRune,
+            };
+            const swapEstimate = {
+                totalFees: totalFees,
+                slipPercentage: swapOutput.slip,
+                netOutput: netOutputInAsset,
+                waitTimeSeconds: 0,
+                canSwap: false,
+                errors: [],
+            };
+            return swapEstimate;
+        });
+    }
+    /**
+     *
+     * @param params - swap object
+     * @returns - constructed memo string
+     */
+    constructSwapMemo(params) {
+        const limstring = params.limit.amount().toFixed();
+        // create LIM with interface ID
+        const lim = limstring.substring(0, limstring.length - 3).concat(params.interfaceID.toString());
+        // create the full memo
+        let memo = `=:${xchainUtil.assetToString(params.destinationAsset)}`;
+        if (params.affiliateAddress != '' || params.affiliateFee == undefined) {
+            memo = memo.concat(`:${params.destinationAddress}:${lim}:${params.affiliateAddress}:${params.affiliateFee.amount().toFixed()}`);
+        }
+        else {
+            memo = memo.concat(`:${params.destinationAddress}:${lim}`);
+        }
+        // If memo length is too long for BTC, trim it
+        if (xchainUtil.eqAsset(params.input.asset, xchainUtil.AssetBTC) && memo.length > 80) {
+            memo = `=:${xchainUtil.assetToString(params.destinationAsset)}:${params.destinationAddress}`;
+        }
+        return memo;
+    }
+    /**
+     * Looks for errors or issues within swap prams before doing the swap.
+     *
+     *
+     * @param params
+     * @param estimate
+     * @param sourcePool
+     * @param sourceInboundDetails
+     * @param destinationPool
+     * @param destinationInboundDetails
+     * @returns
+     */
+    getSwapEstimateErrors(params, estimate, sourceInboundDetails, destinationInboundDetails) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            const sourceAsset = params.input.asset;
+            const destAsset = params.destinationAsset;
+            if (!xchainUtil.isAssetRuneNative(sourceAsset)) {
+                const sourcePool = yield this.thorchainCache.getPoolForAsset(sourceAsset);
+                if (!sourcePool.isAvailable())
+                    errors.push(`sourceAsset ${sourceAsset.ticker} does not have a valid liquidity pool`);
+            }
+            if (!xchainUtil.isAssetRuneNative(destAsset)) {
+                const destPool = yield this.thorchainCache.getPoolForAsset(destAsset);
+                if (!destPool.isAvailable())
+                    errors.push(`destinationAsset ${destAsset.ticker} does not have a valid liquidity pool`);
+            }
+            if (sourceInboundDetails.haltedChain)
+                errors.push(`source chain is halted`);
+            if (sourceInboundDetails.haltedTrading)
+                errors.push(`source pool is halted trading`);
+            if (destinationInboundDetails.haltedChain)
+                errors.push(`destination chain is halted`);
+            if (destinationInboundDetails.haltedTrading)
+                errors.push(`destination pool is halted trading`);
+            if (estimate.slipPercentage.gte(params.slipLimit || 1))
+                errors.push(`expected slip: ${estimate.slipPercentage.toFixed()} is greater than your slip limit:${(_a = params.slipLimit) === null || _a === void 0 ? void 0 : _a.toFixed()} `);
+            // only proceed to check fees if there are no errors so far
+            if (errors.length > 0)
+                return errors;
+            // Check if the inputAmount value is enough to cover all the fees.
+            const canCoverFeesError = yield this.checkCoverFees(params, estimate);
+            if (canCoverFeesError)
+                errors.push(canCoverFeesError);
+            return errors;
+        });
+    }
+    /**
+     *
+     * @param params
+     * @param estimate
+     * @returns
+     */
+    checkCoverFees(params, estimate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = undefined;
+            const inputInRune = yield this.thorchainCache.convert(params.input, xchainUtil.AssetRuneNative);
+            const feesInRune = yield this.getFeesIn(estimate.totalFees, xchainUtil.AssetRuneNative);
+            const totalSwapFeesInRune = feesInRune.inboundFee
+                .plus(feesInRune.outboundFee)
+                .plus(feesInRune.swapFee)
+                .plus(feesInRune.affiliateFee);
+            const totalSwapFeesInAsset = yield this.thorchainCache.convert(totalSwapFeesInRune, params.input.asset);
+            if (totalSwapFeesInRune.gte(inputInRune))
+                result = `Input amount ${params.input.formatedAssetString()}(${inputInRune.formatedAssetString()}) is less than or equal to total swap fees ${totalSwapFeesInAsset.formatedAssetString()}(${totalSwapFeesInRune.formatedAssetString()}) `;
+            return result;
+        });
+    }
+    /**
+     * Convenience method to convert TotalFees to a different CryptoAmount
+     *
+     * TotalFees are always calculated and returned in RUNE, this method can
+     * be used to show the equivalent fees in another Asset Type
+     *
+     * @param fees: TotalFees - the fees you want to convert
+     * @param asset: Asset - the asset you want the fees converted to
+     * @returns TotalFees in asset
+     */
+    getFeesIn(fees, asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                inboundFee: yield this.convert(fees.inboundFee, asset),
+                swapFee: yield this.convert(fees.swapFee, asset),
+                outboundFee: yield this.convert(fees.outboundFee, asset),
+                affiliateFee: yield this.convert(fees.affiliateFee, asset),
+            };
+        });
+    }
+    /**
+     * Returns the exchange of a CryptoAmount to a different Asset
+     *
+     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
+     *
+     * @param input - amount/asset to convert to outAsset
+     * @param ouAsset - the Asset you want to convert to
+     * @returns CryptoAmount of input
+     */
+    convert(input, outAsset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.thorchainCache.convert(input, outAsset);
+        });
+    }
+    /**
+     * Finds the required confCount required for an inbound or outbound Tx to THORChain. Estimate based on Midgard data only.
+     *
+     * Finds the gas asset of the given asset (e.g. BUSD is on BNB), finds the value of asset in Gas Asset then finds the required confirmation count.
+     * ConfCount is then times by 6 seconds.
+     *
+     * @param inbound: CryptoAmount - amount/asset of the outbound amount.
+     * @returns time in seconds before a Tx is confirmed by THORChain
+     * @see https://docs.thorchain.org/chain-clients/overview
+     */
+    confCounting(inbound) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // RUNE, BNB and Synths have near instant finality, so no conf counting required. - need to make a BFT only case.
+            if (xchainUtil.isAssetRuneNative(inbound.asset) ||
+                inbound.asset.chain == xchainUtil.AssetBNB.chain ||
+                inbound.asset.chain == xchainUtil.AssetAtom.chain ||
+                inbound.asset.synth) {
+                return this.chainAttributes[xchainUtil.Chain.THORChain].avgBlockTimeInSecs;
+            }
+            // Get the gas asset for the inbound.asset.chain
+            const chainGasAsset = getChainAsset(inbound.asset.chain);
+            // check for chain asset, else need to convert asset value to chain asset.
+            const amountInGasAsset = yield this.thorchainCache.convert(inbound, chainGasAsset);
+            // Convert to Asset Amount
+            const amountInGasAssetInAsset = amountInGasAsset.assetAmount;
+            const confConfig = this.chainAttributes[inbound.asset.chain];
+            // find the required confs
+            const requiredConfs = Math.ceil(amountInGasAssetInAsset.amount().div(confConfig.blockReward).toNumber());
+            // convert that into seconds
+            return requiredConfs * confConfig.avgBlockTimeInSecs;
+        });
+    }
+    /**
+     * Works out how long an outbound Tx will be held by THORChain before sending.
+     *
+     * @param outboundAmount: CryptoAmount  being sent.
+     * @returns required delay in seconds
+     * @see https://gitlab.com/thorchain/thornode/-/blob/develop/x/thorchain/manager_txout_current.go#L548
+     */
+    outboundDelay(outboundAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const networkValues = yield this.thorchainCache.getNetworkValues();
+            const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), xchainUtil.AssetRuneNative);
+            const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
+            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainUtil.AssetRuneNative);
+            const getScheduledOutboundValue = yield this.thorchainCache.midgard.getScheduledOutboundValue();
+            const thorChainblocktime = this.chainAttributes[xchainUtil.Chain.THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
+            // If asset is equal to Rune set runeValue as outbound amount else set it to the asset's value in rune
+            const runeValue = yield this.thorchainCache.convert(outboundAmount, xchainUtil.AssetRuneNative);
+            // Check rune value amount
+            if (runeValue.lt(minTxOutVolumeThreshold)) {
+                return thorChainblocktime;
+            }
+            // Rune value in the outbound queue
+            if (getScheduledOutboundValue == undefined) {
+                throw new Error(`Could not return Scheduled Outbound Value`);
+            }
+            // Add OutboundAmount in rune to the oubound queue
+            const outboundAmountTotal = runeValue.plus(getScheduledOutboundValue);
+            // calculate the if outboundAmountTotal is over the volume threshold
+            const volumeThreshold = outboundAmountTotal.div(minTxOutVolumeThreshold);
+            // check delay rate
+            txOutDelayRate = txOutDelayRate.minus(volumeThreshold).baseAmount.amount().lt(1)
+                ? new CryptoAmount(xchainUtil.baseAmount(1), xchainUtil.AssetRuneNative)
+                : txOutDelayRate;
+            // calculate the minimum number of blocks in the future the txn has to be
+            let minBlocks = runeValue.div(txOutDelayRate).baseAmount.amount().toNumber();
+            minBlocks = minBlocks > maxTxOutOffset ? maxTxOutOffset : minBlocks;
+            return minBlocks * thorChainblocktime;
+        });
+    }
+    /**
+     * For a given in Tx Hash (as returned by THORChainAMM.DoSwap()), finds the status of any THORChain transaction
+     * This function should be polled.
+     * @param
+     * @param inboundTxHash - needed to determine transactions stage
+     * @param sourceChain - extra parameter
+     * @returns - object tx status
+     */
+    checkTx(inboundTxHash, sourceChain) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            let txStatus = { stage: exports.TxStage.INBOUND_CHAIN_UNCONFIRMED, seconds: 0 };
+            const txData = yield this.thorchainCache.thornode.getTxData(inboundTxHash);
+            const scheduledQueueItem = (yield this.thorchainCache.thornode.getscheduledQueue()).find((item) => item.in_hash === inboundTxHash);
+            //console.log(`Tx stage ${txStatus.stage}\nTx seconds left ${txStatus.seconds}`)
+            // Check to see if the transaction has been observed
+            if (txData.observed_tx == undefined) {
+                txStatus = yield this.checkTxDefined(txStatus, sourceChain);
+                return txStatus;
+            }
+            // If its scheduled and observed
+            if (scheduledQueueItem && txData.observed_tx) {
+                txStatus = yield this.checkObservedOnly(txStatus, scheduledQueueItem, txData.observed_tx, sourceChain);
+            }
+            //console.log(`Tx stage ${txStatus.stage}\nTx seconds left ${txStatus.seconds}`)
+            // Retrieve asset and chain from memo
+            const pool = (_a = txData.observed_tx.tx.memo) === null || _a === void 0 ? void 0 : _a.split(`:`);
+            if (!pool)
+                throw Error(`No pool found from memo`);
+            const getAsset = xchainUtil.assetFromString(pool[1].toUpperCase());
+            // Retrieve thorchain blockHeight for the tx
+            if (!((_b = txData.observed_tx.tx) === null || _b === void 0 ? void 0 : _b.id))
+                throw Error('No action observed');
+            const recordedAction = yield this.thorchainCache.midgard.getActions(txData.observed_tx.tx.id);
+            const recordedTCBlock = recordedAction.find((block) => {
+                return block;
+            });
+            if (!(recordedTCBlock === null || recordedTCBlock === void 0 ? void 0 : recordedTCBlock.height))
+                throw Error('No recorded block height');
+            // Retrieve thorchains last observed block height
+            const lastBlock = yield this.thorchainCache.thornode.getLastBlock();
+            const lastBlockHeight = lastBlock.find((obj) => obj.chain === (getAsset === null || getAsset === void 0 ? void 0 : getAsset.chain));
+            // Check to see if its in the outbound queue
+            if (scheduledQueueItem) {
+                txStatus = yield this.checkOutboundQueue(txStatus, scheduledQueueItem, lastBlockHeight);
+                // Check to see if there is an outbound wait
+                if ((scheduledQueueItem === null || scheduledQueueItem === void 0 ? void 0 : scheduledQueueItem.height) != undefined && txStatus.stage < exports.TxStage.OUTBOUND_CHAIN_CONFIRMED) {
+                    txStatus = yield this.checkOutboundTx(txStatus, scheduledQueueItem, lastBlockHeight);
+                }
+                //console.log(`Tx stage ${txStatus.stage}\nTx seconds left ${txStatus.seconds}`)
+                return txStatus;
+            }
+            // If not in queue, outbound Tx sent // check synth // check it status == done
+            if (!scheduledQueueItem && getAsset) {
+                txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_UNCONFIRMED;
+                if (getAsset === null || getAsset === void 0 ? void 0 : getAsset.synth) {
+                    if (((_c = txData.observed_tx) === null || _c === void 0 ? void 0 : _c.status) == xchainThornode.ObservedTxStatusEnum.Done) {
+                        txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_CONFIRMED;
+                        txStatus.seconds = 0;
+                    }
+                    else {
+                        txStatus.seconds = 6;
+                    }
+                    //console.log(`Tx stage ${txStatus.stage}\nTx seconds left ${txStatus.seconds}`)
+                    return txStatus;
+                }
+                if (((_d = txData.observed_tx) === null || _d === void 0 ? void 0 : _d.status) == xchainThornode.ObservedTxStatusEnum.Done && getAsset.chain != xchainUtil.Chain.THORChain) {
+                    // Retrieve recorded asset block height for the Outbound asset
+                    const recordedBlockHeight = yield this.thorchainCache.thornode.getLastBlock(+recordedTCBlock.height);
+                    // Match outbound asset to block record
+                    const assetBlockHeight = recordedBlockHeight.find((obj) => obj.chain === (getAsset === null || getAsset === void 0 ? void 0 : getAsset.chain));
+                    if ((lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.last_observed_in) && (assetBlockHeight === null || assetBlockHeight === void 0 ? void 0 : assetBlockHeight.last_observed_in)) {
+                        const chainblockTime = this.chainAttributes[getAsset.chain].avgBlockTimeInSecs;
+                        // Difference between current block and the recorded tx block for the outbound asset
+                        const blockDifference = lastBlockHeight.last_observed_in - assetBlockHeight.last_observed_in;
+                        const timeElapsed = blockDifference * chainblockTime;
+                        // If the time elapsed since the tx is greater than the chains block time, assume tx has 1 ocnfirmation else return time left to wait
+                        txStatus.seconds = timeElapsed > chainblockTime ? 0 : chainblockTime - timeElapsed;
+                        console.log(timeElapsed);
+                    }
+                    else if (txData.observed_tx.tx.id && (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) {
+                        const recordedAction = yield this.thorchainCache.midgard.getActions(txData.observed_tx.tx.id);
+                        const recordedBlockheight = recordedAction.find((block) => {
+                            return block;
+                        });
+                        if (!recordedBlockheight)
+                            throw Error(`No height recorded`);
+                        const chainblockTime = this.chainAttributes[getAsset.chain].avgBlockTimeInSecs;
+                        console.log(chainblockTime);
+                        const blockDifference = (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain) - +recordedBlockheight.height;
+                        console.log(blockDifference);
+                        const timeElapsed = (blockDifference * chainblockTime) / this.chainAttributes[getAsset.chain].avgBlockTimeInSecs;
+                        txStatus.seconds = timeElapsed > chainblockTime ? 0 : chainblockTime - timeElapsed;
+                        console.log(txStatus.seconds);
+                        txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_CONFIRMED;
+                    }
+                    //console.log(`Tx stage ${txStatus.stage}\nTx seconds left ${txStatus.seconds}`)
+                    return txStatus;
+                }
+                else {
+                    txStatus.seconds = 0;
+                    txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_CONFIRMED;
+                }
+                //console.log(`Tx stage ${txStatus.stage}\nTx seconds left ${txStatus.seconds}`)
+                return txStatus;
+            }
+            else {
+                // case example "memo": "OUT:08BC062B248F6F27D0FECEF1650843585A1496BFFEAF7CB17A1CBC30D8D58F9C" where no asset is found its a thorchain tx. Confirms in ~6 seconds
+                txStatus.seconds = 0;
+                txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_CONFIRMED;
+            }
+            return txStatus;
+        });
+    }
+    /** Stage 1  */
+    checkTxDefined(txStatus, sourceChain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If there is an error Thornode does not know about it. wait 60 seconds
+            // If a long block time like BTC, can check or poll to see if the status changes.
+            if (sourceChain) {
+                txStatus.seconds = this.chainAttributes[sourceChain].avgBlockTimeInSecs;
+            }
+            else {
+                txStatus.seconds = 60;
+            }
+            return txStatus;
+        });
+    }
+    /** Stage 2, THORNode has seen it. See if observed only (conf counting) or it has been processed by THORChain  */
+    // e.g. https://thornode.ninerealms.com/thorchain/tx/365AC447BE6CE4A55D14143975EE3823A93A0D8DE2B70AECDD63B6A905C3D72B
+    checkObservedOnly(txStatus, scheduledQueueItem, observed_tx, sourceChain) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.tx) === null || _a === void 0 ? void 0 : _a.chain) != undefined) {
+                sourceChain = getChain(observed_tx.tx.chain);
+            }
+            else {
+                throw new Error(`Cannot get source chain ${(_b = observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.tx) === null || _b === void 0 ? void 0 : _b.chain}`);
+            }
+            //If observed by not final, need to wait till the finalised block before moving to the next stage, blocks in source chain
+            if ((observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.block_height) && (observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.finalise_height) && scheduledQueueItem.height) {
+                if (observed_tx.block_height < observed_tx.finalise_height) {
+                    txStatus.stage = exports.TxStage.CONF_COUNTING;
+                    const blocksToWait = observed_tx.finalise_height - scheduledQueueItem.height;
+                    txStatus.seconds = blocksToWait * this.chainAttributes[sourceChain].avgBlockTimeInSecs;
+                }
+                else if (observed_tx.status != xchainThornode.ObservedTxStatusEnum.Done) {
+                    // processed but not yet full final, e.g. not 2/3 nodes signed
+                    txStatus.seconds = this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs; // wait one more TC block
+                    txStatus.stage = exports.TxStage.TC_PROCESSING;
+                }
+            }
+            return txStatus;
+        });
+    }
+    /**
+     * Stage 3
+     * @param txStatus
+     * @param txData
+     * @param scheduledQueue
+     * @param scheduledQueueItem
+     * @param lastBlockHeight
+     * @returns
+     */
+    checkOutboundQueue(txStatus, scheduledQueueItem, lastBlockHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If the scheduled block is greater than the current block, need to wait that amount of blocks till outbound is sent
+            if ((scheduledQueueItem === null || scheduledQueueItem === void 0 ? void 0 : scheduledQueueItem.height) && (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) {
+                if (lastBlockHeight.thorchain < (scheduledQueueItem === null || scheduledQueueItem === void 0 ? void 0 : scheduledQueueItem.height)) {
+                    const blocksToWait = scheduledQueueItem.height - lastBlockHeight.thorchain;
+                    txStatus.stage = exports.TxStage.OUTBOUND_QUEUED;
+                    txStatus.seconds = blocksToWait * this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs;
+                    return txStatus;
+                }
+                else {
+                    txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_UNCONFIRMED;
+                    return txStatus;
+                }
+            }
+            return txStatus;
+        });
+    }
+    /** Stage 4 */
+    checkOutboundTx(txStatus, scheduledQueueItem, lastBlockHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((scheduledQueueItem === null || scheduledQueueItem === void 0 ? void 0 : scheduledQueueItem.height) && (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) {
+                const blockDifference = scheduledQueueItem.height - (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain);
+                const timeElapsed = blockDifference * this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs;
+                if (blockDifference == 0) {
+                    // If Tx has just been sent, Stage 3 should pick this up really
+                    txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_UNCONFIRMED;
+                    txStatus.seconds = this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs;
+                }
+                else if (timeElapsed < txStatus.seconds) {
+                    // if the time passed since the outbound TX was sent is less than the outbound block time, outbound Tx unconfirmed, wait a bit longer.
+                    txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_UNCONFIRMED;
+                    txStatus.seconds = this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs - timeElapsed; // workout how long to wait
+                }
+                else {
+                    // time passed is greater than outbound Tx time, Tx is confirmed. Thus stage 5
+                    txStatus.stage = exports.TxStage.OUTBOUND_CHAIN_CONFIRMED;
+                    txStatus.seconds = 0;
+                }
+            }
+            return txStatus;
+        });
+    }
+}
+
+/**
+ * Represent a Liquidity Pool in Thorchain
+ */
+class LiquidityPool {
+    constructor(pool, decimals) {
+        this.pool = pool;
+        const asset = xchainUtil.assetFromString(this.pool.asset);
+        if (!asset)
+            throw new Error(`could not parse ${this.pool.asset}`);
+        this.asset = asset;
+        this.decimals = decimals;
+        this.assetString = this.pool.asset;
+        this.assetBalance = xchainUtil.baseAmount(this.pool.assetDepth);
+        this.runeBalance = xchainUtil.baseAmount(this.pool.runeDepth);
+        this.runeToAssetRatio = this.runeBalance.amount().div(this.assetBalance.amount());
+        this.assetToRuneRatio = this.assetBalance.amount().div(this.runeBalance.amount());
+    }
+    isAvailable() {
+        return this.pool.status.toLowerCase() === 'available';
+    }
+}
+
+const SAME_ASSET_EXCHANGE_RATE = new BigNumber.BigNumber(1);
+const TEN_MINUTES = 10 * 60 * 1000;
+const DEFAULT_THORCHAIN_DECIMALS = 8;
+const USD_ASSETS = {
+    mainnet: [
+        xchainUtil.assetFromString('BNB.BUSD-BD1'),
+        xchainUtil.assetFromString('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48'),
+        xchainUtil.assetFromString('ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7'),
+    ],
+    stagenet: [xchainUtil.assetFromString('ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7')],
+    testnet: [xchainUtil.assetFromString('BNB.BUSD-74E'), xchainUtil.assetFromString('ETH.USDT-0XA3910454BF2CB59B8B3A401589A3BACC5CA42306')],
+};
+/**
+ * This class manages retrieving information from up to date Thorchain
+ */
+class ThorchainCache {
+    /**
+     * Contrustor to create a ThorchainCache
+     *
+     * @param midgard - an instance of the midgard API (could be pointing to stagenet,testnet,mainnet)
+     * @param expirePoolCacheMillis - how long should the pools be cached before expiry
+     * @param expireAsgardCacheMillis - how long should the inboundAsgard Addresses be cached before expiry
+     * @param expireInboundDetailsCacheMillis - how long should the InboundDetails be cached before expiry
+     * @param expireNetworkValuesCacheMillis - how long should the Mimir/Constants be cached before expiry
+     * @returns ThorchainCache
+     */
+    constructor(midgard, thornode, expirePoolCacheMillis = 6000, expireAsgardCacheMillis = TEN_MINUTES, expireInboundDetailsCacheMillis = 6000, expireNetworkValuesCacheMillis = TEN_MINUTES) {
+        this.asgardAssetsCache = undefined;
+        this.inboundDetailCache = undefined;
+        this.networkValuesCache = undefined;
+        this.midgard = midgard;
+        this.thornode = thornode;
+        this.expirePoolCacheMillis = expirePoolCacheMillis;
+        this.expireAsgardCacheMillis = expireAsgardCacheMillis;
+        this.expireInboundDetailsCacheMillis = expireInboundDetailsCacheMillis;
+        this.expireNetworkValuesCacheMillis = expireNetworkValuesCacheMillis;
+        //initialize the cache
+        this.refereshPoolCache();
+    }
+    /**
+     * Gets the exchange rate of the from asset in terms on the to asset
+     *
+     * @param asset - cannot be RUNE.
+     * @returns Promise<BigNumber>
+     */
+    getExchangeRate(from, to) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let exchangeRate;
+            if (xchainUtil.eqAsset(from, to)) {
+                exchangeRate = SAME_ASSET_EXCHANGE_RATE;
+            }
+            else if (xchainUtil.isAssetRuneNative(from)) {
+                //  Runes per Asset
+                const lpTo = yield this.getPoolForAsset(to);
+                exchangeRate = lpTo.assetToRuneRatio;
+            }
+            else if (xchainUtil.isAssetRuneNative(to)) {
+                //  Asset per rune
+                const lpFrom = yield this.getPoolForAsset(from);
+                exchangeRate = lpFrom.runeToAssetRatio;
+            }
+            else {
+                //  AssetA per AssetB
+                const lpFrom = yield this.getPoolForAsset(from);
+                const lpTo = yield this.getPoolForAsset(to);
+                // from/R * R/to = from/to
+                exchangeRate = lpFrom.runeToAssetRatio.times(lpTo.assetToRuneRatio);
+            }
+            // console.log(` 1 ${assetToString(from)} = ${exchangeRate} ${assetToString(to)}`)
+            return exchangeRate;
+        });
+    }
+    /**
+     * Gets the Liquidity Pool for a given Asset
+     *
+     * @param asset - cannot be RUNE, since Rune is the other side of each pool.
+     * @returns Promise<LiquidityPool>
+     */
+    getPoolForAsset(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (xchainUtil.isAssetRuneNative(asset))
+                throw Error(`AssetRuneNative doesn't have a pool`);
+            const pools = yield this.getPools();
+            // Not: we use ticker, not asset string to get the same pool for both assets and synths
+            const pool = pools[asset.ticker];
+            if (pool) {
+                return pool;
+            }
+            throw Error(`Pool for ${xchainUtil.assetToString(asset)} not found`);
+        });
+    }
+    /**
+     * Get all the Liquidity Pools currently cached.
+     * if the cache is expired, the pools wioll be re-fetched from midgard
+     *
+     * @returns Promise<Record<string, LiquidityPool>>
+     */
+    getPools() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const millisSinceLastRefeshed = Date.now() - (((_a = this.poolCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
+            if (millisSinceLastRefeshed > this.expirePoolCacheMillis) {
+                try {
+                    yield this.refereshPoolCache();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            if (this.poolCache) {
+                return (_b = this.poolCache) === null || _b === void 0 ? void 0 : _b.pools;
+            }
+            else {
+                throw Error(`Could not refresh Pools `);
+            }
+        });
+    }
+    /**
+     * Refreshes the Pool Cache
+     *
+     * NOTE: do not call refereshPoolCache() directly, call getPools() instead
+     * which will refresh the cache if it's expired
+     */
+    refereshPoolCache() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const [thornodePools, midgardPools] = yield Promise.all([this.thornode.getPools(), this.midgard.getPools()]);
+            const poolMap = {};
+            if (midgardPools) {
+                for (const pool of midgardPools) {
+                    const thornodePool = thornodePools.find((p) => p.asset === pool.asset);
+                    const decimals = (_a = thornodePool === null || thornodePool === void 0 ? void 0 : thornodePool.decimals) !== null && _a !== void 0 ? _a : 8;
+                    const lp = new LiquidityPool(pool, decimals);
+                    poolMap[lp.asset.ticker] = lp;
+                }
+                this.poolCache = {
+                    lastRefreshed: Date.now(),
+                    pools: poolMap,
+                };
+            }
+        });
+    }
+    /**
+     * Refreshes the asgardAssetsCache Cache
+     *
+     * NOTE: do not call refereshAsgardCache() directly, call getAsgardAssets() instead
+     * which will refresh the cache if it's expired
+     */
+    refereshAsgardCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundAddressesItems = yield this.midgard.getAllInboundAddresses();
+            const map = {};
+            if (inboundAddressesItems) {
+                for (const inboundAddress of inboundAddressesItems) {
+                    map[inboundAddress.chain] = inboundAddress;
+                }
+                this.asgardAssetsCache = {
+                    lastRefreshed: Date.now(),
+                    inboundAddressesItems: map,
+                };
+            }
+        });
+    }
+    /**
+     * Refreshes the InboundDetailCache Cache
+     *
+     * NOTE: do not call refereshInboundDetailCache() directly, call getInboundDetails() instead
+     * which will refresh the cache if it's expired
+     */
+    refereshInboundDetailCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundDetails = yield this.midgard.getInboundDetails();
+            this.inboundDetailCache = {
+                lastRefreshed: Date.now(),
+                inboundDetails,
+            };
+        });
+    }
+    /**
+     * Refreshes the NetworkValuesCache Cache
+     *
+     * NOTE: do not call refereshNetworkValuesCache() directly, call getNetworkValuess() instead
+     * which will refresh the cache if it's expired
+     */
+    refereshNetworkValuesCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const networkValues = yield this.midgard.getNetworkValues();
+            this.networkValuesCache = {
+                lastRefreshed: Date.now(),
+                networkValues,
+            };
+        });
+    }
+    /**
+     *
+     *  Calcuate the expected slip, output & swapFee given the current pool depths
+     *
+     *  swapFee - the amount of asset lost  according to slip calculations
+     *  slip - the percent (0-1) of original amount lost to slipfees
+     *  output - the amount of asset expected from the swap   *
+     *
+     * @param inputAmount - CryptoAmount amount to swap from
+     * @param destinationAsset - destimation Asset to swap to
+     * @returns SwapOutput - swap output object - output - fee - slip
+     */
+    getExpectedSwapOutput(inputAmount, destinationAsset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (xchainUtil.isAssetRuneNative(inputAmount.asset)) {
+                //singleswap from rune -> asset
+                const pool = yield this.getPoolForAsset(destinationAsset);
+                return getSingleSwap(inputAmount, pool, false);
+            }
+            else if (xchainUtil.isAssetRuneNative(destinationAsset)) {
+                //singleswap from  asset -> rune
+                const pool = yield this.getPoolForAsset(inputAmount.asset);
+                return getSingleSwap(inputAmount, pool, true);
+            }
+            else {
+                //doubleswap asset-> asset
+                const inPool = yield this.getPoolForAsset(inputAmount.asset);
+                const destPool = yield this.getPoolForAsset(destinationAsset);
+                return yield getDoubleSwap(inputAmount, inPool, destPool, this);
+            }
+        });
+    }
+    /**
+     * Returns the exchange of a CryptoAmount to a different Asset
+     *
+     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
+     *
+     * @param input - amount/asset to convert to outAsset
+     * @param ouAsset - the Asset you want to convert to
+     * @returns CryptoAmount of input
+     */
+    convert(input, outAsset) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchangeRate = yield this.getExchangeRate(input.asset, outAsset);
+            let decimals = DEFAULT_THORCHAIN_DECIMALS;
+            if (!xchainUtil.isAssetRuneNative(outAsset)) {
+                const pool = yield this.getPoolForAsset(outAsset);
+                decimals = (_a = pool.decimals) !== null && _a !== void 0 ? _a : DEFAULT_THORCHAIN_DECIMALS;
+            }
+            const amt = xchainUtil.assetAmount(input.assetAmount.times(exchangeRate).amount().toFixed(), decimals);
+            const result = new CryptoAmount(xchainUtil.assetToBase(amt), outAsset);
+            return result;
+        });
+    }
+    getRouterAddressForChain(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundAsgard = (yield this.getInboundAddressesItems())[chain];
+            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
+                throw new Error('router address is not defined');
+            }
+            return inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router;
+        });
+    }
+    getInboundAddressesItems() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const millisSinceLastRefeshed = Date.now() - (((_a = this.asgardAssetsCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
+            if (millisSinceLastRefeshed > this.expireAsgardCacheMillis) {
+                try {
+                    yield this.refereshAsgardCache();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            if (this.asgardAssetsCache) {
+                return this.asgardAssetsCache.inboundAddressesItems;
+            }
+            else {
+                throw Error(`Could not refresh refereshAsgardCache `);
+            }
+        });
+    }
+    getInboundDetails() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const millisSinceLastRefeshed = Date.now() - (((_a = this.inboundDetailCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
+            if (millisSinceLastRefeshed > this.expireInboundDetailsCacheMillis) {
+                try {
+                    yield this.refereshInboundDetailCache();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            if (this.inboundDetailCache) {
+                return this.inboundDetailCache.inboundDetails;
+            }
+            else {
+                throw Error(`Could not refereshInboundDetailCache `);
+            }
+        });
+    }
+    getNetworkValues() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const millisSinceLastRefeshed = Date.now() - (((_a = this.networkValuesCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
+            if (millisSinceLastRefeshed > this.expireNetworkValuesCacheMillis) {
+                try {
+                    yield this.refereshNetworkValuesCache();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            if (this.networkValuesCache) {
+                return this.networkValuesCache.networkValues;
+            }
+            else {
+                throw Error(`Could not refereshInboundDetailCache `);
+            }
+        });
+    }
+    getDeepestUSDPool() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const usdAssets = USD_ASSETS[this.midgard.network];
+            let deepestRuneDepth = new BigNumber.BigNumber(0);
+            let deepestPool = null;
+            for (const usdAsset of usdAssets) {
+                const usdPool = yield this.getPoolForAsset(usdAsset);
+                if (usdPool.runeBalance.amount() > deepestRuneDepth) {
+                    deepestRuneDepth = usdPool.runeBalance.amount();
+                    deepestPool = usdPool;
+                }
+            }
+            if (!deepestPool)
+                throw Error('now USD Pool found');
+            return deepestPool;
+        });
+    }
+}
+
+/**
+ *
+ * @param liquidity - asset amount added
+ * @param pool  - pool depths
+ * @returns liquidity units
+ */
+const getLiquidityUnits = (liquidity, pool) => {
+    // formula: ((R + T) (r T + R t))/(4 R T)
+    // part1 * (part2 + part3) / denominator
+    const r = liquidity.rune;
+    const t = liquidity.asset;
+    const R = pool.runeBalance.amount().plus(r); // Must add r first
+    const T = pool.assetBalance.amount().plus(t); // Must add t first
+    const part1 = R.plus(T);
+    const part2 = r.times(T);
+    const part3 = R.times(t);
+    const numerator = part1.times(part2.plus(part3));
+    const denominator = R.times(T).times(4);
+    const result = numerator.div(denominator);
+    return result;
+};
+/**
+ *
+ * @param unitData
+ * @param pool
+ * @returns
+ */
+const getPoolShare = (unitData, pool) => {
+    // formula: (rune * part) / total; (asset * part) / total
+    const units = unitData.liquidityUnits;
+    const total = unitData.totalUnits;
+    const R = pool.runeBalance.amount();
+    const T = pool.assetBalance.amount();
+    const asset = T.times(units).div(total);
+    const rune = R.times(units).div(total);
+    const liquidityData = {
+        asset: asset,
+        rune: rune,
+    };
+    return liquidityData;
+};
+/**
+ *
+ * @param liquidity
+ * @param pool
+ * @returns
+ */
+const getSlipOnLiquidity = (liquidity, pool) => {
+    // formula: (t * R - T * r)/ (T*r + R*T)
+    const r = liquidity.rune;
+    const t = liquidity.asset;
+    const R = pool.runeBalance.amount();
+    const T = pool.assetBalance.amount();
+    const numerator = t.times(R).minus(T.times(r));
+    const denominator = T.times(r).plus(R.times(T));
+    const result = numerator.div(denominator).abs();
+    return result;
+};
+/**
+ *
+ * @param liquidity
+ * @param pool
+ * @param block
+ * @returns
+ */
+// Blocks for full protection 144000 // 100 days
+const getLiquidityProtectionData = (liquidity, pool, block) => {
+    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
+    const R0 = liquidity.rune; // symetrical value of rune deposit
+    const A0 = liquidity.asset; // symetrical value of asset deposit
+    const R1 = pool.runeBalance.amount(); // rune to redeem
+    const A1 = pool.assetBalance.amount(); // asset to redeem
+    const P1 = R1.div(A1); // Pool ratio at withdrawal
+    const coverage = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1));
+    const currentHeight = block.current;
+    const heightLastAdded = block.lastAdded;
+    const blocksforfullprotection = block.fullProtection;
+    const protectionProgress = (currentHeight - heightLastAdded) / blocksforfullprotection;
+    const result = protectionProgress * coverage.toNumber(); // impermanent loss protection result
+    return result;
+};
+
+const defaultMidgardConfig = {
+    mainnet: {
+        apiRetries: 3,
+        midgardBaseUrls: [
+            'https://midgard.thorchain.info',
+            'https://midgard.thorswap.net',
+            'https://midgard.ninerealms.com',
+        ],
+    },
+    stagenet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://stagenet-midgard.ninerealms.com'],
+    },
+    testnet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://testnet.midgard.thorchain.info'],
+    },
+};
+class Midgard {
+    constructor(network = xchainClient.Network.Mainnet, config) {
+        this.network = network;
+        this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig[this.network];
+        axiosRetry__default['default'](axios__default['default'], { retries: this.config.apiRetries, retryDelay: axiosRetry__default['default'].exponentialDelay });
+        this.midgardApis = this.config.midgardBaseUrls.map((url) => new xchainMidgard.MidgardApi(new xchainMidgard.Configuration({ basePath: url })));
+    }
+    getMimirDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = '/v2/thorchain/mimir';
+            for (const baseUrl of this.config.midgardBaseUrls) {
+                try {
+                    const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
+                    return data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error('Midgard not responding');
+        });
+    }
+    /**
+     *
+     * @returns an array of Pools
+     */
+    getPools() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    return (yield api.getPools()).data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    getAllInboundAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    return (yield api.getProxiedInboundAddresses()).data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Gets the Inbound Details
+     * @returns inbound details
+     */
+    getInboundDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [mimirDetails, allInboundDetails] = yield Promise.all([this.getMimirDetails(), this.getAllInboundAddresses()]);
+            const inboundDetails = {};
+            for (const inboundDetail of allInboundDetails) {
+                const chain = inboundDetail.chain;
+                if (!inboundDetail.gas_rate)
+                    throw new Error(`Could not get gas_rate for ${chain}`);
+                const details = {
+                    vault: inboundDetail.address,
+                    gas_rate: new BigNumber__default['default'](inboundDetail.gas_rate),
+                    haltedChain: (inboundDetail === null || inboundDetail === void 0 ? void 0 : inboundDetail.halted) || !!mimirDetails[`HALT${chain}CHAIN`] || !!mimirDetails['HALTCHAINGLOBAL'],
+                    haltedTrading: !!mimirDetails['HALTTRADING'] || !!mimirDetails[`HALT${chain}TRADING`],
+                    haltedLP: !!mimirDetails['PAUSELP'] || !!mimirDetails[`PAUSELP${chain}`],
+                };
+                inboundDetails[chain] = details;
+            }
+            // add mock THORCHAIN inbound details
+            const details = {
+                vault: '',
+                gas_rate: new BigNumber__default['default'](0),
+                haltedChain: false,
+                haltedTrading: !!mimirDetails['HALTTRADING'],
+                haltedLP: false, //
+            };
+            inboundDetails[xchainUtil.Chain.THORChain] = details;
+            return inboundDetails;
+        });
+    }
+    getConstantsDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = '/v2/thorchain/constants';
+            for (const baseUrl of this.config.midgardBaseUrls) {
+                try {
+                    const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
+                    return data.int_64_values;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error('Midgard not responding');
+        });
+    }
+    /**
+     *
+     * @returns the outbound Tx Value in RUNE (Basemount)
+     */
+    getScheduledOutboundValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = '/v2/thorchain/queue';
+            for (const baseUrl of this.config.midgardBaseUrls) {
+                try {
+                    const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
+                    const value = new CryptoAmount(xchainUtil.baseAmount(data['scheduled_outbound_value']), xchainUtil.AssetRuneNative);
+                    return value;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error('Midgard not responding');
+        });
+    }
+    /**
+     * Function that wraps Mimir and Constants to return the value from a given constant name. Searchs Mimir first.
+     *
+     * @param networkValueName the network value to be used to search the contsants
+     * @returns the mimir or constants value
+     */
+    getNetworkValues() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [mimirDetails, constantDetails] = yield Promise.all([this.getMimirDetails(), this.getConstantsDetails()]);
+            const retVal = {};
+            // insert constants first
+            for (const constantKey of Object.keys(constantDetails)) {
+                retVal[constantKey.toUpperCase()] = constantDetails[constantKey];
+            }
+            // mimir will overwrite any dupe constants
+            for (const mimirKey of Object.keys(mimirDetails)) {
+                const mimirValue = mimirDetails[mimirKey];
+                retVal[mimirKey.toUpperCase()] = mimirValue;
+            }
+            return retVal;
+        });
+    }
+    /**
+     * Gets the latest block using the Health endpoint within Midgard
+     *
+     * @returns
+     */
+    getLatestBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const data = (yield api.getHealth()).data;
+                    return +data.scannerHeight;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Gets actions related to a txID
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const actions = (yield api.getActions('', txHash)).data.actions;
+                    return actions;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+}
+
+const defaultThornodeConfig = {
+    mainnet: {
+        apiRetries: 3,
+        thornodeBaseUrls: [
+            `https://thornode.ninerealms.com`,
+            `https://thornode.thorswap.net`,
+            `https://thornode.thorchain.info`,
+        ],
+    },
+    stagenet: {
+        apiRetries: 3,
+        thornodeBaseUrls: ['https://stagenet-thornode.ninerealms.com'],
+    },
+    testnet: {
+        apiRetries: 3,
+        thornodeBaseUrls: ['https://testnet.thornode.thorchain.info'],
+    },
+};
+class Thornode {
+    constructor(network = xchainClient.Network.Mainnet, config) {
+        this.network = network;
+        this.config = config !== null && config !== void 0 ? config : defaultThornodeConfig[this.network];
+        axiosRetry__default['default'](axios__default['default'], { retries: this.config.apiRetries, retryDelay: axiosRetry__default['default'].exponentialDelay });
+        this.transactionsApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.TransactionsApi(new xchainThornode.Configuration({ basePath: url })));
+        this.queueApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.QueueApi(new xchainThornode.Configuration({ basePath: url })));
+        this.networkApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.NetworkApi(new xchainThornode.Configuration({ basePath: url })));
+        this.poolsApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.PoolsApi(new xchainThornode.Configuration({ basePath: url })));
+    }
+    /**
+     * Returns the oubound transactions held by THORChain due to outbound delay
+     * May be empty if there are no transactions
+     *
+     * @returns {ScheduledQueueItem} Array
+     *
+     */
+    getscheduledQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.queueApi) {
+                try {
+                    const queueScheduled = yield api.queueScheduled();
+                    return queueScheduled.data;
+                }
+                catch (e) {
+                    console.error(e);
+                    throw new Error(`THORNode not responding`);
+                }
+            }
+            throw Error(`THORNode not responding`);
+        });
+    }
+    getTxData(txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.transactionsApi) {
+                try {
+                    const txResponse = yield api.tx(txHash);
+                    return txResponse.data;
+                }
+                catch (e) {
+                    const txR = {
+                        observed_tx: undefined,
+                        keysign_metric: undefined,
+                    };
+                    return txR;
+                }
+            }
+            throw new Error(`THORNode not responding`);
+        });
+    }
+    getLastBlock(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.networkApi) {
+                try {
+                    const lastBlock = yield api.lastblock(height);
+                    return lastBlock.data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error(`THORNode not responding`);
+        });
+    }
+    getPools() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.poolsApi) {
+                try {
+                    const pools = yield api.pools();
+                    return pools.data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error(`THORNode not responding`);
+        });
+    }
+}
+
+exports.CryptoAmount = CryptoAmount;
+exports.LiquidityPool = LiquidityPool;
+exports.Midgard = Midgard;
+exports.ThorchainCache = ThorchainCache;
+exports.ThorchainQuery = ThorchainQuery;
+exports.Thornode = Thornode;
+exports.calcNetworkFee = calcNetworkFee;
+exports.getDoubleSwap = getDoubleSwap;
+exports.getLiquidityProtectionData = getLiquidityProtectionData;
+exports.getLiquidityUnits = getLiquidityUnits;
+exports.getPoolShare = getPoolShare;
+exports.getSingleSwap = getSingleSwap;
+exports.getSlipOnLiquidity = getSlipOnLiquidity;