@xchainjs/xchain-thorchain-query 0.1.0 → 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 { 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, AssetRuneNative } from '@xchainjs/xchain-util/lib';
+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;
 });
@@ -415,23 +311,23 @@ const getDoubleSwap = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(v
  */
 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(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
         case Chain.BitcoinCash:
-            return new CryptoAmount(baseAmount$1(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
         case Chain.Litecoin:
-            return new CryptoAmount(baseAmount$1(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), 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(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
+            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
         case Chain.Binance:
             //flat fee
-            return new CryptoAmount(baseAmount$1(inbound.gasRate), AssetBNB);
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetBNB);
         case Chain.Ethereum:
             const gasRateinETHGwei = inbound.gasRate;
-            const gasRateinETHWei = baseAmount$1(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
+            const gasRateinETHWei = baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetETH)) {
                 return new CryptoAmount(gasRateinETHWei.times(21000), AssetETH);
             }
@@ -440,19 +336,17 @@ const calcNetworkFee = (asset, inbound) => {
             }
         case Chain.Avalanche:
             const gasRateinAVAXGwei = inbound.gasRate;
-            const gasRateinAVAXWei = baseAmount$1(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
+            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(inbound.gasRate), AssetLUNA);
         case Chain.Cosmos:
-            return new CryptoAmount(baseAmount$1(inbound.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,
@@ -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 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$1(destinationInboundDetails.outboundFee), params.destinationAsset);
+            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,18 +1105,18 @@ 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 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]);
                 if (assetInboundFee.assetAmount.amount().times(3).gt(params.asset.assetAmount.amount()))
@@ -1151,12 +1127,13 @@ 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, 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());
     }
@@ -1651,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}`,
@@ -1855,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) {

package/lib/index.js

@@ -70,10 +70,6 @@ const DefaultChainAttributes = {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
     },
-    TERRA: {
-        blockReward: 0,
-        avgBlockTimeInSecs: 0,
-    },
     BNB: {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
@@ -185,107 +181,7 @@ class CryptoAmount {
     TxStage[TxStage["OUTBOUND_QUEUED"] = 3] = "OUTBOUND_QUEUED";
     TxStage[TxStage["OUTBOUND_CHAIN_UNCONFIRMED"] = 4] = "OUTBOUND_CHAIN_UNCONFIRMED";
     TxStage[TxStage["OUTBOUND_CHAIN_CONFIRMED"] = 5] = "OUTBOUND_CHAIN_CONFIRMED";
-})(exports.TxStage || (exports.TxStage = {}));
-// 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_js.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(lib.baseAmount(asset), pool.asset),
-        runeShare: new CryptoAmount(lib.baseAmount(rune), lib.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(lib.baseAmount(result), lib.AssetRuneNative),
-        totalDays: (protectionProgress * 100).toFixed(2),
-    };
-    return ILProtection;
-};
+})(exports.TxStage || (exports.TxStage = {}));
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
@@ -455,8 +351,6 @@ const calcNetworkFee = (asset, inbound) => {
             else {
                 return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainUtil.AssetAVAX);
             }
-        case xchainUtil.Chain.Terra:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainUtil.AssetLUNA);
         case xchainUtil.Chain.Cosmos:
             return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainUtil.AssetAtom);
         case xchainUtil.Chain.THORChain:
@@ -487,8 +381,6 @@ const getChainAsset = (chain) => {
             return xchainUtil.AssetLTC;
         case xchainUtil.DOGEChain:
             return xchainUtil.AssetDOGE;
-        case xchainUtil.TerraChain:
-            return xchainUtil.AssetLUNA;
         case xchainUtil.AvalancheChain:
             return xchainUtil.AssetAVAX;
         default:
@@ -518,14 +410,100 @@ const getChain = (chain) => {
             return xchainUtil.LTCChain;
         case 'DOGE':
             return xchainUtil.DOGEChain;
-        case 'TERRA':
-            return xchainUtil.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_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(lib.baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(lib.baseAmount(rune), lib.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, 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(lib.baseAmount(result), lib.AssetRuneNative),
+        totalDays: (protectionProgress * 100).toFixed(2),
+    };
+    return ILProtection;
+};
+
 const BN_1 = new bignumber_js.BigNumber(1);
 /**
  * THORChain Class for interacting with THORChain.
@@ -565,9 +543,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,
@@ -1137,11 +1113,11 @@ class ThorchainQuery {
             if (!xchainUtil.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 lpUnits = getLiquidityUnits({ asset: params.asset, rune: params.rune }, assetPool);
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
             const unitData = {
-                liquidityUnits: xchainUtil.baseAmount(lpUnits),
-                totalUnits: xchainUtil.baseAmount(assetPool.pool.liquidityUnits),
+                liquidityUnits: lpUnits,
+                totalUnits: new bignumber_js.BigNumber(assetPool.pool.liquidityUnits),
             };
             const poolShare = getPoolShare(unitData, assetPool);
             const assetWaitTimeSeconds = yield this.confCounting(params.asset);
@@ -1160,8 +1136,9 @@ class ThorchainQuery {
                     errors.push(`Rune amount is less than fees`);
             }
             const totalFees = (yield this.convert(assetInboundFee, xchainUtil.AssetRuneNative)).plus(runeInboundFee);
-            const slip = getSlipOnLiquidity({ asset: params.asset.baseAmount, rune: params.rune.baseAmount }, assetPool);
+            const slip = getSlipOnLiquidity({ asset: params.asset, rune: params.rune }, assetPool);
             const estimateLP = {
+                assetPool: assetPool.pool.asset,
                 slipPercent: slip.times(100),
                 poolShare: poolShare,
                 lpUnits: xchainUtil.baseAmount(lpUnits),
@@ -1188,6 +1165,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}`);
@@ -1197,8 +1176,8 @@ class ThorchainQuery {
                 throw Error(`Could not get block data`);
             // Pools total units & Lp's total units
             const unitData = {
-                totalUnits: xchainUtil.baseAmount(poolAsset.pool.liquidityUnits),
-                liquidityUnits: xchainUtil.baseAmount(liquidityProvider.units),
+                totalUnits: new bignumber_js.BigNumber(poolAsset.pool.liquidityUnits),
+                liquidityUnits: new bignumber_js.BigNumber(liquidityProvider.units),
             };
             //console.log(`unit data`, unitData.totalUnits.amount().toNumber(), unitData.liquidityUnits.amount().toNumber())
             const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
@@ -1246,22 +1225,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: xchainUtil.baseAmount(memberDetail.position.units),
-                totalUnits: xchainUtil.baseAmount(assetPool.pool.liquidityUnits),
+                liquidityUnits: new bignumber_js.BigNumber(memberDetail.position.units),
+                totalUnits: new bignumber_js.BigNumber(assetPool.pool.liquidityUnits),
             }, assetPool);
             // calculate total fees
             const totalFees = (yield this.convert(dustValues.asset, xchainUtil.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));
@@ -1277,6 +1255,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,
@@ -1287,6 +1267,7 @@ class ThorchainQuery {
                 runeAmount: poolShare.runeShare,
                 estimatedWaitSeconds: waitTimeSeconds,
                 impermanentLossProtection: memberDetail.impermanentLossProtection,
+                assetPool: assetPool.pool.asset,
             };
             return estimateLP;
         });

package/lib/thorchain-query.d.ts

@@ -146,7 +146,7 @@ export declare class ThorchainQuery {
      * @param address - address used for Lp
      * @returns - Type Object liquidityPosition
      */
-    checkLiquidityPosition(asset: Asset, assetOrRuneAddress: string): Promise<LiquidityPosition>;
+    checkLiquidityPosition(asset: Asset, assetOrRuneAddress?: string): Promise<LiquidityPosition>;
     /**
      * Do not send assetNativeRune, There is no pool for it.
      * @param asset - asset required to find the pool

package/lib/types.d.ts

@@ -53,8 +53,8 @@ export declare type SwapOutput = {
     slip: BigNumber;
 };
 export declare type UnitData = {
-    liquidityUnits: BaseAmount;
-    totalUnits: BaseAmount;
+    liquidityUnits: BigNumber;
+    totalUnits: BigNumber;
 };
 export declare type LiquidityData = {
     rune: CryptoAmount;
@@ -114,8 +114,8 @@ export declare type TxStatus = {
     seconds: number;
 };
 export declare type LiquidityToAdd = {
-    asset: BaseAmount;
-    rune: BaseAmount;
+    asset: CryptoAmount;
+    rune: CryptoAmount;
 };
 export declare type PostionDepositValue = {
     asset: BaseAmount;
@@ -126,6 +126,7 @@ export declare type PoolShareDetail = {
     runeShare: CryptoAmount;
 };
 export declare type EstimateAddLP = {
+    assetPool: string;
     slipPercent: BigNumber;
     poolShare: PoolShareDetail;
     lpUnits: BaseAmount;
@@ -136,12 +137,15 @@ export declare type EstimateAddLP = {
     canAdd: boolean;
 };
 export declare type EstimateWithdrawLP = {
+    assetAddress?: string;
+    runeAddress?: string;
     slipPercent: BigNumber;
     transactionFee: LPFees;
     assetAmount: CryptoAmount;
     runeAmount: CryptoAmount;
     impermanentLossProtection: ILProtectionData;
     estimatedWaitSeconds: number;
+    assetPool: string;
 };
 export declare type LPFees = {
     runeFee: CryptoAmount;

package/lib/utils/swap.d.ts

@@ -4,6 +4,7 @@ import { CryptoAmount } from '../crypto-amount';
 import { LiquidityPool } from '../liquidity-pool';
 import { ThorchainCache } from '../thorchain-cache';
 import { InboundDetail, SwapOutput } from '../types';
+export declare const getBaseAmountWithDiffDecimals: (inputAmount: CryptoAmount, outDecimals: number) => BigNumber;
 /**
  *
  * @param inputAmount - amount to swap

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-query",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "description": "Thorchain query module that is resposible for estimating swap calculations and add/remove liquidity for thorchain ",
   "keywords": [
@@ -33,20 +33,20 @@
     "postversion": "git push --follow-tags"
   },
   "devDependencies": {
-    "@xchainjs/xchain-client": "^0.13.1",
+    "@xchainjs/xchain-client": "^0.13.2",
     "@xchainjs/xchain-midgard": "^0.1.0",
     "@xchainjs/xchain-thornode": "^0.1.0",
-    "@xchainjs/xchain-util": "^0.10.0",
+    "@xchainjs/xchain-util": "^0.11.0",
     "axios": "^0.25.0",
     "axios-retry": "^3.2.5",
     "bignumber.js": "^9.0.0",
     "rimraf": "~3.0.2"
   },
   "peerDependencies": {
-    "@xchainjs/xchain-client": "^0.13.1",
+    "@xchainjs/xchain-client": "^0.13.2",
     "@xchainjs/xchain-midgard": "^0.1.0",
     "@xchainjs/xchain-thornode": "^0.1.0",
-    "@xchainjs/xchain-util": "^0.10.0",
+    "@xchainjs/xchain-util": "^0.11.0",
     "axios": "^0.25.0",
     "axios-retry": "^3.2.5",
     "bignumber.js": "^9.0.0",