@xchainjs/xchain-thorchain-query 0.2.2 → 0.2.4

package/lib/index.js

@@ -2,21 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var xchainBinance = require('@xchainjs/xchain-binance');
-var xchainBitcoin = require('@xchainjs/xchain-bitcoin');
-var xchainCosmos = require('@xchainjs/xchain-cosmos');
-var xchainThorchain = require('@xchainjs/xchain-thorchain');
 var xchainUtil = require('@xchainjs/xchain-util');
 var bignumber_js = require('bignumber.js');
 var xchainClient = require('@xchainjs/xchain-client');
 var xchainMidgard = require('@xchainjs/xchain-midgard');
 var axios = require('axios');
 var axiosRetry = require('axios-retry');
-var xchainAvax = require('@xchainjs/xchain-avax');
-var xchainBitcoincash = require('@xchainjs/xchain-bitcoincash');
-var xchainDoge = require('@xchainjs/xchain-doge');
-var xchainEthereum = require('@xchainjs/xchain-ethereum');
-var xchainLitecoin = require('@xchainjs/xchain-litecoin');
 var xchainThornode = require('@xchainjs/xchain-thornode');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -86,6 +77,14 @@ const DefaultChainAttributes = {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
     },
+    BSC: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 3,
+    },
+    MAYA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
 };
 
 /**
@@ -205,148 +204,29 @@ class LiquidityPool {
     }
 }
 
-const defaultMidgardConfig = {
-    mainnet: {
-        apiRetries: 3,
-        midgardBaseUrls: ['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 })));
-    }
-    /**
-     *
-     * @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 new Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * 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 object for any of the parameters
-     * @param txHash transaction id
-     * @returns Type Action array of objects
-     */
-    getActions(address, txid, asset, type, affiliate, limit, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
-                    return actions;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return member details based on valid liquidity position
-     * @param address - needed to query for Lp details
-     * @returns - object type of Member Detail
-     */
-    getMember(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const memberDetail = (yield api.getMemberDetail(address)).data;
-                    return memberDetail;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return pool statistics for a particular asset
-     * @param asset - asset string to query its pool stats
-     * @returns - type object poolstatsDetail
-     */
-    getPoolStats(asset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const poolDetail = (yield api.getPoolStats(asset)).data;
-                    return poolDetail;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return THORNameDetails for a particular name
-     * @param name - thorname string to query
-     * @returns - type object THORNameDetails
-     */
-    getTHORNameDetails(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const resp = yield api.getTHORNameDetail(name);
-                    if (resp.status == 404) {
-                        return undefined;
-                    }
-                    else if (resp.status == 200) {
-                        return resp.data;
-                    }
-                }
-                catch (e) {
-                    // if (resp.status == 404) {
-                    //   return undefined
-                    // }
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-}
+const AssetBNB = xchainUtil.assetFromStringEx('BNB.BNB');
+const AssetAVAX = xchainUtil.assetFromStringEx('AVAX.AVAX');
+const AssetBTC = xchainUtil.assetFromStringEx('BTC.BTC');
+const AssetBCH = xchainUtil.assetFromStringEx('BCH.BHC');
+const AssetETH = xchainUtil.assetFromStringEx('ETH.ETH');
+const AssetDOGE = xchainUtil.assetFromStringEx('DOGE.DOGE');
+const AssetLTC = xchainUtil.assetFromStringEx('LTC.LTC');
+const AssetATOM = xchainUtil.assetFromStringEx('GAIA.ATOM');
+const AssetMAYA = xchainUtil.assetFromStringEx('MAYA.CACAO');
+const AssetBSC = xchainUtil.assetFromStringEx('BSC.BNB');
+const AssetRuneNative = xchainUtil.assetFromStringEx('THOR.RUNE');
+const BNBChain = 'BNB';
+const BTCChain = 'BTC';
+const BCHChain = 'BCH';
+const ETHChain = 'ETH';
+const GAIAChain = 'GAIA';
+const DOGEChain = 'DOGE';
+const LTCChain = 'LTC';
+const AVAXChain = 'AVAX';
+const MAYAChain = 'MAYA';
+const BSCChain = 'BSC';
+const THORChain = 'THOR';
+const isAssetRuneNative = (asset) => xchainUtil.assetToString(asset) === xchainUtil.assetToString(AssetRuneNative);
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
@@ -369,7 +249,7 @@ const getSwapFee = (inputAmount, pool, toRune) => {
     const x = getBaseAmountWithDiffDecimals(inputAmount, 8);
     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 ? xchainThorchain.AssetRuneNative : pool.asset;
+    const units = toRune ? AssetRuneNative : pool.asset;
     const numerator = x.times(x).multipliedBy(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
@@ -408,7 +288,7 @@ const getSwapOutput = (inputAmount, pool, toRune) => {
     const x = getBaseAmountWithDiffDecimals(inputAmount, 8);
     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 ? xchainThorchain.AssetRuneNative : pool.asset;
+    const units = toRune ? 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);
@@ -453,7 +333,7 @@ const getDoubleSwapFee = (inputAmount, pool1, pool2, thorchainCache) => __awaite
     const fee1InRune = getSwapFee(inputAmount, pool1, true);
     const swapOutput = getSwapOutput(inputAmount, pool1, true);
     const fee2InAsset = getSwapFee(swapOutput, pool2, false);
-    const fee2InRune = yield thorchainCache.convert(fee2InAsset, xchainThorchain.AssetRuneNative);
+    const fee2InRune = yield thorchainCache.convert(fee2InAsset, AssetRuneNative);
     const result = fee1InRune.plus(fee2InRune);
     return result;
 });
@@ -482,24 +362,28 @@ const getDoubleSwap = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(v
  */
 const getChainAsset = (chain) => {
     switch (chain) {
-        case xchainBinance.BNBChain:
-            return xchainBinance.AssetBNB;
-        case xchainBitcoin.BTCChain:
-            return xchainBitcoin.AssetBTC;
-        case xchainEthereum.ETHChain:
-            return xchainEthereum.AssetETH;
-        case xchainThorchain.THORChain:
-            return xchainThorchain.AssetRuneNative;
-        case xchainCosmos.GAIAChain:
-            return xchainCosmos.AssetATOM;
-        case xchainBitcoincash.BCHChain:
-            return xchainBitcoincash.AssetBCH;
-        case xchainLitecoin.LTCChain:
-            return xchainLitecoin.AssetLTC;
-        case xchainDoge.DOGEChain:
-            return xchainDoge.AssetDOGE;
-        case xchainAvax.AVAXChain:
-            return xchainAvax.AssetAVAX;
+        case BNBChain:
+            return AssetBNB;
+        case BTCChain:
+            return AssetBTC;
+        case ETHChain:
+            return AssetETH;
+        case THORChain:
+            return AssetRuneNative;
+        case GAIAChain:
+            return AssetATOM;
+        case BCHChain:
+            return AssetBCH;
+        case LTCChain:
+            return AssetLTC;
+        case DOGEChain:
+            return AssetDOGE;
+        case AVAXChain:
+            return AssetAVAX;
+        case BSCChain:
+            return AssetBSC;
+        case MAYAChain:
+            return AssetMAYA;
         default:
             throw Error('Unknown chain');
     }
@@ -524,44 +408,48 @@ const isNativeChainAsset = (asset) => {
 const calcNetworkFee = (asset, inbound) => {
     // synths are always 0.02R fee
     if (asset.synth)
-        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), AssetRuneNative);
     // if you are swapping a non-gas asset  on a multiAsset chain (ex. ERC-20 on ETH), the
     // gas fees will be paid in a diff asset than the one you are swapping
     switch (asset.chain) {
-        case xchainBitcoin.BTCChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainBitcoin.AssetBTC);
-        case xchainBitcoincash.BCHChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainBitcoincash.AssetBCH);
-        case xchainLitecoin.LTCChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainLitecoin.AssetLTC);
-        case xchainDoge.DOGEChain:
+        case BTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
+        case BCHChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
+        case LTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetLTC);
+        case DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainDoge.AssetDOGE);
-        case xchainBinance.BNBChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
+        case BNBChain:
             //flat fee
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainBinance.AssetBNB);
-        case xchainEthereum.ETHChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), AssetBNB);
+        case ETHChain:
             const gasRateinETHGwei = inbound.gasRate;
             const gasRateinETHWei = xchainUtil.baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
