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

package/README.md

@@ -1,8 +1,6 @@
 # `@xchainjs/xchain-thorchain-query`
 
-Thorchain-query module to query thorchain for
-
-## Modules
+Thorchain-query module to query thorchain for estimation of swaps. Returns a TxDetail object with all the information needed to conduct a swap.
 
 ## Installation
 
@@ -10,10 +8,46 @@ Thorchain-query module to query thorchain for
 yarn add @xchainjs/xchain-thorchain-query
 ```
 
+Following peer dependencies have to be installed into your project. These are not included in `@xchainjs/xchain-thorchain-query`.
+
+```
+yarn add @xchainjs/xchain-client @xchainjs/xchain-util @xchainjs/xchain-midgard @xchainjs/xchain-thornode axios
+
+```
+
 ## Examples
 
+Estimation example from a swap of 2 BTC to RUNE
+
+```ts
+{
+  memo: '=:THOR.RUNE::2071168559999',
+  expiry: 2022-09-07T02:16:45.732Z,
+  toAddress: '',
+  txEstimate: {
+    input: '₿ 2',
+    totalFees: {
+      inboundFee: 'ᚱ 0.02',
+      swapFee: 'ᚱ 52.85380999',
+      outboundFee: 'ᚱ 0.06',
+      affiliateFee: 'ᚱ 0'
+    },
+    slipPercentage: '0.00246920801878638026',
+    netOutput: 'ᚱ 21,352.25318742',
+    waitTimeSeconds: '1248',
+    canSwap: true,
+    errors: []
+  }
+}
 ```
 
 ## Documentation
 
+For bash exmples, see example folder at the base of this repository xchainjs/xchainjs-lib.
+
+```
+### [`xchain-thorchain-query`](http://docs.xchainjs.org/xchain-thorchain-query/)
+
+[`How xchain-thorchain-query works`](http://docs.xchainjs.org/xchain-thorchain-query/how-it-works.html)\
+[`How to use xchain-thorchain-query`](http://docs.xchainjs.org/xchain-thorchain-query/how-to-use.html)
 ```

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);
@@ -431,23 +443,47 @@ class ThorchainQuery {
   
      * @returns The SwapEstimate
      */
-    estimateSwap(params, destinationAddress = '', affiliateAddress = '', interfaceID = 999) {
+    estimateSwap({ input, destinationAsset, destinationAddress, affiliateAddress = '', interfaceID = 999, affiliateFeePercent = 0, slipLimit, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.isValidSwap(params);
+            this.isValidSwap({
+                input,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                interfaceID,
+                affiliateFeePercent,
+                slipLimit,
+            });
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
-            const sourceInboundDetails = inboundDetails[params.input.asset.chain];
+            const sourceInboundDetails = inboundDetails[input.asset.chain];
             // console.log(JSON.stringify(sourceInboundDetails, null, 2))
-            const destinationInboundDetails = inboundDetails[params.destinationAsset.chain];
+            const destinationInboundDetails = inboundDetails[destinationAsset.chain];
             // console.log(JSON.stringify(destinationInboundDetails, null, 2))
-            const swapEstimate = yield this.calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails);
+            const swapEstimate = yield this.calcSwapEstimate({
+                input,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                interfaceID,
+                affiliateFeePercent,
+                slipLimit,
+            }, sourceInboundDetails, destinationInboundDetails);
             // Remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
-            const affiliateFee = params.input.baseAmount.times(params.affiliateFeePercent || 0);
+            const affiliateFee = input.baseAmount.times(affiliateFeePercent || 0);
             // Calculate expiry time
             const currentDatetime = new Date();
             const minutesToAdd = 15;
             const expiryDatetime = new Date(currentDatetime.getTime() + minutesToAdd * 60000);
             // Check for errors
-            const errors = yield this.getSwapEstimateErrors(params, swapEstimate, sourceInboundDetails, destinationInboundDetails);
+            const errors = yield this.getSwapEstimateErrors({
+                input,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                interfaceID,
+                affiliateFeePercent,
+                slipLimit,
+            }, swapEstimate, sourceInboundDetails, destinationInboundDetails);
             const txDetails = {
                 memo: '',
                 toAddress: '',
@@ -461,26 +497,26 @@ class ThorchainQuery {
             else {
                 txDetails.txEstimate.canSwap = true;
                 // Retrieve inbound Asgard address.
-                const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.input.asset.chain];
+                const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[input.asset.chain];
                 txDetails.toAddress = (inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address) || '';
                 // Work out LIM from the slip percentage
                 let limPercentage = BN_1;
-                if (params.slipLimit) {
-                    limPercentage = BN_1.minus(params.slipLimit || 1);
+                if (slipLimit) {
+                    limPercentage = BN_1.minus(slipLimit || 1);
                 } // else allowed slip is 100%
                 const limAssetAmount = swapEstimate.netOutput.times(limPercentage);
-                const inboundDelay = yield this.confCounting(params.input);
+                const inboundDelay = yield this.confCounting(input);
                 const outboundDelay = yield this.outboundDelay(limAssetAmount);
                 txDetails.txEstimate.waitTimeSeconds = outboundDelay + inboundDelay;
                 // Construct memo
                 txDetails.memo = this.constructSwapMemo({
-                    input: params.input,
-                    destinationAsset: params.destinationAsset,
+                    input: input,
+                    destinationAsset: destinationAsset,
                     limit: limAssetAmount.baseAmount,
-                    destinationAddress,
-                    affiliateAddress,
+                    destinationAddress: destinationAddress,
+                    affiliateAddress: affiliateAddress,
                     affiliateFee,
-                    interfaceID,
+                    interfaceID: interfaceID,
                 });
             }
             return txDetails;
@@ -512,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.
@@ -543,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);
@@ -1226,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];
@@ -1699,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);
@@ -440,23 +452,47 @@ class ThorchainQuery {
   
      * @returns The SwapEstimate
      */
-    estimateSwap(params, destinationAddress = '', affiliateAddress = '', interfaceID = 999) {
+    estimateSwap({ input, destinationAsset, destinationAddress, affiliateAddress = '', interfaceID = 999, affiliateFeePercent = 0, slipLimit, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.isValidSwap(params);
+            this.isValidSwap({
+                input,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                interfaceID,
+                affiliateFeePercent,
+                slipLimit,
+            });
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
-            const sourceInboundDetails = inboundDetails[params.input.asset.chain];
+            const sourceInboundDetails = inboundDetails[input.asset.chain];
             // console.log(JSON.stringify(sourceInboundDetails, null, 2))
-            const destinationInboundDetails = inboundDetails[params.destinationAsset.chain];
+            const destinationInboundDetails = inboundDetails[destinationAsset.chain];
             // console.log(JSON.stringify(destinationInboundDetails, null, 2))
-            const swapEstimate = yield this.calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails);
+            const swapEstimate = yield this.calcSwapEstimate({
+                input,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                interfaceID,
+                affiliateFeePercent,
+                slipLimit,
+            }, sourceInboundDetails, destinationInboundDetails);
             // Remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
-            const affiliateFee = params.input.baseAmount.times(params.affiliateFeePercent || 0);
+            const affiliateFee = input.baseAmount.times(affiliateFeePercent || 0);
             // Calculate expiry time
             const currentDatetime = new Date();
             const minutesToAdd = 15;
             const expiryDatetime = new Date(currentDatetime.getTime() + minutesToAdd * 60000);
             // Check for errors
-            const errors = yield this.getSwapEstimateErrors(params, swapEstimate, sourceInboundDetails, destinationInboundDetails);
+            const errors = yield this.getSwapEstimateErrors({
+                input,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                interfaceID,
+                affiliateFeePercent,
+                slipLimit,
+            }, swapEstimate, sourceInboundDetails, destinationInboundDetails);
             const txDetails = {
                 memo: '',
                 toAddress: '',
@@ -470,26 +506,26 @@ class ThorchainQuery {
             else {
                 txDetails.txEstimate.canSwap = true;
                 // Retrieve inbound Asgard address.
-                const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.input.asset.chain];
+                const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[input.asset.chain];
                 txDetails.toAddress = (inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address) || '';
                 // Work out LIM from the slip percentage
                 let limPercentage = BN_1;
-                if (params.slipLimit) {
-                    limPercentage = BN_1.minus(params.slipLimit || 1);
+                if (slipLimit) {
+                    limPercentage = BN_1.minus(slipLimit || 1);
                 } // else allowed slip is 100%
                 const limAssetAmount = swapEstimate.netOutput.times(limPercentage);
-                const inboundDelay = yield this.confCounting(params.input);
+                const inboundDelay = yield this.confCounting(input);
                 const outboundDelay = yield this.outboundDelay(limAssetAmount);
                 txDetails.txEstimate.waitTimeSeconds = outboundDelay + inboundDelay;
                 // Construct memo
                 txDetails.memo = this.constructSwapMemo({
-                    input: params.input,
-                    destinationAsset: params.destinationAsset,
+                    input: input,
+                    destinationAsset: destinationAsset,
                     limit: limAssetAmount.baseAmount,
-                    destinationAddress,
-                    affiliateAddress,
+                    destinationAddress: destinationAddress,
+                    affiliateAddress: affiliateAddress,
                     affiliateFee,
-                    interfaceID,
+                    interfaceID: interfaceID,
                 });
             }
             return txDetails;
@@ -521,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.
@@ -552,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);
@@ -1235,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];
@@ -1708,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/lib/thorchain-query.d.ts

@@ -26,7 +26,7 @@ export declare class ThorchainQuery {
   
      * @returns The SwapEstimate
      */
-    estimateSwap(params: EstimateSwapParams, destinationAddress?: string, affiliateAddress?: string, interfaceID?: number): Promise<TxDetails>;
+    estimateSwap({ input, destinationAsset, destinationAddress, affiliateAddress, interfaceID, affiliateFeePercent, slipLimit, }: EstimateSwapParams): Promise<TxDetails>;
     /**
      * Basic Checks for swap information
      * @param params

package/lib/types.d.ts

@@ -41,6 +41,9 @@ export declare type MidgardConfig = {
 export declare type EstimateSwapParams = {
     input: CryptoAmount;
     destinationAsset: Asset;
+    destinationAddress: Address;
+    affiliateAddress?: Address;
+    interfaceID?: number;
     affiliateFeePercent?: number;
     slipLimit?: BigNumber;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-query",
-  "version": "0.1.0-alpha",
+  "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": [