@xchainjs/xchain-thorchain-query 0.1.0-beta2 → 0.1.2

package/lib/index.esm.js

@@ -1,7 +1,7 @@
 import { ObservedTxStatusEnum, TransactionsApi, Configuration as Configuration$1, QueueApi, NetworkApi, PoolsApi, LiquidityProvidersApi } from '@xchainjs/xchain-thornode';
-import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, baseAmount as baseAmount$1, AssetRuneNative as AssetRuneNative$1, Chain, AssetAtom, AssetLUNA, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, TerraChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, isAssetRuneNative, assetFromString, assetAmount, assetFromStringEx } from '@xchainjs/xchain-util';
-import BigNumber$1, { BigNumber } from 'bignumber.js';
-import { baseAmount, AssetRuneNative } from '@xchainjs/xchain-util/lib';
+import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, baseAmount, AssetRuneNative, Chain, AssetAtom, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, isAssetRuneNative, assetFromString, assetAmount, assetFromStringEx } from '@xchainjs/xchain-util';
+import { BigNumber } from 'bignumber.js';
+import { baseAmount as baseAmount$1, AssetRuneNative as AssetRuneNative$1 } from '@xchainjs/xchain-util/lib';
 import { Network } from '@xchainjs/xchain-client';
 import { MidgardApi, Configuration } from '@xchainjs/xchain-midgard';
 import axios from 'axios';
@@ -61,10 +61,6 @@ const DefaultChainAttributes = {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
     },
-    TERRA: {
-        blockReward: 0,
-        avgBlockTimeInSecs: 0,
-    },
     BNB: {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
@@ -177,114 +173,14 @@ var TxStage;
     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";
-})(TxStage || (TxStage = {}));
-// export type LiquidityProvider = {
-//   asset: string
-//   rune_address: string
-//   asset_address: string
-//   last_add_height: number
-//   last_withdraw_height: number
-//   units: number
-//   pending_rune: number
-//   pending_asset: number
-//   pending_tx_Id: string
-//   rune_deposit_value: number
-//   asset_deposit_value: number
-// }
-
-/**
- * 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 P = new BigNumber(pool.pool.liquidityUnits);
-    const r = liquidity.rune.amount();
-    const a = liquidity.asset.amount();
-    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.amount();
-    const total = unitData.totalUnits.amount();
-    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(baseAmount(asset), pool.asset),
-        runeShare: new CryptoAmount(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) => {
-    // formula: (t * R - T * r)/ (T*r + R*T)
-    const r = stake.rune.amount();
-    const t = stake.asset.amount();
-    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 protectionProgress = (currentHeight - heightLastAdded) / blocksforfullprotection; // percentage of entitlement
-    const result = coverage.times(protectionProgress); // impermanent loss protection result
-    const ILProtection = {
-        ILProtection: new CryptoAmount(baseAmount(result), AssetRuneNative),
-        totalDays: (protectionProgress * 100).toFixed(2),
-    };
-    return ILProtection;
-};
+})(TxStage || (TxStage = {}));
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
     let baseAmountOut = inputAmount.baseAmount.amount();
     const adjustDecimals = outDecimals - inDecimals;
     baseAmountOut = baseAmountOut.times(Math.pow(10, adjustDecimals));
-    return baseAmount$1(baseAmountOut, outDecimals).amount();
+    return baseAmount(baseAmountOut, outDecimals).amount();
 };
 /**
  *
@@ -299,14 +195,14 @@ 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 ? AssetRuneNative$1 : 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);
-    const eightDecimalResult = new CryptoAmount(baseAmount$1(result), units);
+    const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
     const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
-    const swapFee = new CryptoAmount(baseAmount$1(baseOut, decimals), units);
+    const swapFee = new CryptoAmount(baseAmount(baseOut, decimals), units);
     //console.log(` swapFee ${swapFee.assetAmountFixedString()} `)
     return swapFee;
 };
@@ -337,15 +233,15 @@ 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 ? AssetRuneNative$1 : 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);
     const result = numerator.div(denominator);
-    const eightDecimalResult = new CryptoAmount(baseAmount$1(result), units);
+    const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
     const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
-    return new CryptoAmount(baseAmount$1(baseOut, decimals), units);
+    return new CryptoAmount(baseAmount(baseOut, decimals), units);
 };
 const getDoubleSwapOutput = (inputAmount, pool1, pool2) => {
     // formula: getSwapOutput(pool1) => getSwapOutput(pool2)
@@ -382,7 +278,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, AssetRuneNative$1);
+    const fee2InRune = yield thorchainCache.convert(fee2InAsset, AssetRuneNative);
     const result = fee1InRune.plus(fee2InRune);
     return result;
 });
@@ -413,25 +309,25 @@ const getDoubleSwap = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(v
  * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
  * @returns
  */
