@xchainjs/xchain-thorchain-query 0.1.0-alpha1 → 0.1.0-beta

package/lib/crypto-amount.d.ts

@@ -25,8 +25,8 @@ export declare class CryptoAmount {
      * This guard protects against trying to perform math with different assets
      *
      * Example.
-     * const x = new CryptoAmount(baseAmount(1),AssetBTC)
-     * const y = new CryptoAmount(baseAmount(1),AssetETH)
+     * const x = new CryptoAmount(assetAmount(1),AssetBTC)
+     * const y = new CryptoAmount(assetAmount(1),AssetETH)
      *
      * x.plus(y) <- will throw error "cannot perform math on 2 diff assets BTC.BTC ETH.ETH
      *

package/lib/index.esm.js

@@ -1,5 +1,5 @@
 import { ObservedTxStatusEnum, TransactionsApi, Configuration as Configuration$1, QueueApi, NetworkApi, PoolsApi } from '@xchainjs/xchain-thornode';
-import { formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, baseAmount, AssetRuneNative, Chain, AssetAtom, AssetLUNA, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, TerraChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, isAssetRuneNative, assetFromString, assetAmount, assetToBase } from '@xchainjs/xchain-util';
+import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, baseAmount, AssetRuneNative, Chain, AssetAtom, AssetLUNA, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, TerraChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, isAssetRuneNative, assetFromString } from '@xchainjs/xchain-util';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 import { Network } from '@xchainjs/xchain-client';
 import { MidgardApi, Configuration } from '@xchainjs/xchain-midgard';
@@ -85,55 +85,55 @@ class CryptoAmount {
     }
     plus(v) {
         this.check(v);
-        const baseAmountResult = this.baseAmount.plus(v.baseAmount);
-        return new CryptoAmount(baseAmountResult, this.asset);
+        const assetAmountResult = assetToBase(this.assetAmount.plus(v.assetAmount));
+        return new CryptoAmount(assetAmountResult, this.asset);
     }
     minus(v) {
         this.check(v);
-        const baseAmountResult = this.baseAmount.minus(v.baseAmount);
-        return new CryptoAmount(baseAmountResult, this.asset);
+        const assetAmountResult = assetToBase(this.assetAmount.minus(v.assetAmount));
+        return new CryptoAmount(assetAmountResult, this.asset);
     }
     times(v) {
         this.check(v);
         if (v instanceof CryptoAmount) {
-            const baseAmountResult = this.baseAmount.times(v.baseAmount);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = assetToBase(this.assetAmount.times(v.assetAmount));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
         else {
-            const baseAmountResult = this.baseAmount.times(v);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = assetToBase(this.assetAmount.times(v));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
     }
     div(v) {
         this.check(v);
         if (v instanceof CryptoAmount) {
-            const baseAmountResult = this.baseAmount.div(v.baseAmount);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = assetToBase(this.assetAmount.div(v.assetAmount));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
         else {
-            const baseAmountResult = this.baseAmount.div(v);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = assetToBase(this.assetAmount.div(v));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
     }
     lt(v) {
         this.check(v);
-        return this.baseAmount.lt(v.baseAmount);
+        return this.assetAmount.lt(v.assetAmount);
     }
     lte(v) {
         this.check(v);
-        return this.baseAmount.lte(v.baseAmount);
+        return this.assetAmount.lte(v.assetAmount);
     }
     gt(v) {
         this.check(v);
-        return this.baseAmount.gt(v.baseAmount);
+        return this.assetAmount.gt(v.assetAmount);
     }
     gte(v) {
         this.check(v);
-        return this.baseAmount.gte(v.baseAmount);
+        return this.assetAmount.gte(v.assetAmount);
     }
     eq(v) {
         this.check(v);
-        return this.baseAmount.eq(v.baseAmount);
+        return this.assetAmount.eq(v.assetAmount);
     }
     formatedAssetString() {
         return formatAssetAmountCurrency({
@@ -152,8 +152,8 @@ class CryptoAmount {
      * This guard protects against trying to perform math with different assets
      *
      * Example.
-     * const x = new CryptoAmount(baseAmount(1),AssetBTC)
-     * const y = new CryptoAmount(baseAmount(1),AssetETH)
+     * const x = new CryptoAmount(assetAmount(1),AssetBTC)
+     * const y = new CryptoAmount(assetAmount(1),AssetETH)
      *
      * x.plus(y) <- will throw error "cannot perform math on 2 diff assets BTC.BTC ETH.ETH
      *
@@ -178,6 +178,13 @@ var TxStage;
     TxStage[TxStage["OUTBOUND_CHAIN_CONFIRMED"] = 5] = "OUTBOUND_CHAIN_CONFIRMED";
 })(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(baseAmountOut, outDecimals).amount();
+};
 /**
  *
  * @param inputAmount - amount to swap
@@ -188,16 +195,18 @@ var TxStage;
 const getSwapFee = (inputAmount, pool, toRune) => {
     // formula: (x * x * Y) / (x + X) ^ 2
     // const isInputRune = isAssetRuneNative(inputAmount.asset)
-    const x = inputAmount.baseAmount.amount();
+    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 : pool.asset;
-    const decimals = toRune || !pool.decimals ? 8 : pool.decimals;
     const numerator = x.times(x).multipliedBy(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
-    const swapFee = new CryptoAmount(baseAmount(result, decimals), units);
-    // console.log(` swapFee ${swapFee.assetAmountFixedString()} ${assetToString(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(baseOut, decimals), units);
+    //console.log(` swapFee ${swapFee.assetAmountFixedString()} `)
     return swapFee;
 };
 /**
@@ -210,7 +219,7 @@ const getSwapFee = (inputAmount, pool, toRune) => {
  */
 const getSwapSlip = (inputAmount, pool, toRune) => {
     // formula: (x) / (x + X)
-    const x = inputAmount.baseAmount.amount();
+    const x = getBaseAmountWithDiffDecimals(inputAmount, 8);
     const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
     const result = x.div(x.plus(X));
     return new BigNumber(result);
@@ -224,15 +233,18 @@ const getSwapSlip = (inputAmount, pool, toRune) => {
  */
 const getSwapOutput = (inputAmount, pool, toRune) => {
     // formula: (x * X * Y) / (x + X) ^ 2
-    const x = inputAmount.baseAmount.amount();
+    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 : pool.asset;
-    const decimals = toRune || !pool.decimals ? 8 : pool.decimals;
+    // const decimals = toRune || !pool.decimals ? 8 : pool.decimals
     const numerator = x.times(X).times(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
-    return new CryptoAmount(baseAmount(result, decimals), units);
+    const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
+    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
+    return new CryptoAmount(baseAmount(baseOut, decimals), units);
 };
 const getDoubleSwapOutput = (inputAmount, pool1, pool2) => {
     // formula: getSwapOutput(pool1) => getSwapOutput(pool2)
@@ -329,10 +341,10 @@ const calcNetworkFee = (asset, gasRate) => {
             const gasRateinAVAXGwei = gasRate;
             const gasRateinAVAXWei = baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetAVAX)) {
-                return new CryptoAmount(gasRateinAVAXWei.times(21000), AssetETH);
+                return new CryptoAmount(gasRateinAVAXWei.times(21000), AssetAVAX);
             }
             else {
-                return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetETH);
+                return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
             }
         case Chain.Terra:
             return new CryptoAmount(baseAmount(gasRate), AssetLUNA);
@@ -536,18 +548,24 @@ class ThorchainQuery {
      */
     calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails) {
         return __awaiter(this, void 0, void 0, function* () {
-            //NOTE need to convert the asset to 8 decimals places for all calcs
-            const input = yield this.thorchainCache.convert(params.input, params.input.asset);
-            const inputInRune = yield this.thorchainCache.convert(input, AssetRuneNative);
+            // NOTE need to convert the asset to 8 decimals places for all calcs
+            const DEFAULT_THORCHAIN_DECIMALS = 8;
+            // If input is already in 8 decimals skip the convert
+            const input = params.input.baseAmount.decimal === DEFAULT_THORCHAIN_DECIMALS
+                ? 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 ? input : yield this.thorchainCache.convert(input, AssetRuneNative);
             const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails.gas_rate);
             let outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails.gas_rate);
             outboundFeeInAsset = outboundFeeInAsset.times(3);
+            // convert fees to rune
             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
-            // const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune)
-            const inputMinusInboundFeeInRune = inputInRune;
+            // TODO confirm with chris about this change, was there a reason why this was commented out?
+            const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune);
+            //>//const inputMinusInboundFeeInRune = inputInRune
             // remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
             const affiliateFeeInRune = inputMinusInboundFeeInRune.times(params.affiliateFeePercent || 0);
             // remove the affiliate fee from the input.
@@ -567,7 +585,7 @@ class ThorchainQuery {
                     outboundFeeInRune = yield this.convert(newFee, AssetRuneNative);
                 }
             }
-            // Now calculate swapfee based on inputNetAmount
+            // 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);
             const outputInRune = yield this.thorchainCache.convert(swapOutput.output, AssetRuneNative);
@@ -1250,23 +1268,35 @@ class ThorchainCache {
      * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
      *
      * @param input - amount/asset to convert to outAsset
-     * @param ouAsset - the Asset you want to convert to
+     * @param outAsset - the Asset you want to convert to
      * @returns CryptoAmount of input
      */
     convert(input, outAsset) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const exchangeRate = yield this.getExchangeRate(input.asset, outAsset);
-            let decimals = DEFAULT_THORCHAIN_DECIMALS;
-            if (!isAssetRuneNative(outAsset)) {
-                const pool = yield this.getPoolForAsset(outAsset);
-                decimals = (_a = pool.decimals) !== null && _a !== void 0 ? _a : DEFAULT_THORCHAIN_DECIMALS;
-            }
-            const amt = assetAmount(input.assetAmount.times(exchangeRate).amount().toFixed(), decimals);
-            const result = new CryptoAmount(assetToBase(amt), outAsset);
+            const outDecimals = yield this.getDecimalForAsset(outAsset);
+            const inDecimals = input.baseAmount.decimal;
+            let baseAmountOut = input.baseAmount.times(exchangeRate).amount();
+            const adjustDecimals = outDecimals - inDecimals;
+            baseAmountOut = baseAmountOut.times(Math.pow(10, adjustDecimals));
+            const amt = baseAmount(baseAmountOut, outDecimals);
+            const result = new CryptoAmount(amt, outAsset);
+            // console.log(
+            //   `${input.formatedAssetString()} ${input.asset.ticker} = ${result.formatedAssetString()} ${outAsset.ticker}`,
+            // )
             return result;
         });
     }
+    getDecimalForAsset(asset) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isAssetRuneNative(asset)) {
+                const pool = yield this.getPoolForAsset(asset);
+                return (_a = pool.decimals) !== null && _a !== void 0 ? _a : DEFAULT_THORCHAIN_DECIMALS;
+            }
+            return DEFAULT_THORCHAIN_DECIMALS;
+        });
+    }
     getRouterAddressForChain(chain) {
         return __awaiter(this, void 0, void 0, function* () {
             const inboundAsgard = (yield this.getInboundAddressesItems())[chain];
@@ -1723,6 +1753,7 @@ class Thornode {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.poolsApi) {
                 try {
+                    // console.log(console.log(JSON.stringify(api, null, 2)))
                     const pools = yield api.pools();
                     return pools.data;
                 }

package/lib/index.js

@@ -95,55 +95,55 @@ class CryptoAmount {
     }
     plus(v) {
         this.check(v);
-        const baseAmountResult = this.baseAmount.plus(v.baseAmount);
-        return new CryptoAmount(baseAmountResult, this.asset);
+        const assetAmountResult = xchainUtil.assetToBase(this.assetAmount.plus(v.assetAmount));
+        return new CryptoAmount(assetAmountResult, this.asset);
     }
     minus(v) {
         this.check(v);
-        const baseAmountResult = this.baseAmount.minus(v.baseAmount);
-        return new CryptoAmount(baseAmountResult, this.asset);
+        const assetAmountResult = xchainUtil.assetToBase(this.assetAmount.minus(v.assetAmount));
+        return new CryptoAmount(assetAmountResult, this.asset);
     }
     times(v) {
         this.check(v);
         if (v instanceof CryptoAmount) {
-            const baseAmountResult = this.baseAmount.times(v.baseAmount);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = xchainUtil.assetToBase(this.assetAmount.times(v.assetAmount));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
         else {
-            const baseAmountResult = this.baseAmount.times(v);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = xchainUtil.assetToBase(this.assetAmount.times(v));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
     }
     div(v) {
         this.check(v);
         if (v instanceof CryptoAmount) {
-            const baseAmountResult = this.baseAmount.div(v.baseAmount);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = xchainUtil.assetToBase(this.assetAmount.div(v.assetAmount));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
         else {
-            const baseAmountResult = this.baseAmount.div(v);
-            return new CryptoAmount(baseAmountResult, this.asset);
+            const assetAmountResult = xchainUtil.assetToBase(this.assetAmount.div(v));
+            return new CryptoAmount(assetAmountResult, this.asset);
         }
     }
     lt(v) {
         this.check(v);
-        return this.baseAmount.lt(v.baseAmount);
+        return this.assetAmount.lt(v.assetAmount);
     }
     lte(v) {
         this.check(v);
-        return this.baseAmount.lte(v.baseAmount);
+        return this.assetAmount.lte(v.assetAmount);
     }
     gt(v) {
         this.check(v);
-        return this.baseAmount.gt(v.baseAmount);
+        return this.assetAmount.gt(v.assetAmount);
     }
     gte(v) {
         this.check(v);
-        return this.baseAmount.gte(v.baseAmount);
+        return this.assetAmount.gte(v.assetAmount);
     }
     eq(v) {
         this.check(v);
-        return this.baseAmount.eq(v.baseAmount);
+        return this.assetAmount.eq(v.assetAmount);
     }
     formatedAssetString() {
         return xchainUtil.formatAssetAmountCurrency({
@@ -162,8 +162,8 @@ class CryptoAmount {
      * This guard protects against trying to perform math with different assets
      *
      * Example.
-     * const x = new CryptoAmount(baseAmount(1),AssetBTC)
-     * const y = new CryptoAmount(baseAmount(1),AssetETH)
+     * const x = new CryptoAmount(assetAmount(1),AssetBTC)
+     * const y = new CryptoAmount(assetAmount(1),AssetETH)
      *
      * x.plus(y) <- will throw error "cannot perform math on 2 diff assets BTC.BTC ETH.ETH
      *
@@ -187,6 +187,13 @@ class CryptoAmount {
     TxStage[TxStage["OUTBOUND_CHAIN_CONFIRMED"] = 5] = "OUTBOUND_CHAIN_CONFIRMED";
 })(exports.TxStage || (exports.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 xchainUtil.baseAmount(baseAmountOut, outDecimals).amount();
+};
 /**
  *
  * @param inputAmount - amount to swap
@@ -197,16 +204,18 @@ class CryptoAmount {
 const getSwapFee = (inputAmount, pool, toRune) => {
     // formula: (x * x * Y) / (x + X) ^ 2
     // const isInputRune = isAssetRuneNative(inputAmount.asset)
-    const x = inputAmount.baseAmount.amount();
+    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 ? xchainUtil.AssetRuneNative : pool.asset;
-    const decimals = toRune || !pool.decimals ? 8 : pool.decimals;
     const numerator = x.times(x).multipliedBy(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
-    const swapFee = new CryptoAmount(xchainUtil.baseAmount(result, decimals), units);
-    // console.log(` swapFee ${swapFee.assetAmountFixedString()} ${assetToString(units)}`)
+    const eightDecimalResult = new CryptoAmount(xchainUtil.baseAmount(result), units);
+    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
+    const swapFee = new CryptoAmount(xchainUtil.baseAmount(baseOut, decimals), units);
+    //console.log(` swapFee ${swapFee.assetAmountFixedString()} `)
     return swapFee;
 };
 /**
@@ -219,7 +228,7 @@ const getSwapFee = (inputAmount, pool, toRune) => {
  */
 const getSwapSlip = (inputAmount, pool, toRune) => {
     // formula: (x) / (x + X)
-    const x = inputAmount.baseAmount.amount();
+    const x = getBaseAmountWithDiffDecimals(inputAmount, 8);
     const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
     const result = x.div(x.plus(X));
     return new BigNumber.BigNumber(result);
@@ -233,15 +242,18 @@ const getSwapSlip = (inputAmount, pool, toRune) => {
  */
 const getSwapOutput = (inputAmount, pool, toRune) => {
     // formula: (x * X * Y) / (x + X) ^ 2
-    const x = inputAmount.baseAmount.amount();
+    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 ? xchainUtil.AssetRuneNative : pool.asset;
-    const decimals = toRune || !pool.decimals ? 8 : pool.decimals;
+    // const decimals = toRune || !pool.decimals ? 8 : pool.decimals
     const numerator = x.times(X).times(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
-    return new CryptoAmount(xchainUtil.baseAmount(result, decimals), units);
+    const eightDecimalResult = new CryptoAmount(xchainUtil.baseAmount(result), units);
+    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
+    return new CryptoAmount(xchainUtil.baseAmount(baseOut, decimals), units);
 };
 const getDoubleSwapOutput = (inputAmount, pool1, pool2) => {
     // formula: getSwapOutput(pool1) => getSwapOutput(pool2)
@@ -338,10 +350,10 @@ const calcNetworkFee = (asset, gasRate) => {
             const gasRateinAVAXGwei = gasRate;
             const gasRateinAVAXWei = xchainUtil.baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (xchainUtil.eqAsset(asset, xchainUtil.AssetAVAX)) {
-                return new CryptoAmount(gasRateinAVAXWei.times(21000), xchainUtil.AssetETH);
+                return new CryptoAmount(gasRateinAVAXWei.times(21000), xchainUtil.AssetAVAX);
             }
             else {
-                return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainUtil.AssetETH);
+                return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainUtil.AssetAVAX);
             }
         case xchainUtil.Chain.Terra:
             return new CryptoAmount(xchainUtil.baseAmount(gasRate), xchainUtil.AssetLUNA);
@@ -545,18 +557,24 @@ class ThorchainQuery {
      */
     calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails) {
         return __awaiter(this, void 0, void 0, function* () {
-            //NOTE need to convert the asset to 8 decimals places for all calcs
-            const input = yield this.thorchainCache.convert(params.input, params.input.asset);
-            const inputInRune = yield this.thorchainCache.convert(input, xchainUtil.AssetRuneNative);
+            // NOTE need to convert the asset to 8 decimals places for all calcs
+            const DEFAULT_THORCHAIN_DECIMALS = 8;
+            // If input is already in 8 decimals skip the convert
+            const input = params.input.baseAmount.decimal === DEFAULT_THORCHAIN_DECIMALS
+                ? params.input
+                : yield this.thorchainCache.convert(params.input, params.input.asset);
+            // If asset is already rune native, skip the convert
+            const inputInRune = input.asset === xchainUtil.AssetRuneNative ? input : yield this.thorchainCache.convert(input, xchainUtil.AssetRuneNative);
             const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails.gas_rate);
             let outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails.gas_rate);
             outboundFeeInAsset = outboundFeeInAsset.times(3);
+            // convert fees to rune
             const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, xchainUtil.AssetRuneNative);
             let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, xchainUtil.AssetRuneNative);
             // ---------- Remove Fees from inbound before doing the swap -----------
-            // TODO confirm with chris about this change
-            // const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune)
-            const inputMinusInboundFeeInRune = inputInRune;
+            // TODO confirm with chris about this change, was there a reason why this was commented out?
+            const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune);
+            //>//const inputMinusInboundFeeInRune = inputInRune
             // remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
             const affiliateFeeInRune = inputMinusInboundFeeInRune.times(params.affiliateFeePercent || 0);
             // remove the affiliate fee from the input.
@@ -576,7 +594,7 @@ class ThorchainQuery {
                     outboundFeeInRune = yield this.convert(newFee, xchainUtil.AssetRuneNative);
                 }
             }
-            // Now calculate swapfee based on inputNetAmount
+            // Now calculate swap output based on inputNetAmount
             const swapOutput = yield this.thorchainCache.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
             const swapFeeInRune = yield this.thorchainCache.convert(swapOutput.swapFee, xchainUtil.AssetRuneNative);
             const outputInRune = yield this.thorchainCache.convert(swapOutput.output, xchainUtil.AssetRuneNative);
@@ -1259,23 +1277,35 @@ class ThorchainCache {
      * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
      *
      * @param input - amount/asset to convert to outAsset
-     * @param ouAsset - the Asset you want to convert to
+     * @param outAsset - the Asset you want to convert to
      * @returns CryptoAmount of input
      */
     convert(input, outAsset) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const exchangeRate = yield this.getExchangeRate(input.asset, outAsset);
-            let decimals = DEFAULT_THORCHAIN_DECIMALS;
-            if (!xchainUtil.isAssetRuneNative(outAsset)) {
-                const pool = yield this.getPoolForAsset(outAsset);
-                decimals = (_a = pool.decimals) !== null && _a !== void 0 ? _a : DEFAULT_THORCHAIN_DECIMALS;
-            }
-            const amt = xchainUtil.assetAmount(input.assetAmount.times(exchangeRate).amount().toFixed(), decimals);
-            const result = new CryptoAmount(xchainUtil.assetToBase(amt), outAsset);
+            const outDecimals = yield this.getDecimalForAsset(outAsset);
+            const inDecimals = input.baseAmount.decimal;
+            let baseAmountOut = input.baseAmount.times(exchangeRate).amount();
+            const adjustDecimals = outDecimals - inDecimals;
+            baseAmountOut = baseAmountOut.times(Math.pow(10, adjustDecimals));
+            const amt = xchainUtil.baseAmount(baseAmountOut, outDecimals);
+            const result = new CryptoAmount(amt, outAsset);
+            // console.log(
+            //   `${input.formatedAssetString()} ${input.asset.ticker} = ${result.formatedAssetString()} ${outAsset.ticker}`,
+            // )
             return result;
         });
     }
+    getDecimalForAsset(asset) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!xchainUtil.isAssetRuneNative(asset)) {
+                const pool = yield this.getPoolForAsset(asset);
+                return (_a = pool.decimals) !== null && _a !== void 0 ? _a : DEFAULT_THORCHAIN_DECIMALS;
+            }
+            return DEFAULT_THORCHAIN_DECIMALS;
+        });
+    }
     getRouterAddressForChain(chain) {
         return __awaiter(this, void 0, void 0, function* () {
             const inboundAsgard = (yield this.getInboundAddressesItems())[chain];
@@ -1732,6 +1762,7 @@ class Thornode {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.poolsApi) {
                 try {
+                    // console.log(console.log(JSON.stringify(api, null, 2)))
                     const pools = yield api.pools();
                     return pools.data;
                 }

package/lib/thorchain-cache.d.ts

@@ -99,10 +99,11 @@ export declare class ThorchainCache {
      * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
      *
      * @param input - amount/asset to convert to outAsset
-     * @param ouAsset - the Asset you want to convert to
+     * @param outAsset - the Asset you want to convert to
      * @returns CryptoAmount of input
      */
     convert(input: CryptoAmount, outAsset: Asset): Promise<CryptoAmount>;
+    private getDecimalForAsset;
     getRouterAddressForChain(chain: Chain): Promise<Address>;
     getInboundAddressesItems(): Promise<Record<string, InboundAddressesItem>>;
     getInboundDetails(): Promise<Record<string, InboundDetail>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-query",
-  "version": "0.1.0-alpha1",
+  "version": "0.1.0-beta",
   "license": "MIT",
   "description": "Thorchain query module that is resposible for estimating swap calculations and add/remove liquidity for thorchain ",
   "keywords": [