-            if (xchainUtil.eqAsset(asset, xchainEthereum.AssetETH)) {
-                return new CryptoAmount(gasRateinETHWei.times(21000), xchainEthereum.AssetETH);
+            if (xchainUtil.eqAsset(asset, AssetETH)) {
+                return new CryptoAmount(gasRateinETHWei.times(21000), AssetETH);
             }
             else {
-                return new CryptoAmount(gasRateinETHWei.times(70000), xchainEthereum.AssetETH);
+                return new CryptoAmount(gasRateinETHWei.times(70000), AssetETH);
             }
-        case xchainAvax.AVAXChain:
+        case AVAXChain:
             const gasRateinAVAXGwei = inbound.gasRate;
             const gasRateinAVAXWei = xchainUtil.baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
-            if (xchainUtil.eqAsset(asset, xchainAvax.AssetAVAX)) {
-                return new CryptoAmount(gasRateinAVAXWei.times(21000), xchainAvax.AssetAVAX);
+            if (xchainUtil.eqAsset(asset, AssetAVAX)) {
+                return new CryptoAmount(gasRateinAVAXWei.times(21000), AssetAVAX);
             }
             else {
-                return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainAvax.AssetAVAX);
+                return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
             }
-        case xchainCosmos.GAIAChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainCosmos.AssetATOM);
-        case xchainThorchain.THORChain:
-            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
+        case GAIAChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), AssetATOM);
+        case THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), AssetRuneNative);
+        case BSCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), AssetBSC);
+        case MAYAChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), AssetMAYA);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
@@ -576,32 +464,270 @@ const calcNetworkFee = (asset, inbound) => {
  */
 const calcOutboundFee = (asset, inbound) => {
     if (asset.synth)
-        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), AssetRuneNative);
     switch (asset.chain) {
-        case xchainBitcoin.BTCChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainBitcoin.AssetBTC);
-        case xchainBitcoincash.BCHChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainBitcoincash.AssetBCH);
-        case xchainLitecoin.LTCChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainLitecoin.AssetLTC);
-        case xchainDoge.DOGEChain:
+        case BTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetBTC);
+        case BCHChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetBCH);
+        case LTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetLTC);
+        case DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainDoge.AssetDOGE);
-        case xchainBinance.BNBChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetDOGE);
+        case BNBChain:
             //flat fee
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainBinance.AssetBNB);
-        case xchainEthereum.ETHChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), xchainEthereum.AssetETH);
-        case xchainAvax.AVAXChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), xchainAvax.AssetAVAX);
-        case xchainCosmos.GAIAChain:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainCosmos.AssetATOM);
-        case xchainThorchain.THORChain:
-            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetBNB);
+        case ETHChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetETH);
+        case AVAXChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetAVAX);
+        case GAIAChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetATOM);
+        case BSCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), AssetBSC);
+        case THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), AssetRuneNative);
+        case MAYAChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), AssetMAYA);
     }
     throw new Error(`could not calculate outbound fee for ${asset.chain}`);
 };
 
+/**
+ * https://dev.thorchain.org/thorchain-dev/interface-guide/math#lp-units-add
+ * @param liquidity - asset amount added
+ * @param pool  - pool depths
+ * @returns liquidity units - ownership of pool
+ */
+const getLiquidityUnits = (liquidity, pool) => {
+    const baseAmount8decimals = getBaseAmountWithDiffDecimals(liquidity.asset, 8);
+    const P = new bignumber_js.BigNumber(pool.pool.liquidityUnits);
+    const r = liquidity.rune.baseAmount.amount();
+    const a = baseAmount8decimals;
+    const R = pool.runeBalance.amount();
+    const A = pool.assetBalance.amount();
+    const part1 = R.times(a);
+    const part2 = r.times(A);
+    const numerator = P.times(part1.plus(part2));
+    const denominator = R.times(A).times(2);
+    const result = numerator.div(denominator);
+    return result;
+};
+/**
+ *
+ * @param unitData - units for both asset and rune
+ * @param pool - pool that the asset is bound to
+ * @returns - pool share of both asset and rune in percentage
+ */
+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 poolShareDetail = {
+        assetShare: new CryptoAmount(xchainUtil.baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(xchainUtil.baseAmount(rune), AssetRuneNative),
+    };
+    return poolShareDetail;
+};
+/**
+ *
+ * @param poolShare - the share of asset and rune added to the pool
+ * @param pool - Pool that the asset is attached to
+ * @returns - returns bignumber representing a slip percentage
+ */
+const getSlipOnLiquidity = (stake, pool) => {
+    const baseAmount8decimals = getBaseAmountWithDiffDecimals(stake.asset, 8);
+    // formula: (t * R - T * r)/ (T*r + R*T)
+    const r = stake.rune.baseAmount.amount();
+    const t = baseAmount8decimals;
+    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;
+};
+/**
+ * https://docs.thorchain.org/thorchain-finance/continuous-liquidity-pools#impermanent-loss-protection
+ * @param poolShare - the share of asset and rune added to the pool
+ * @param pool - Pool that the asset is attached to
+ * @param block - blockl object with current, last added and the constant blocksforlossProtection
+ * @returns
+ */
+// Blocks for full protection 1440000 // 100 days
+const getLiquidityProtectionData = (depositValue, poolShare, block) => {
+    //Coverage formula coverage=((A0∗P1)+R0)−((A1∗P1)+R1)=>((A0∗R1/A1)+R0)−(R1+R1)
+    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
+    const R0 = depositValue.rune.amount(); // rune deposit value
+    const A0 = depositValue.asset.amount(); // asset deposit value
+    const R1 = poolShare.runeShare.baseAmount.amount(); // rune amount to redeem
+    const A1 = poolShare.assetShare.baseAmount.amount(); // asset amount to redeem
+    const P1 = R1.div(A1); // Pool ratio at withdrawal
+    const part1 = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1)); // start position minus end position
+    const part2 = A0.times(R1.div(A1)).plus(R0).minus(R1.plus(R1)); // different way to check position
+    const coverage = part1 >= part2 ? part1 : part2; // Coverage represents how much ILP a LP is entitled to
+    const currentHeight = block.current;
+    const heightLastAdded = block.lastAdded || 0; //default to zero if undefined
+    const blocksforfullprotection = block.fullProtection;
+    const fractionOfFullILPProtection = (currentHeight - heightLastAdded) / blocksforfullprotection;
+    const protectionProgress = Math.min(fractionOfFullILPProtection, 1); // percentage of entitlement, max 100%
+    const result = coverage.times(protectionProgress); // impermanent loss protection result
+    const maxILP = result.lt(0) ? new bignumber_js.BigNumber(0) : result; // max negative ILP to 0
+    const ILProtection = {
+        ILProtection: new CryptoAmount(xchainUtil.baseAmount(maxILP), AssetRuneNative),
+        totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
+    };
+    return ILProtection;
+};
+
+const defaultMidgardConfig = {
+    mainnet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['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 })));
+    }
+    /**
+     *
+     * @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 new Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * 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 object for any of the parameters
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(address, txid, asset, type, affiliate, limit, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
+                    return actions;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return member details based on valid liquidity position
+     * @param address - needed to query for Lp details
+     * @returns - object type of Member Detail
+     */
+    getMember(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const memberDetail = (yield api.getMemberDetail(address)).data;
+                    return memberDetail;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return pool statistics for a particular asset
+     * @param asset - asset string to query its pool stats
+     * @returns - type object poolstatsDetail
+     */
+    getPoolStats(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const poolDetail = (yield api.getPoolStats(asset)).data;
+                    return poolDetail;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return THORNameDetails for a particular name
+     * @param name - thorname string to query
+     * @returns - type object THORNameDetails
+     */
+    getTHORNameDetails(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const resp = yield api.getTHORNameDetail(name);
+                    if (resp.status == 404) {
+                        return undefined;
+                    }
+                    else if (resp.status == 200) {
+                        return resp.data;
+                    }
+                }
+                catch (e) {
+                    // if (resp.status == 404) {
+                    //   return undefined
+                    // }
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+}
+
 const defaultThornodeConfig = {
     mainnet: {
         apiRetries: 3,
@@ -1041,12 +1167,12 @@ class ThorchainCache {
             if (xchainUtil.eqAsset(from, to)) {
                 exchangeRate = SAME_ASSET_EXCHANGE_RATE;
             }
-            else if (xchainThorchain.isAssetRuneNative(from)) {
+            else if (isAssetRuneNative(from)) {
                 //  Runes per Asset
                 const lpTo = yield this.getPoolForAsset(to);
                 exchangeRate = lpTo.assetToRuneRatio;
             }
-            else if (xchainThorchain.isAssetRuneNative(to)) {
+            else if (isAssetRuneNative(to)) {
                 //  Asset per rune
                 const lpFrom = yield this.getPoolForAsset(from);
                 exchangeRate = lpFrom.runeToAssetRatio;
@@ -1070,7 +1196,7 @@ class ThorchainCache {
      */
     getPoolForAsset(asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (xchainThorchain.isAssetRuneNative(asset))
+            if (isAssetRuneNative(asset))
                 throw Error(`AssetRuneNative doesn't have a pool`);
             const pools = yield this.getPools();
             // Note: we use ticker, not asset string to get the same pool for both assets and synths
@@ -1182,7 +1308,7 @@ class ThorchainCache {
             }
             // add mock THORCHAIN inbound details
             const details = {
-                chain: xchainThorchain.THORChain,
+                chain: THORChain,
                 address: '',
                 router: '',
                 gasRate: new bignumber_js.BigNumber(0),
@@ -1193,7 +1319,7 @@ class ThorchainCache {
                 haltedTrading: !!mimirDetails['HALTTRADING'],
                 haltedLP: false, //
             };
-            inboundDetails[xchainThorchain.THORChain] = details;
+            inboundDetails[THORChain] = details;
             this.inboundDetailCache = {
                 lastRefreshed: Date.now(),
                 inboundDetails,
@@ -1230,12 +1356,12 @@ class ThorchainCache {
     getExpectedSwapOutput(inputAmount, destinationAsset) {
         return __awaiter(this, void 0, void 0, function* () {
             let swapOutput;
-            if (xchainThorchain.isAssetRuneNative(inputAmount.asset)) {
+            if (isAssetRuneNative(inputAmount.asset)) {
                 //singleswap from rune -> asset
                 const pool = yield this.getPoolForAsset(destinationAsset);
                 swapOutput = getSingleSwap(inputAmount, pool, false);
             }
-            else if (xchainThorchain.isAssetRuneNative(destinationAsset)) {
+            else if (isAssetRuneNative(destinationAsset)) {
                 //singleswap from  asset -> rune
                 const pool = yield this.getPoolForAsset(inputAmount.asset);
                 swapOutput = getSingleSwap(inputAmount, pool, true);
@@ -1278,7 +1404,7 @@ class ThorchainCache {
     }
     getDecimalForAsset(asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!xchainThorchain.isAssetRuneNative(asset)) {
+            if (!isAssetRuneNative(asset)) {
                 const pool = yield this.getPoolForAsset(asset);
                 const decimals = Number(pool.pool.nativeDecimal);
                 if (decimals > 0)
@@ -1365,97 +1491,6 @@ class ThorchainCache {
     }
 }
 
-/**
- * https://dev.thorchain.org/thorchain-dev/interface-guide/math#lp-units-add
- * @param liquidity - asset amount added
- * @param pool  - pool depths
- * @returns liquidity units - ownership of pool
- */
-const getLiquidityUnits = (liquidity, pool) => {
-    const baseAmount8decimals = getBaseAmountWithDiffDecimals(liquidity.asset, 8);
-    const P = new bignumber_js.BigNumber(pool.pool.liquidityUnits);
-    const r = liquidity.rune.baseAmount.amount();
-    const a = baseAmount8decimals;
-    const R = pool.runeBalance.amount();
-    const A = pool.assetBalance.amount();
-    const part1 = R.times(a);
-    const part2 = r.times(A);
-    const numerator = P.times(part1.plus(part2));
-    const denominator = R.times(A).times(2);
-    const result = numerator.div(denominator);
-    return result;
-};
-/**
- *
- * @param unitData - units for both asset and rune
- * @param pool - pool that the asset is bound to
- * @returns - pool share of both asset and rune in percentage
- */
-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 poolShareDetail = {
-        assetShare: new CryptoAmount(xchainUtil.baseAmount(asset), pool.asset),
-        runeShare: new CryptoAmount(xchainUtil.baseAmount(rune), xchainThorchain.AssetRuneNative),
-    };
-    return poolShareDetail;
-};
-/**
- *
- * @param poolShare - the share of asset and rune added to the pool
- * @param pool - Pool that the asset is attached to
- * @returns - returns bignumber representing a slip percentage
- */
-const getSlipOnLiquidity = (stake, pool) => {
-    const baseAmount8decimals = getBaseAmountWithDiffDecimals(stake.asset, 8);
-    // formula: (t * R - T * r)/ (T*r + R*T)
-    const r = stake.rune.baseAmount.amount();
-    const t = baseAmount8decimals;
-    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;
-};
-/**
- * https://docs.thorchain.org/thorchain-finance/continuous-liquidity-pools#impermanent-loss-protection
- * @param poolShare - the share of asset and rune added to the pool
- * @param pool - Pool that the asset is attached to
- * @param block - blockl object with current, last added and the constant blocksforlossProtection
- * @returns
- */
-// Blocks for full protection 1440000 // 100 days
-const getLiquidityProtectionData = (depositValue, poolShare, block) => {
-    //Coverage formula coverage=((A0∗P1)+R0)−((A1∗P1)+R1)=>((A0∗R1/A1)+R0)−(R1+R1)
-    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
-    const R0 = depositValue.rune.amount(); // rune deposit value
-    const A0 = depositValue.asset.amount(); // asset deposit value
-    const R1 = poolShare.runeShare.baseAmount.amount(); // rune amount to redeem
-    const A1 = poolShare.assetShare.baseAmount.amount(); // asset amount to redeem
-    const P1 = R1.div(A1); // Pool ratio at withdrawal
-    const part1 = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1)); // start position minus end position
-    const part2 = A0.times(R1.div(A1)).plus(R0).minus(R1.plus(R1)); // different way to check position
-    const coverage = part1 >= part2 ? part1 : part2; // Coverage represents how much ILP a LP is entitled to
-    const currentHeight = block.current;
-    const heightLastAdded = block.lastAdded || 0; //default to zero if undefined
-    const blocksforfullprotection = block.fullProtection;
-    const fractionOfFullILPProtection = (currentHeight - heightLastAdded) / blocksforfullprotection;
-    const protectionProgress = Math.min(fractionOfFullILPProtection, 1); // percentage of entitlement, max 100%
-    const result = coverage.times(protectionProgress); // impermanent loss protection result
-    const maxILP = result.lt(0) ? new bignumber_js.BigNumber(0) : result; // max negative ILP to 0
-    const ILProtection = {
-        ILProtection: new CryptoAmount(xchainUtil.baseAmount(maxILP), xchainThorchain.AssetRuneNative),
-        totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
-    };
-    return ILProtection;
-};
-
 const BN_1 = new bignumber_js.BigNumber(1);
 const defaultCache = new ThorchainCache();
 /**
@@ -1568,7 +1603,7 @@ class ThorchainQuery {
     isValidSwap(params) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (xchainThorchain.isAssetRuneNative(params.input.asset) || params.input.asset.synth) {
+            if (isAssetRuneNative(params.input.asset) || params.input.asset.synth) {
                 if (params.input.baseAmount.decimal !== 8)
                     throw Error(`input asset ${xchainUtil.assetToString(params.input.asset)}  must have decimals of 8`);
             }
@@ -1615,14 +1650,14 @@ class ThorchainQuery {
             const inboundFeeInInboundGasAsset = calcNetworkFee(input.asset, sourceInboundDetails);
             let outboundFeeInOutboundGasAsset = calcOutboundFee(params.destinationAsset, destinationInboundDetails);
             // 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 !== xchainThorchain.THORChain && !params.destinationAsset.synth) {
+            if (params.destinationAsset.chain !== THORChain && !params.destinationAsset.synth) {
                 const deepestUSDPOOL = yield this.thorchainCache.getDeepestUSDPool();
                 const usdAsset = deepestUSDPOOL.asset;
                 const usdMinFee = new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount('1', Number(deepestUSDPOOL.pool.nativeDecimal))), usdAsset);
                 const checkOutboundFee = (yield this.convert(outboundFeeInOutboundGasAsset, usdAsset)).gte(usdMinFee);
                 if (!checkOutboundFee) {
                     const newFee = usdMinFee;
-                    outboundFeeInOutboundGasAsset = yield this.convert(newFee, xchainThorchain.AssetRuneNative);
+                    outboundFeeInOutboundGasAsset = yield this.convert(newFee, AssetRuneNative);
                 }
             }
             // ----------- Remove Fees from inbound before doing the swap -----------
@@ -1633,15 +1668,15 @@ class ThorchainQuery {
             const affiliateFeePercent = params.affiliateFeeBasisPoints ? params.affiliateFeeBasisPoints / 10000 : 0;
             const affiliateFeeInAsset = inputMinusInboundFeeInAsset.times(affiliateFeePercent);
             let affiliateFeeSwapOutputInRune;
-            if (xchainThorchain.isAssetRuneNative(affiliateFeeInAsset.asset)) {
+            if (isAssetRuneNative(affiliateFeeInAsset.asset)) {
                 affiliateFeeSwapOutputInRune = {
                     output: affiliateFeeInAsset,
-                    swapFee: new CryptoAmount(xchainUtil.baseAmount(0), xchainThorchain.AssetRuneNative),
+                    swapFee: new CryptoAmount(xchainUtil.baseAmount(0), AssetRuneNative),
                     slip: new bignumber_js.BigNumber(0),
                 };
             }
             else {
-                affiliateFeeSwapOutputInRune = yield this.thorchainCache.getExpectedSwapOutput(affiliateFeeInAsset, xchainThorchain.AssetRuneNative);
+                affiliateFeeSwapOutputInRune = yield this.thorchainCache.getExpectedSwapOutput(affiliateFeeInAsset, AssetRuneNative);
             }
             // remove the affiliate fee from the input.
             const inputNetInAsset = inputMinusInboundFeeInAsset.minus(affiliateFeeInAsset);
@@ -1672,7 +1707,7 @@ class ThorchainQuery {
         const contractAddress = xchainUtil.getContractAddressFromAsset(asset);
         if (contractAddress && contractAddress.length > 5) {
             const abrev = contractAddress.substring(contractAddress.length - 5);
-            const sep = asset.chain !== xchainThorchain.THORChain && asset.synth ? '/' : '.';
+            const sep = asset.chain !== THORChain && asset.synth ? '/' : '.';
             return `${asset.chain}${sep}${asset.ticker}-${abrev}`;
         }
         return xchainUtil.assetToString(asset);
@@ -1693,7 +1728,7 @@ class ThorchainQuery {
             memo = memo.concat(`:${params.affiliateAddress}:${params.affiliateFeeBasisPoints}`);
         }
         // If memo length is too long for BTC, trim it
-        if (xchainUtil.eqAsset(params.input.asset, xchainBitcoin.AssetBTC) && memo.length > 80) {
+        if (xchainUtil.eqAsset(params.input.asset, AssetBTC) && memo.length > 80) {
             memo = `=:${this.abbreviateAssetString(params.destinationAsset)}:${params.destinationAddress}:${lim}`;
         }
         return memo;
@@ -1731,12 +1766,12 @@ class ThorchainQuery {
             const errors = [];
             const sourceAsset = params.input.asset;
             const destAsset = params.destinationAsset;
-            if (!xchainThorchain.isAssetRuneNative(sourceAsset)) {
+            if (!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 (!xchainThorchain.isAssetRuneNative(destAsset)) {
+            if (!isAssetRuneNative(destAsset)) {
                 const destPool = yield this.thorchainCache.getPoolForAsset(destAsset);
                 if (!destPool.isAvailable())
                     errors.push(`destinationAsset ${destAsset.ticker} does not have a valid liquidity pool`);
@@ -1782,8 +1817,8 @@ class ThorchainQuery {
     checkCoverFees(params, estimate) {
         return __awaiter(this, void 0, void 0, function* () {
             let result = undefined;
-            const inputInRune = yield this.thorchainCache.convert(params.input, xchainThorchain.AssetRuneNative);
-            const feesInRune = yield this.getFeesIn(estimate.totalFees, xchainThorchain.AssetRuneNative);
+            const inputInRune = yield this.thorchainCache.convert(params.input, AssetRuneNative);
+            const feesInRune = yield this.getFeesIn(estimate.totalFees, AssetRuneNative);
             const totalSwapFeesInRune = !params.input.asset.synth && isNativeChainAsset(params.input.asset)
                 ? feesInRune.inboundFee.plus(feesInRune.outboundFee).plus(feesInRune.swapFee).plus(feesInRune.affiliateFee)
                 : feesInRune.outboundFee.plus(feesInRune.swapFee).plus(feesInRune.affiliateFee);
@@ -1840,11 +1875,11 @@ class ThorchainQuery {
     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 (xchainThorchain.isAssetRuneNative(inbound.asset) ||
-                inbound.asset.chain == xchainBinance.BNBChain ||
-                inbound.asset.chain == xchainCosmos.GAIAChain ||
+            if (isAssetRuneNative(inbound.asset) ||
+                inbound.asset.chain == BNBChain ||
+                inbound.asset.chain == GAIAChain ||
                 inbound.asset.synth) {
-                return this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs;
+                return this.chainAttributes[THORChain].avgBlockTimeInSecs;
             }
             // Get the gas asset for the inbound.asset.chain
             const chainGasAsset = getChainAsset(inbound.asset.chain);
@@ -1869,16 +1904,16 @@ class ThorchainQuery {
     outboundDelay(outboundAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const networkValues = yield this.thorchainCache.getNetworkValues();
-            const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), xchainThorchain.AssetRuneNative);
+            const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
-            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainThorchain.AssetRuneNative).assetAmount
+            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), AssetRuneNative).assetAmount
                 .amount()
                 .toNumber();
             const getQueue = yield this.thorchainCache.thornode.getQueue();
-            const outboundValue = new CryptoAmount(xchainUtil.baseAmount(getQueue.scheduled_outbound_value), xchainThorchain.AssetRuneNative);
-            const thorChainblocktime = this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
+            const outboundValue = new CryptoAmount(xchainUtil.baseAmount(getQueue.scheduled_outbound_value), AssetRuneNative);
+            const thorChainblocktime = this.chainAttributes[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, xchainThorchain.AssetRuneNative);
+            const runeValue = yield this.thorchainCache.convert(outboundAmount, AssetRuneNative);
             // Check rune value amount
             if (runeValue.lt(minTxOutVolumeThreshold)) {
                 return thorChainblocktime;
@@ -1909,7 +1944,7 @@ class ThorchainQuery {
             const errors = [];
             if (params.asset.asset.synth || params.rune.asset.synth)
                 errors.push('you cannot add liquidity with a synth');
-            if (!xchainThorchain.isAssetRuneNative(params.rune.asset))
+            if (!isAssetRuneNative(params.rune.asset))
                 errors.push('params.rune must be THOR.RUNE');
             const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset.asset);
             const lpUnits = getLiquidityUnits({ asset: params.asset, rune: params.rune }, assetPool);
@@ -1923,7 +1958,7 @@ class ThorchainQuery {
             const runeWaitTimeSeconds = yield this.confCounting(params.rune);
             const waitTimeSeconds = assetWaitTimeSeconds > runeWaitTimeSeconds ? assetWaitTimeSeconds : runeWaitTimeSeconds;
             let assetInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), params.asset.asset);
-            let runeInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), xchainThorchain.AssetRuneNative);
+            let runeInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), AssetRuneNative);
             if (!params.asset.assetAmount.eq(0)) {
                 assetInboundFee = calcNetworkFee(params.asset.asset, inboundDetails[params.asset.asset.chain]);
                 if (assetInboundFee.assetAmount.amount().times(3).gt(params.asset.assetAmount.amount()))
@@ -1934,7 +1969,7 @@ class ThorchainQuery {
                 if (runeInboundFee.assetAmount.amount().times(3).gt(params.rune.assetAmount.amount()))
                     errors.push(`Rune amount is less than fees`);
             }
-            const totalFees = (yield this.convert(assetInboundFee, xchainThorchain.AssetRuneNative)).plus(runeInboundFee);
+            const totalFees = (yield this.convert(assetInboundFee, AssetRuneNative)).plus(runeInboundFee);
             const slip = getSlipOnLiquidity({ asset: params.asset, rune: params.rune }, assetPool);
             const estimateLP = {
                 assetPool: assetPool.pool.asset,
@@ -2064,9 +2099,9 @@ class ThorchainQuery {
             }
             const allInboundDetails = yield this.thorchainCache.getInboundDetails();
             const inboundDetails = allInboundDetails[params.asset.chain];
-            const runeInbound = calcNetworkFee(xchainThorchain.AssetRuneNative, inboundDetails);
+            const runeInbound = calcNetworkFee(AssetRuneNative, inboundDetails);
             const assetInbound = calcNetworkFee(params.asset, inboundDetails);
-            const runeOutbound = calcOutboundFee(xchainThorchain.AssetRuneNative, inboundDetails);
+            const runeOutbound = calcOutboundFee(AssetRuneNative, inboundDetails);
             const assetOutbound = calcOutboundFee(params.asset, inboundDetails);
             const estimateLP = {
                 assetAddress: memberDetail.position.asset_address,
@@ -2076,18 +2111,18 @@ class ThorchainQuery {
                     minToSend: {
                         rune: dustValues.rune,
                         asset: dustValues.asset,
-                        total: (yield this.convert(dustValues.asset, xchainThorchain.AssetRuneNative)).plus(dustValues.rune),
+                        total: (yield this.convert(dustValues.asset, AssetRuneNative)).plus(dustValues.rune),
                     },
                     fees: {
                         rune: runeInbound,
                         asset: assetInbound,
-                        total: (yield this.convert(assetInbound, xchainThorchain.AssetRuneNative)).plus(runeInbound),
+                        total: (yield this.convert(assetInbound, AssetRuneNative)).plus(runeInbound),
                     },
                 },
                 outboundFee: {
                     asset: assetOutbound,
                     rune: runeOutbound,
-                    total: (yield this.convert(assetOutbound, xchainThorchain.AssetRuneNative)).plus(runeOutbound),
+                    total: (yield this.convert(assetOutbound, AssetRuneNative)).plus(runeOutbound),
                 },
                 assetAmount: poolShare.assetShare,
                 runeAmount: poolShare.runeShare,
@@ -2110,8 +2145,8 @@ class ThorchainQuery {
             switch (asset.chain) {
                 case 'BNB':
                     dustValues = {
-                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.000001)), xchainBinance.AssetBNB),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.000001)), AssetBNB),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'BTC':
@@ -2120,42 +2155,56 @@ class ThorchainQuery {
                     // 10k sats
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.0001)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'ETH':
                     // 0 wei
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'THOR':
                     // 0 Rune
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'GAIA':
                     // 0 GAIA
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'DOGE':
                     // 1 million sats
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.01)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'AVAX':
                     // 0 AVAX
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'BSC':
+                    // 0 BSC
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'MAYA':
+                    // 0 MAYA
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 default:
@@ -2231,7 +2280,7 @@ class ThorchainQuery {
      */
     estimateWithdrawSaver(withdrawParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (xchainThorchain.isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
+            if (isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
                 throw Error(`Native Rune and synth assets are not supported only L1's`);
             const withdrawQuote = yield this.thorchainCache.thornode.getSaversWithdrawQuote(withdrawParams);
             if (!withdrawQuote.expected_amount_out)
@@ -2414,11 +2463,11 @@ class TransactionStage {
                 //const assetIn = assetFromStringEx(txData.tx.tx.coins?.[0].asset)
                 const swapStatus = ((_b = txData.out_txs[0].memo) === null || _b === void 0 ? void 0 : _b.match('OUT')) ? exports.SwapStatus.Complete : exports.SwapStatus.Complete_Refunded;
                 // current height of thorchain, neeed for confirmations
-                const chainHeight = yield this.blockHeight(xchainThorchain.AssetRuneNative);
+                const chainHeight = yield this.blockHeight(AssetRuneNative);
                 // expected outbound height
                 const outboundHeight = Number((_c = txData.outbound_height) !== null && _c !== void 0 ? _c : txData.finalised_height);
                 const expectedOutBlock = Number((_d = txData.outbound_height) !== null && _d !== void 0 ? _d : txData.finalised_height);
-                const expectedOutDate = yield this.blockToDate(xchainThorchain.THORChain, txData, outboundHeight); // height held in the scheduled queue
+                const expectedOutDate = yield this.blockToDate(THORChain, txData, outboundHeight); // height held in the scheduled queue
                 const confirmations = chainHeight > outboundHeight ? chainHeight - outboundHeight : 0;
                 const minimumAmountOut = memoFields.limit
                     ? yield this.getCryptoAmount(memoFields.limit, assetOut)
@@ -2454,7 +2503,7 @@ class TransactionStage {
     }
     getCryptoAmount(baseAmt, asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            const decimals = xchainThorchain.THORChain === asset.chain ? 8 : Number((yield this.thorchainCache.getPoolForAsset(asset)).pool.nativeDecimal);
+            const decimals = THORChain === asset.chain ? 8 : Number((yield this.thorchainCache.getPoolForAsset(asset)).pool.nativeDecimal);
             return new CryptoAmount(xchainUtil.baseAmount(baseAmt, decimals), asset);
         });
     }
@@ -2471,8 +2520,8 @@ class TransactionStage {
                 const assetIn = xchainUtil.assetFromStringEx((_b = txData.tx.tx.coins) === null || _b === void 0 ? void 0 : _b[0].asset);
                 const inboundAmount = (_c = txData.tx.tx.coins) === null || _c === void 0 ? void 0 : _c[0].amount;
                 const fromAddress = (_d = txData.tx.tx.from_address) !== null && _d !== void 0 ? _d : 'unknkown';
-                const block = txData.tx.tx.chain == xchainThorchain.THORChain ? Number(txData.finalised_height) : Number(txData.tx.block_height);
-                const finalizeBlock = txData.tx.tx.chain == xchainThorchain.THORChain ? Number(txData.finalised_height) : Number(txData.tx.finalise_height);
+                const block = txData.tx.tx.chain == THORChain ? Number(txData.finalised_height) : Number(txData.tx.block_height);
+                const finalizeBlock = txData.tx.tx.chain == THORChain ? Number(txData.finalised_height) : Number(txData.tx.finalise_height);
                 const status = txData.tx.status === 'done' ? exports.InboundStatus.Observed_Consensus : exports.InboundStatus.Observed_Incomplete;
                 if (operation.match(/swap|s|=/gi))
                     progress.txType = exports.TxType.Swap;
@@ -2490,9 +2539,9 @@ class TransactionStage {
                     progress.txType = exports.TxType.Other;
                 const amount = yield this.getCryptoAmount(inboundAmount, assetIn);
                 // find a date for when it should be competed
-                const dateObserved = yield this.blockToDate(xchainThorchain.THORChain, txData);
-                const expectedConfirmationDate = txData.tx.tx.chain === xchainThorchain.THORChain
-                    ? yield this.blockToDate(xchainThorchain.THORChain, txData)
+                const dateObserved = yield this.blockToDate(THORChain, txData);
+                const expectedConfirmationDate = txData.tx.tx.chain === THORChain
+                    ? yield this.blockToDate(THORChain, txData)
                     : yield this.blockToDate(assetIn.chain, txData);
                 progress.inboundObserved = {
                     status,
@@ -2516,8 +2565,8 @@ class TransactionStage {
                 const memoFields = this.parseAddLpMemo(memo);
                 const asset = xchainUtil.assetFromStringEx(memoFields.asset);
                 const isSymmetric = memoFields.pairedAddress ? true : false;
-                const assetTx = !xchainThorchain.isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
-                const runeTx = xchainThorchain.isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                const assetTx = !isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                const runeTx = isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
                 const pairedAssetExpectedConfirmationDate = assetTx ? yield this.blockToDate(asset.chain, txData) : undefined;
                 const checkLpPosition = yield this.thorchainCache.thornode.getLiquidityProvider(memoFields.asset, progress.inboundObserved.fromAddress);
                 const status = checkLpPosition ? exports.AddLpStatus.Complete : exports.AddLpStatus.Incomplete;
@@ -2544,14 +2593,14 @@ class TransactionStage {
                 const currentHeight = lastBlockObj.find((obj) => obj);
                 // find the date in which the asset should be seen in the wallet
                 const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
-                const expectedConfirmationDate = yield this.blockToDate(xchainThorchain.THORChain, txData, outboundHeight); // always pass in thorchain
+                const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
                 // if the TC has process the block that the outbound tx was assigned to then its completed.
                 const status = txData.tx.status === 'done' ? exports.WithdrawStatus.Complete : exports.WithdrawStatus.Incomplete;
                 const outAmount = status === exports.WithdrawStatus.Complete ? JSON.stringify(txData.out_txs).split(`"amount":"`)[1].split(`"`) : '';
                 const outboundBlock = Number((_b = txData.outbound_height) !== null && _b !== void 0 ? _b : txData.finalised_height);
                 const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
                 const estimatedWaitTime = outboundBlock > currentTCHeight
-                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs
+                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs
                     : 0;
                 const withdrawalAmount = yield this.getCryptoAmount(outAmount[0], asset);
                 const withdrawLpInfo = {
@@ -2569,7 +2618,7 @@ class TransactionStage {
     checkAddSaverProgress(txData, progress) {
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
-                const assetTx = !xchainThorchain.isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                const assetTx = !isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
                 const checkSaverVaults = yield this.thorchainCache.thornode.getSaver(txData.tx.tx.coins[0].asset, `${assetTx === null || assetTx === void 0 ? void 0 : assetTx.fromAddress}`);
                 const status = checkSaverVaults ? exports.AddSaverStatus.Complete : exports.AddSaverStatus.Incomplete;
                 const addSaverInfo = {
@@ -2592,13 +2641,13 @@ class TransactionStage {
                 const currentHeight = lastBlockObj.find((obj) => obj);
                 // find the date in which the asset should be seen in the wallet
                 const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
-                const expectedConfirmationDate = yield this.blockToDate(xchainThorchain.THORChain, txData, outboundHeight); // always pass in thorchain
+                const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
                 const outAmount = txData.out_txs ? JSON.stringify(txData.out_txs).split(`"amount":"`)[1].split(`"`) : '';
                 const outboundBlock = Number(txData.outbound_height);
                 const finalisedHeight = Number(txData.finalised_height);
                 const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
                 const estimatedWaitTime = outboundBlock > currentTCHeight
-                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs +
+                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs +
                         this.chainAttributes[asset.chain].avgBlockTimeInSecs
                     : 0;
                 // if the TC has process the block that the outbound tx was assigned to then its completed.
@@ -2623,7 +2672,7 @@ class TransactionStage {
                 const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
                 // find the date in which the asset should be seen in the wallet
                 const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
-                const expectedConfirmationDate = yield this.blockToDate(xchainThorchain.THORChain, txData, outboundHeight); // always pass in thorchain
+                const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
                 const amount = txData.tx.tx.coins[0].amount;
                 const asset = xchainUtil.assetFromStringEx(txData.tx.tx.coins[0].asset);
                 const toAddress = `${txData.tx.tx.to_address}`;
@@ -2633,7 +2682,7 @@ class TransactionStage {
                 const finalisedHeight = Number(txData.finalised_height);
                 const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
                 const estimatedWaitTime = outboundBlock > currentTCHeight
-                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs +
+                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs +
                         this.chainAttributes[asset.chain].avgBlockTimeInSecs
                     : 0;
                 // if the TC has process the block that the outbound tx was assigned to then its completed.
@@ -2705,7 +2754,7 @@ class TransactionStage {
                 }
             }
             // find out how long ago it was processed for all chains
-            if (chain == xchainThorchain.THORChain) {
+            if (chain == THORChain) {
                 const currentHeight = lastBlockObj.find((obj) => obj);
                 const thorchainHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`); // current height of the TC
                 const finalisedHeight = Number(`${txData.finalised_height}`); // height tx was completed in
@@ -2730,7 +2779,7 @@ class TransactionStage {
             const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
             const currentHeight = lastBlockObj.find((obj) => obj.chain == asset.chain);
             let blockHeight;
-            if (asset.chain === xchainThorchain.THORChain || asset.synth) {
+            if (asset.chain === THORChain || asset.synth) {
                 const currentHeight = lastBlockObj.find((obj) => obj);
                 blockHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
             }
@@ -2742,9 +2791,31 @@ class TransactionStage {
     }
 }
 
+exports.AVAXChain = AVAXChain;
+exports.AssetATOM = AssetATOM;
+exports.AssetAVAX = AssetAVAX;
+exports.AssetBCH = AssetBCH;
+exports.AssetBNB = AssetBNB;
+exports.AssetBSC = AssetBSC;
+exports.AssetBTC = AssetBTC;
+exports.AssetDOGE = AssetDOGE;
+exports.AssetETH = AssetETH;
+exports.AssetLTC = AssetLTC;
+exports.AssetMAYA = AssetMAYA;
+exports.AssetRuneNative = AssetRuneNative;
+exports.BCHChain = BCHChain;
+exports.BNBChain = BNBChain;
+exports.BSCChain = BSCChain;
+exports.BTCChain = BTCChain;
 exports.CryptoAmount = CryptoAmount;
+exports.DOGEChain = DOGEChain;
+exports.ETHChain = ETHChain;
+exports.GAIAChain = GAIAChain;
+exports.LTCChain = LTCChain;
 exports.LiquidityPool = LiquidityPool;
+exports.MAYAChain = MAYAChain;
 exports.Midgard = Midgard;
+exports.THORChain = THORChain;
 exports.ThorchainCache = ThorchainCache;
 exports.ThorchainQuery = ThorchainQuery;
 exports.Thornode = Thornode;
@@ -2756,3 +2827,4 @@ exports.getLiquidityUnits = getLiquidityUnits;
 exports.getPoolShare = getPoolShare;
 exports.getSingleSwap = getSingleSwap;
 exports.getSlipOnLiquidity = getSlipOnLiquidity;
+exports.isAssetRuneNative = isAssetRuneNative;