-const calcNetworkFee = (asset, gasRate) => {
+const calcNetworkFee = (asset, inbound) => {
     if (asset.synth)
-        return new CryptoAmount(baseAmount$1(2000000), AssetRuneNative$1);
+        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     switch (asset.chain) {
         case Chain.Bitcoin:
-            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(1000)), AssetBTC);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
         case Chain.BitcoinCash:
-            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(1500)), AssetBCH);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
         case Chain.Litecoin:
-            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(250)), AssetLTC);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetLTC);
         case Chain.Doge:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(1000)), AssetDOGE);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
         case Chain.Binance:
             //flat fee
-            return new CryptoAmount(baseAmount$1(gasRate), AssetBNB);
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetBNB);
         case Chain.Ethereum:
-            const gasRateinETHGwei = gasRate;
-            const gasRateinETHWei = baseAmount$1(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
+            const gasRateinETHGwei = inbound.gasRate;
+            const gasRateinETHWei = baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetETH)) {
                 return new CryptoAmount(gasRateinETHWei.times(21000), AssetETH);
             }
@@ -439,20 +335,18 @@ const calcNetworkFee = (asset, gasRate) => {
                 return new CryptoAmount(gasRateinETHWei.times(70000), AssetETH);
             }
         case Chain.Avalanche:
-            const gasRateinAVAXGwei = gasRate;
-            const gasRateinAVAXWei = baseAmount$1(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
+            const gasRateinAVAXGwei = inbound.gasRate;
+            const gasRateinAVAXWei = baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetAVAX)) {
                 return new CryptoAmount(gasRateinAVAXWei.times(21000), AssetAVAX);
             }
             else {
                 return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
             }
-        case Chain.Terra:
-            return new CryptoAmount(baseAmount$1(gasRate), AssetLUNA);
         case Chain.Cosmos:
-            return new CryptoAmount(baseAmount$1(gasRate), AssetAtom);
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetAtom);
         case Chain.THORChain:
-            return new CryptoAmount(baseAmount$1(2000000), AssetRuneNative$1);
+            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
@@ -470,7 +364,7 @@ const getChainAsset = (chain) => {
         case ETHChain:
             return AssetETH;
         case THORChain:
-            return AssetRuneNative$1;
+            return AssetRuneNative;
         case CosmosChain:
             return AssetAtom;
         case BCHChain:
@@ -479,8 +373,6 @@ const getChainAsset = (chain) => {
             return AssetLTC;
         case DOGEChain:
             return AssetDOGE;
-        case TerraChain:
-            return AssetLUNA;
         case AvalancheChain:
             return AssetAVAX;
         default:
@@ -510,14 +402,100 @@ const getChain = (chain) => {
             return LTCChain;
         case 'DOGE':
             return DOGEChain;
-        case 'TERRA':
-            return TerraChain;
         default:
             throw Error('Unknown chain');
     }
 };
 
-// import { Network } from '@xchainjs/xchain-client'
+/**
+ * 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(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(baseAmount$1(asset), pool.asset),
+        runeShare: new CryptoAmount(baseAmount$1(rune), AssetRuneNative$1),
+    };
+    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, pool.decimals);
+    // 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 protectionProgress = (currentHeight - heightLastAdded) / blocksforfullprotection; // percentage of entitlement
+    const result = coverage.times(protectionProgress); // impermanent loss protection result
+    const ILProtection = {
+        ILProtection: new CryptoAmount(baseAmount$1(result), AssetRuneNative$1),
+        totalDays: (protectionProgress * 100).toFixed(2),
+    };
+    return ILProtection;
+};
+
 const BN_1 = new BigNumber(1);
 /**
  * THORChain Class for interacting with THORChain.
@@ -557,9 +535,7 @@ class ThorchainQuery {
             });
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
             const sourceInboundDetails = inboundDetails[input.asset.chain];
-            // console.log(JSON.stringify(sourceInboundDetails, null, 2))
             const destinationInboundDetails = inboundDetails[destinationAsset.chain];
-            // console.log(JSON.stringify(destinationInboundDetails, null, 2))
             const swapEstimate = yield this.calcSwapEstimate({
                 input,
                 destinationAsset,
@@ -598,7 +574,7 @@ class ThorchainQuery {
             else {
                 txDetails.txEstimate.canSwap = true;
                 // Retrieve inbound Asgard address.
-                const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[input.asset.chain];
+                const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[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;
@@ -656,13 +632,13 @@ class ThorchainQuery {
                 ? params.input
                 : yield this.thorchainCache.convert(params.input, params.input.asset);
             // If asset is already rune native, skip the convert
-            const inputInRune = input.asset === AssetRuneNative$1 ? input : yield this.thorchainCache.convert(input, AssetRuneNative$1);
-            const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails.gas_rate);
-            let outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails.gas_rate);
-            outboundFeeInAsset = outboundFeeInAsset.times(3);
+            const inputInRune = input.asset === AssetRuneNative ? input : yield this.thorchainCache.convert(input, AssetRuneNative);
+            const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails);
+            // Retrieve outbound fee from inboundAddressDetails.
+            const outboundFeeInAsset = new CryptoAmount(baseAmount(destinationInboundDetails.outboundFee), params.destinationAsset);
             // convert fees to rune
-            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, AssetRuneNative$1);
-            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, AssetRuneNative$1);
+            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, AssetRuneNative);
+            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, AssetRuneNative);
             // ---------- Remove Fees from inbound before doing the swap -----------
             // TODO confirm with chris about this change, was there a reason why this was commented out?
             const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune);
@@ -678,18 +654,18 @@ class ThorchainQuery {
                 const deepestUSDPOOL = yield this.thorchainCache.getDeepestUSDPool();
                 const usdAsset = deepestUSDPOOL.asset;
                 const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
-                const usdMinFee = new CryptoAmount(baseAmount$1(networkValues['MINIMUML1OUTBOUNDFEEUSD']), usdAsset);
+                const usdMinFee = new CryptoAmount(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, AssetRuneNative$1);
+                    outboundFeeInRune = yield this.convert(newFee, AssetRuneNative);
                 }
             }
             // Now calculate swap output based on inputNetAmount
             const swapOutput = yield this.thorchainCache.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
-            const swapFeeInRune = yield this.thorchainCache.convert(swapOutput.swapFee, AssetRuneNative$1);
-            const outputInRune = yield this.thorchainCache.convert(swapOutput.output, AssetRuneNative$1);
+            const swapFeeInRune = yield this.thorchainCache.convert(swapOutput.swapFee, AssetRuneNative);
+            const outputInRune = yield this.thorchainCache.convert(swapOutput.output, AssetRuneNative);
             // ---------------- Remove Outbound Fee ---------------------- /
             const netOutputInRune = outputInRune.minus(outboundFeeInRune);
             const netOutputInAsset = yield this.thorchainCache.convert(netOutputInRune, params.destinationAsset);
@@ -790,8 +766,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, AssetRuneNative$1);
-            const feesInRune = yield this.getFeesIn(estimate.totalFees, AssetRuneNative$1);
+            const inputInRune = yield this.thorchainCache.convert(params.input, AssetRuneNative);
+            const feesInRune = yield this.getFeesIn(estimate.totalFees, AssetRuneNative);
             const totalSwapFeesInRune = feesInRune.inboundFee
                 .plus(feesInRune.outboundFee)
                 .plus(feesInRune.swapFee)
@@ -878,15 +854,15 @@ class ThorchainQuery {
     outboundDelay(outboundAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const networkValues = yield this.thorchainCache.getNetworkValues();
-            const minTxOutVolumeThreshold = new CryptoAmount(baseAmount$1(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative$1);
+            const minTxOutVolumeThreshold = new CryptoAmount(baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
-            let txOutDelayRate = new CryptoAmount(baseAmount$1(networkValues['TXOUTDELAYRATE']), AssetRuneNative$1).assetAmount
+            let txOutDelayRate = new CryptoAmount(baseAmount(networkValues['TXOUTDELAYRATE']), AssetRuneNative).assetAmount
                 .amount()
                 .toNumber();
             const getScheduledOutboundValue = yield this.thorchainCache.midgard.getScheduledOutboundValue();
             const thorChainblocktime = this.chainAttributes[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, AssetRuneNative$1);
+            const runeValue = yield this.thorchainCache.convert(outboundAmount, AssetRuneNative);
             // Check rune value amount
             if (runeValue.lt(minTxOutVolumeThreshold)) {
                 return thorChainblocktime;
@@ -1129,34 +1105,35 @@ class ThorchainQuery {
             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.baseAmount, rune: params.rune.baseAmount }, assetPool);
-            const inboundDetails = yield this.thorchainCache.midgard.getInboundDetails();
+            const lpUnits = getLiquidityUnits({ asset: params.asset, rune: params.rune }, assetPool);
+            const inboundDetails = yield this.thorchainCache.getInboundDetails();
             const unitData = {
-                liquidityUnits: baseAmount$1(lpUnits),
-                totalUnits: baseAmount$1(assetPool.pool.liquidityUnits),
+                liquidityUnits: lpUnits,
+                totalUnits: new BigNumber(assetPool.pool.liquidityUnits),
             };
             const poolShare = getPoolShare(unitData, assetPool);
             const assetWaitTimeSeconds = yield this.confCounting(params.asset);
             const runeWaitTimeSeconds = yield this.confCounting(params.rune);
             const waitTimeSeconds = assetWaitTimeSeconds > runeWaitTimeSeconds ? assetWaitTimeSeconds : runeWaitTimeSeconds;
-            let assetInboundFee = new CryptoAmount(baseAmount$1(0), params.asset.asset);
-            let runeInboundFee = new CryptoAmount(baseAmount$1(0), AssetRuneNative$1);
+            let assetInboundFee = new CryptoAmount(baseAmount(0), params.asset.asset);
+            let runeInboundFee = new CryptoAmount(baseAmount(0), AssetRuneNative);
             if (!params.asset.assetAmount.eq(0)) {
-                assetInboundFee = calcNetworkFee(params.asset.asset, inboundDetails[params.asset.asset.chain].gas_rate);
+                assetInboundFee = calcNetworkFee(params.asset.asset, inboundDetails[params.asset.asset.chain]);
                 if (assetInboundFee.assetAmount.amount().times(3).gt(params.asset.assetAmount.amount()))
                     errors.push(`Asset amount is less than fees`);
             }
             if (!params.rune.assetAmount.eq(0)) {
-                runeInboundFee = calcNetworkFee(params.rune.asset, inboundDetails[params.rune.asset.chain].gas_rate);
+                runeInboundFee = calcNetworkFee(params.rune.asset, inboundDetails[params.rune.asset.chain]);
                 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, AssetRuneNative$1)).plus(runeInboundFee);
-            const slip = getSlipOnLiquidity({ asset: params.asset.baseAmount, rune: params.rune.baseAmount }, assetPool);
+            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,
                 slipPercent: slip.times(100),
                 poolShare: poolShare,
-                lpUnits: baseAmount$1(lpUnits),
+                lpUnits: baseAmount(lpUnits),
                 runeToAssetRatio: assetPool.runeToAssetRatio,
                 transactionFee: {
                     assetFee: assetInboundFee,
@@ -1180,6 +1157,8 @@ class ThorchainQuery {
             const poolAsset = yield this.thorchainCache.getPoolForAsset(asset);
             if (!poolAsset)
                 throw Error(`Could not find pool for ${asset}`);
+            if (!assetOrRuneAddress)
+                throw Error(`No address provided ${assetOrRuneAddress}`);
             const liquidityProvider = yield this.thorchainCache.thornode.getLiquidityProvider(poolAsset.assetString, assetOrRuneAddress);
             if (!liquidityProvider)
                 throw Error(`Could not find LP for ${assetOrRuneAddress}`);
@@ -1189,8 +1168,8 @@ class ThorchainQuery {
                 throw Error(`Could not get block data`);
             // Pools total units & Lp's total units
             const unitData = {
-                totalUnits: baseAmount$1(poolAsset.pool.liquidityUnits),
-                liquidityUnits: baseAmount$1(liquidityProvider.units),
+                totalUnits: new BigNumber(poolAsset.pool.liquidityUnits),
+                liquidityUnits: new BigNumber(liquidityProvider.units),
             };
             //console.log(`unit data`, unitData.totalUnits.amount().toNumber(), unitData.liquidityUnits.amount().toNumber())
             const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
@@ -1201,8 +1180,8 @@ class ThorchainQuery {
             };
             //
             const currentLP = {
-                asset: baseAmount$1(liquidityProvider.asset_deposit_value),
-                rune: baseAmount$1(liquidityProvider.rune_deposit_value),
+                asset: baseAmount(liquidityProvider.asset_deposit_value),
+                rune: baseAmount(liquidityProvider.rune_deposit_value),
             };
             const poolShare = getPoolShare(unitData, poolAsset);
             // console.log(poolShare.assetShare.toNumber(), poolShare.runeShare.toNumber())
@@ -1238,22 +1217,21 @@ class ThorchainQuery {
     estimateWithdrawLP(params) {
         return __awaiter(this, void 0, void 0, function* () {
             // Caution Dust Limits: BTC,BCH,LTC chains 10k sats; DOGE 1m Sats; ETH 0 wei; THOR 0 RUNE.
-            if (!params.assetAddress)
-                throw Error(`can't estimate lp without an asset address`);
-            const memberDetail = yield this.checkLiquidityPosition(params.asset, params.assetAddress);
+            const assetOrRuneAddress = params.assetAddress ? params.assetAddress : params.runeAddress;
+            const memberDetail = yield this.checkLiquidityPosition(params.asset, assetOrRuneAddress);
             const dustValues = yield this.getDustValues(params.asset); // returns asset and rune dust values
             const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset);
             // get pool share from unit data
             const poolShare = getPoolShare({
-                liquidityUnits: baseAmount$1(memberDetail.position.units),
-                totalUnits: baseAmount$1(assetPool.pool.liquidityUnits),
+                liquidityUnits: new BigNumber(memberDetail.position.units),
+                totalUnits: new BigNumber(assetPool.pool.liquidityUnits),
             }, assetPool);
             // calculate total fees
-            const totalFees = (yield this.convert(dustValues.asset, AssetRuneNative$1)).plus(dustValues.rune);
+            const totalFees = (yield this.convert(dustValues.asset, AssetRuneNative)).plus(dustValues.rune);
             // get slip on liquidity removal
             const slip = getSlipOnLiquidity({
-                asset: poolShare.assetShare.baseAmount,
-                rune: poolShare.runeShare.baseAmount,
+                asset: poolShare.assetShare,
+                rune: poolShare.runeShare,
             }, assetPool);
             // TODO make sure we compare wait times for withdrawing both rune and asset OR just rune OR just asset
             const waitTimeSecondsForAsset = yield this.confCounting(poolShare.assetShare.div(params.percentage / 100));
@@ -1269,6 +1247,8 @@ class ThorchainQuery {
                 waitTimeSeconds = waitTimeSecondsForRune;
             }
             const estimateLP = {
+                assetAddress: memberDetail.position.asset_address,
+                runeAddress: memberDetail.position.rune_address,
                 slipPercent: slip.times(100),
                 transactionFee: {
                     assetFee: dustValues.asset,
@@ -1279,6 +1259,7 @@ class ThorchainQuery {
                 runeAmount: poolShare.runeShare,
                 estimatedWaitSeconds: waitTimeSeconds,
                 impermanentLossProtection: memberDetail.impermanentLossProtection,
+                assetPool: assetPool.pool.asset,
             };
             return estimateLP;
         });
@@ -1295,42 +1276,42 @@ class ThorchainQuery {
                 case 'BNB':
                     dustValues = {
                         asset: new CryptoAmount(assetToBase(assetAmount(0.000001)), AssetBNB),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'BTC'  :
                     // 10k sats
                     dustValues = {
                         asset: new CryptoAmount(assetToBase(assetAmount(0.0001)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'ETH':
                     // 0 wei
                     dustValues = {
                         asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'THOR':
                     // 0 Rune
                     dustValues = {
                         asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'GAIA':
                     // 0 GAIA
                     dustValues = {
                         asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 case 'DOGE':
                     // 1 million sats
                     dustValues = {
                         asset: new CryptoAmount(assetToBase(assetAmount(0.01)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
                 default:
@@ -1352,8 +1333,8 @@ class LiquidityPool {
         this.asset = asset;
         this.decimals = decimals;
         this.assetString = this.pool.asset;
-        this.assetBalance = baseAmount$1(this.pool.assetDepth);
-        this.runeBalance = baseAmount$1(this.pool.runeDepth);
+        this.assetBalance = baseAmount(this.pool.assetDepth);
+        this.runeBalance = baseAmount(this.pool.runeDepth);
         this.runeToAssetRatio = this.runeBalance.amount().div(this.assetBalance.amount());
         this.assetToRuneRatio = this.assetBalance.amount().div(this.runeBalance.amount());
     }
@@ -1515,15 +1496,17 @@ class ThorchainCache {
      */
     refereshAsgardCache() {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAddressesItems = yield this.midgard.getAllInboundAddresses();
+            const inboundAddresses = yield this.thornode.getInboundAddresses();
             const map = {};
-            if (inboundAddressesItems) {
-                for (const inboundAddress of inboundAddressesItems) {
+            if (inboundAddresses) {
+                for (const inboundAddress of inboundAddresses) {
+                    if (!inboundAddress.chain)
+                        throw Error('chain needed');
                     map[inboundAddress.chain] = inboundAddress;
                 }
                 this.asgardAssetsCache = {
                     lastRefreshed: Date.now(),
-                    inboundAddressesItems: map,
+                    inboundAddresses: map,
                 };
             }
         });
@@ -1536,7 +1519,49 @@ class ThorchainCache {
      */
     refereshInboundDetailCache() {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundDetails = yield this.midgard.getInboundDetails();
+            const [mimirDetails, allInboundAddresses] = yield Promise.all([
+                this.midgard.getMimirDetails(),
+                this.thornode.getInboundAddresses(),
+            ]);
+            const inboundDetails = {};
+            for (const inbound of allInboundAddresses) {
+                const chain = inbound.chain;
+                if (!chain ||
+                    !inbound.gas_rate ||
+                    !inbound.address ||
+                    !inbound.gas_rate_units ||
+                    !inbound.outbound_tx_size ||
+                    !inbound.outbound_fee ||
+                    !inbound.gas_rate_units)
+                    throw new Error(`Missing required inbound info`);
+                const details = {
+                    chain: chain,
+                    address: inbound.address,
+                    router: inbound.router,
+                    gasRate: new BigNumber(inbound.gas_rate),
+                    gasRateUnits: inbound.gas_rate_units,
+                    outboundTxSize: new BigNumber(inbound.outbound_tx_size),
+                    outboundFee: new BigNumber(inbound.outbound_fee),
+                    haltedChain: (inbound === null || inbound === void 0 ? void 0 : inbound.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 = {
+                chain: Chain.THORChain,
+                address: '',
+                router: '',
+                gasRate: new BigNumber(0),
+                gasRateUnits: '',
+                outboundTxSize: new BigNumber(0),
+                outboundFee: new BigNumber(0),
+                haltedChain: false,
+                haltedTrading: !!mimirDetails['HALTTRADING'],
+                haltedLP: false, //
+            };
+            inboundDetails[Chain.THORChain] = details;
             this.inboundDetailCache = {
                 lastRefreshed: Date.now(),
                 inboundDetails,
@@ -1607,7 +1632,7 @@ class ThorchainCache {
             let baseAmountOut = input.baseAmount.times(exchangeRate).amount();
             const adjustDecimals = outDecimals - inDecimals;
             baseAmountOut = baseAmountOut.times(Math.pow(10, adjustDecimals));
-            const amt = baseAmount$1(baseAmountOut, outDecimals);
+            const amt = baseAmount(baseAmountOut, outDecimals);
             const result = new CryptoAmount(amt, outAsset);
             // console.log(
             //   `${input.formatedAssetString()} ${input.asset.ticker} = ${result.formatedAssetString()} ${outAsset.ticker}`,
@@ -1627,7 +1652,7 @@ class ThorchainCache {
     }
     getRouterAddressForChain(chain) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.getInboundAddressesItems())[chain];
+            const inboundAsgard = (yield this.getInboundAddresses())[chain];
             if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
                 throw new Error('router address is not defined');
             }
@@ -1638,7 +1663,7 @@ class ThorchainCache {
      *
      * @returns - inbound adresses item
      */
-    getInboundAddressesItems() {
+    getInboundAddresses() {
         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);
@@ -1651,7 +1676,7 @@ class ThorchainCache {
                 }
             }
             if (this.asgardAssetsCache) {
-                return this.asgardAssetsCache.inboundAddressesItems;
+                return this.asgardAssetsCache.inboundAddresses;
             }
             else {
                 throw Error(`Could not refresh refereshAsgardCache `);
@@ -1782,52 +1807,6 @@ class Midgard {
             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$1(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$1(0),
-                haltedChain: false,
-                haltedTrading: !!mimirDetails['HALTTRADING'],
-                haltedLP: false, //
-            };
-            inboundDetails[Chain.THORChain] = details;
-            return inboundDetails;
-        });
-    }
     /**
      *
      * @returns - constants
@@ -1857,7 +1836,7 @@ class Midgard {
             for (const baseUrl of this.config.midgardBaseUrls) {
                 try {
                     const { data } = yield axios.get(`${baseUrl}${path}`);
-                    const value = new CryptoAmount(baseAmount$1(data['scheduled_outbound_value']), AssetRuneNative$1);
+                    const value = new CryptoAmount(baseAmount(data['scheduled_outbound_value']), AssetRuneNative);
                     return value;
                 }
                 catch (e) {
@@ -2100,6 +2079,27 @@ class Thornode {
             throw new Error(`THORNode not responding`);
         });
     }
+    /**
+     *
+     * @param asset - asset string
+     * @param address - address
+     * @param height - optional block height, defaults to current tip
+     * @returns
+     */
+    getInboundAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.networkApi) {
+                try {
+                    const resp = (yield api.inboundAddresses()).data;
+                    return resp;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error(`THORNode not responding`);
+        });
+    }
 }
 
 export { CryptoAmount, LiquidityPool, Midgard, ThorchainCache, ThorchainQuery, Thornode, TxStage, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity };