@xchainjs/xchain-thorchain-query 0.1.4 → 0.1.5

package/README.md

@@ -43,11 +43,13 @@ Estimation example from a swap of 2 BTC to RUNE
 
 ## Documentation
 
+[`Overview `](https://dev.thorchain.org/thorchain-dev/xchainjs-integration-guide/query-package)
+
 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 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)
 
 For Live examples

package/lib/index.esm.js

@@ -427,6 +427,7 @@ const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
 const getSwapFee = (inputAmount, pool, toRune) => {
     // formula: (x * x * Y) / (x + X) ^ 2
     // const isInputRune = isAssetRuneNative(inputAmount.asset)
+    const decimalsOut = pool.pool.nativeDecimal !== '-1' ? Number(pool.pool.nativeDecimal) : inputAmount.baseAmount.decimal;
     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
@@ -435,7 +436,7 @@ const getSwapFee = (inputAmount, pool, toRune) => {
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
     const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
-    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const decimals = toRune ? 8 : decimalsOut;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
     const swapFee = new CryptoAmount(baseAmount(baseOut, decimals), units);
     //console.log(` swapFee ${swapFee.assetAmountFixedString()} `)
@@ -465,6 +466,7 @@ const getSwapSlip = (inputAmount, pool, toRune) => {
  */
 const getSwapOutput = (inputAmount, pool, toRune) => {
     // formula: (x * X * Y) / (x + X) ^ 2
+    const decimalsOut = pool.pool.nativeDecimal !== '-1' ? Number(pool.pool.nativeDecimal) : inputAmount.baseAmount.decimal;
     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
@@ -474,7 +476,7 @@ const getSwapOutput = (inputAmount, pool, toRune) => {
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
     const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
-    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const decimals = toRune ? 8 : decimalsOut;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
     return new CryptoAmount(baseAmount(baseOut, decimals), units);
 };
@@ -585,6 +587,42 @@ const calcNetworkFee = (asset, inbound) => {
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
+/**
+ * Works out the required outbound fee based on the chain.
+ * Call getInboundDetails to get the current outbound fee
+ *
+ * @param sourceAsset
+ * @param inbound detail
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+const calcOutboundFee = (asset, inbound) => {
+    if (asset.synth)
+        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+    switch (asset.chain) {
+        case Chain.Bitcoin:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBTC);
+        case Chain.BitcoinCash:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBCH);
+        case Chain.Litecoin:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetLTC);
+        case Chain.Doge:
+            // NOTE: UTXO chains estimate fees with a 250 byte size
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetDOGE);
+        case Chain.Binance:
+            //flat fee
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBNB);
+        case Chain.Ethereum:
+            return new CryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetETH);
+        case Chain.Avalanche:
+            return new CryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetAVAX);
+        case Chain.Cosmos:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetAtom);
+        case Chain.THORChain:
+            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+    }
+    throw new Error(`could not calculate outbound fee for ${asset.chain}`);
+};
 /**
  * Return the chain for a given Asset This method should live somewhere else.
  * @param chain
@@ -829,14 +867,12 @@ class ThorchainCache {
      * @param expireNetworkValuesCacheMillis - how long should the Mimir/Constants be cached before expiry
      * @returns ThorchainCache
      */
-    constructor(midgard = defaultMidgard, thornode = defaultThornode, expirePoolCacheMillis = 6000, expireAsgardCacheMillis = TEN_MINUTES, expireInboundDetailsCacheMillis = 6000, expireNetworkValuesCacheMillis = TEN_MINUTES) {
-        this.asgardAssetsCache = undefined;
+    constructor(midgard = defaultMidgard, thornode = defaultThornode, expirePoolCacheMillis = 6000, expireInboundDetailsCacheMillis = 6000, expireNetworkValuesCacheMillis = TEN_MINUTES) {
         this.inboundDetailCache = undefined;
         this.networkValuesCache = undefined;
         this.midgard = midgard;
         this.thornode = thornode;
         this.expirePoolCacheMillis = expirePoolCacheMillis;
-        this.expireAsgardCacheMillis = expireAsgardCacheMillis;
         this.expireInboundDetailsCacheMillis = expireInboundDetailsCacheMillis;
         this.expireNetworkValuesCacheMillis = expireNetworkValuesCacheMillis;
         //initialize the cache
@@ -946,29 +982,6 @@ class ThorchainCache {
             }
         });
     }
-    /**
-     * Refreshes the asgardAssetsCache Cache
-     *
-     * NOTE: do not call refereshAsgardCache() directly, call getAsgardAssets() instead
-     * which will refresh the cache if it's expired
-     */
-    refereshAsgardCache() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inboundAddresses = yield this.thornode.getInboundAddresses();
-            const map = {};
-            if (inboundAddresses) {
-                for (const inboundAddress of inboundAddresses) {
-                    if (!inboundAddress.chain)
-                        throw Error('chain needed');
-                    map[inboundAddress.chain] = inboundAddress;
-                }
-                this.asgardAssetsCache = {
-                    lastRefreshed: Date.now(),
-                    inboundAddresses: map,
-                };
-            }
-        });
-    }
     /**
      * Refreshes the InboundDetailCache Cache
      *
@@ -1055,22 +1068,26 @@ class ThorchainCache {
      */
     getExpectedSwapOutput(inputAmount, destinationAsset) {
         return __awaiter(this, void 0, void 0, function* () {
+            let swapOutput;
             if (isAssetRuneNative(inputAmount.asset)) {
                 //singleswap from rune -> asset
                 const pool = yield this.getPoolForAsset(destinationAsset);
-                return getSingleSwap(inputAmount, pool, false);
+                swapOutput = getSingleSwap(inputAmount, pool, false);
             }
             else if (isAssetRuneNative(destinationAsset)) {
                 //singleswap from  asset -> rune
                 const pool = yield this.getPoolForAsset(inputAmount.asset);
-                return getSingleSwap(inputAmount, pool, true);
+                swapOutput = getSingleSwap(inputAmount, pool, true);
             }
             else {
                 //doubleswap asset-> asset
                 const inPool = yield this.getPoolForAsset(inputAmount.asset);
                 const destPool = yield this.getPoolForAsset(destinationAsset);
-                return yield getDoubleSwap(inputAmount, inPool, destPool, this);
+                swapOutput = yield getDoubleSwap(inputAmount, inPool, destPool, this);
             }
+            //Note this is needed to return a synth vs. a  native asset on swap out
+            swapOutput.output = new CryptoAmount(swapOutput.output.baseAmount, destinationAsset);
+            return swapOutput;
         });
     }
     /**
@@ -1113,37 +1130,13 @@ class ThorchainCache {
     }
     getRouterAddressForChain(chain) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.getInboundAddresses())[chain];
+            const inboundAsgard = (yield this.getInboundDetails())[chain];
             if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
                 throw new Error('router address is not defined');
             }
             return inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router;
         });
     }
-    /**
-     *
-     * @returns - inbound adresses item
-     */
-    getInboundAddresses() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const millisSinceLastRefeshed = Date.now() - (((_a = this.asgardAssetsCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
-            if (millisSinceLastRefeshed > this.expireAsgardCacheMillis) {
-                try {
-                    yield this.refereshAsgardCache();
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            if (this.asgardAssetsCache) {
-                return this.asgardAssetsCache.inboundAddresses;
-            }
-            else {
-                throw Error(`Could not refresh refereshAsgardCache `);
-            }
-        });
-    }
     /**
      *
      * @returns - inbound details
@@ -1327,7 +1320,8 @@ class ThorchainQuery {
   
      * @returns The SwapEstimate
      */
-    estimateSwap({ input, destinationAsset, destinationAddress, slipLimit, interfaceID = 999, affiliateAddress = '', affiliateFeePercent = 0, }) {
+    estimateSwap({ input, destinationAsset, destinationAddress, slipLimit = new BigNumber('0.03'), //default to 3%
+    interfaceID = '555', affiliateAddress = '', affiliateFeeBasisPoints = 0, }) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.isValidSwap({
                 input,
@@ -1335,7 +1329,7 @@ class ThorchainQuery {
                 destinationAddress,
                 slipLimit,
                 affiliateAddress,
-                affiliateFeePercent,
+                affiliateFeeBasisPoints,
                 interfaceID,
             });
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
@@ -1348,7 +1342,7 @@ class ThorchainQuery {
                 destinationAddress,
                 slipLimit,
                 affiliateAddress,
-                affiliateFeePercent,
+                affiliateFeeBasisPoints,
                 interfaceID,
             }, sourceInboundDetails, destinationInboundDetails);
             // Calculate transaction expiry time
@@ -1362,7 +1356,7 @@ class ThorchainQuery {
                 destinationAddress,
                 slipLimit,
                 affiliateAddress,
-                affiliateFeePercent,
+                affiliateFeeBasisPoints,
                 interfaceID,
             }, swapEstimate, sourceInboundDetails, destinationInboundDetails);
             const txDetails = {
@@ -1377,7 +1371,7 @@ class ThorchainQuery {
             }
             else {
                 txDetails.txEstimate.canSwap = true;
-                const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[input.asset.chain];
+                const inboundAsgard = (yield this.thorchainCache.getInboundDetails())[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;
@@ -1397,7 +1391,7 @@ class ThorchainQuery {
                     limit: baseAmount(limAssetAmount8Decimals),
                     destinationAddress: destinationAddress,
                     affiliateAddress: affiliateAddress,
-                    affiliateFee: swapEstimate.totalFees.affiliateFee.baseAmount,
+                    affiliateFeeBasisPoints: affiliateFeeBasisPoints,
                     interfaceID: interfaceID,
                 });
             }
@@ -1409,6 +1403,7 @@ class ThorchainQuery {
      * @param params
      */
     isValidSwap(params) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (isAssetRuneNative(params.input.asset)) {
                 if (params.input.baseAmount.decimal !== 8)
@@ -1428,8 +1423,12 @@ class ThorchainQuery {
             if (params.input.baseAmount.lte(0))
                 throw Error('inputAmount must be greater than 0');
             // Affiliate fee % can't exceed 10% because this is set by TC.
-            if (params.affiliateFeePercent && (params.affiliateFeePercent < 0 || params.affiliateFeePercent > 0.1))
-                throw Error(`affiliateFee must be between 0 and 1000 basis points`);
+            if (params.affiliateFeeBasisPoints && (params.affiliateFeeBasisPoints < 0 || params.affiliateFeeBasisPoints > 1000))
+                throw Error(`affiliateFeeBasisPoints must be between 0 and 1000 basis points`);
+            if (params.affiliateFeeBasisPoints && !Number.isInteger(params.affiliateFeeBasisPoints))
+                throw Error(`affiliateFeeBasisPoints must be an integer`);
+            if (((_a = params.slipLimit) === null || _a === void 0 ? void 0 : _a.lte(0)) || ((_b = params.slipLimit) === null || _b === void 0 ? void 0 : _b.gt(1)))
+                throw Error(`slipLimit must be between 0 and 1`);
         });
     }
     /**
@@ -1450,51 +1449,48 @@ class ThorchainQuery {
             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);
-            // Retrieve outbound fee from inboundAddressDetails.
-            const outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails).times(3);
-            // convert fees to rune
-            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, AssetRuneNative);
-            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, AssetRuneNative);
+            const inboundFeeInInboundGasAsset = calcNetworkFee(input.asset, sourceInboundDetails);
+            const outboundFeeInOutboundGasAsset = calcOutboundFee(params.destinationAsset, destinationInboundDetails);
             // ----------- Remove Fees from inbound before doing the swap -----------
-            const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune);
+            const inboundFeeInInboundAsset = yield this.thorchainCache.convert(inboundFeeInInboundGasAsset, params.input.asset);
+            const inputMinusInboundFeeInAsset = input.minus(inboundFeeInInboundAsset);
+            // console.log('y', inputMinusInboundFeeInAsset.formatedAssetString())
             // remove any affiliateFee. netInput * affiliateFee (percentage) of the destination asset type
-            const affiliateFeeInRune = inputMinusInboundFeeInRune.times(params.affiliateFeePercent || 0);
-            // remove the affiliate fee from the input.
-            const inputNetAmountInRune = inputMinusInboundFeeInRune.minus(affiliateFeeInRune);
-            // convert back to input asset
-            const inputNetInAsset = yield this.thorchainCache.convert(inputNetAmountInRune, input.asset);
-            // Check outbound fee is equal too or greater than 1 USD * need to find a more permanent solution to this. referencing just 1 stable coin pool has problems
-            if (params.destinationAsset.chain !== Chain.THORChain && !params.destinationAsset.synth) {
-                const deepestUSDPOOL = yield this.thorchainCache.getDeepestUSDPool();
-                const usdAsset = deepestUSDPOOL.asset;
-                const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
-                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);
-                }
+            const affiliateFeePercent = params.affiliateFeeBasisPoints ? params.affiliateFeeBasisPoints / 10000 : 0;
+            const affiliateFeeInAsset = inputMinusInboundFeeInAsset.times(affiliateFeePercent);
+            let affiliateFeeSwapOutputInRune;
+            if (isAssetRuneNative(affiliateFeeInAsset.asset)) {
+                affiliateFeeSwapOutputInRune = {
+                    output: affiliateFeeInAsset,
+                    swapFee: new CryptoAmount(baseAmount(0), AssetRuneNative),
+                    slip: new BigNumber(0),
+                };
+            }
+            else {
+                affiliateFeeSwapOutputInRune = yield this.thorchainCache.getExpectedSwapOutput(affiliateFeeInAsset, AssetRuneNative);
             }
+            // remove the affiliate fee from the input.
+            const inputNetInAsset = inputMinusInboundFeeInAsset.minus(affiliateFeeInAsset);
             // 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);
+            const swapOutputInDestinationAsset = yield this.thorchainCache.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
             // ---------------- Remove Outbound Fee ---------------------- /
-            const netOutputInRune = outputInRune.minus(outboundFeeInRune);
-            const netOutputInAsset = yield this.thorchainCache.convert(netOutputInRune, params.destinationAsset);
+            const outboundFeeInDestinationAsset = yield this.thorchainCache.convert(outboundFeeInOutboundGasAsset, params.destinationAsset);
+            // console.log('a', assetToString(swapOutputInDestinationAsset.output.asset))
+            // console.log('b', assetToString(outboundFeeInDestinationAsset.asset))
+            // // console.log('x', swapOutputInDestinationAsset.output.formatedAssetString())
+            // // console.log('y', outboundFeeInDestinationAsset.formatedAssetString())
+            const netOutputInAsset = swapOutputInDestinationAsset.output.minus(outboundFeeInDestinationAsset);
             const totalFees = {
-                inboundFee: inboundFeeInRune,
-                swapFee: swapFeeInRune,
-                outboundFee: outboundFeeInRune,
-                affiliateFee: affiliateFeeInRune,
+                inboundFee: inboundFeeInInboundGasAsset,
+                swapFee: swapOutputInDestinationAsset.swapFee,
+                outboundFee: outboundFeeInOutboundGasAsset,
+                affiliateFee: affiliateFeeSwapOutputInRune.output,
+                // totalFees: ,
             };
+            //const totalFeesInUsd = await this.getFeesIn(totalFees, usdAsset)
             const swapEstimate = {
                 totalFees: totalFees,
-                slipPercentage: swapOutput.slip,
+                slipPercentage: swapOutputInDestinationAsset.slip,
                 netOutput: netOutputInAsset,
                 waitTimeSeconds: 0,
                 canSwap: false,
@@ -1509,15 +1505,16 @@ class ThorchainQuery {
      * @returns - constructed memo string
      */
     constructSwapMemo(params) {
+        var _a;
         const limstring = params.limit.amount().toFixed();
         // create LIM with interface ID
-        const lim = limstring.substring(0, limstring.length - 3).concat(params.interfaceID.toString());
+        const lim = limstring.substring(0, limstring.length - 3).concat(params.interfaceID);
         // create the full memo
         let memo = `=:${assetToString(params.destinationAsset)}`;
         // NOTE: we should validate affiliate address is EITHER: a thorname or valid thorchain address, currently we cannot do this without importing xchain-thorchain
-        if (params.affiliateAddress != '' || params.affiliateFee == undefined) {
+        if (((_a = params.affiliateAddress) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             // NOTE: we should validate destinationAddress address is valid destination address for the asset type requested
-            memo = memo.concat(`:${params.destinationAddress}:${lim}:${params.affiliateAddress}:${params.affiliateFee.amount().toFixed()}`);
+            memo = memo.concat(`:${params.destinationAddress}:${lim}:${params.affiliateAddress}:${params.affiliateFeeBasisPoints}`);
         }
         else {
             memo = memo.concat(`:${params.destinationAddress}:${lim}`);
@@ -1632,6 +1629,9 @@ class ThorchainQuery {
             };
         });
     }
+    // async getTotalFees(inbound: CryptoAmount, swapFee: CryptoAmount, outbound: CryptoAmount, affiliate: CryptoAmount): Promise<TotalFees> {
+    //   return {}
+    // }
     /**
      * Returns the exchange of a CryptoAmount to a different Asset
      *

package/lib/index.js

@@ -436,6 +436,7 @@ const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
 const getSwapFee = (inputAmount, pool, toRune) => {
     // formula: (x * x * Y) / (x + X) ^ 2
     // const isInputRune = isAssetRuneNative(inputAmount.asset)
+    const decimalsOut = pool.pool.nativeDecimal !== '-1' ? Number(pool.pool.nativeDecimal) : inputAmount.baseAmount.decimal;
     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
@@ -444,7 +445,7 @@ const getSwapFee = (inputAmount, pool, toRune) => {
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
     const eightDecimalResult = new CryptoAmount(xchainUtil.baseAmount(result), units);
-    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const decimals = toRune ? 8 : decimalsOut;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
     const swapFee = new CryptoAmount(xchainUtil.baseAmount(baseOut, decimals), units);
     //console.log(` swapFee ${swapFee.assetAmountFixedString()} `)
@@ -474,6 +475,7 @@ const getSwapSlip = (inputAmount, pool, toRune) => {
  */
 const getSwapOutput = (inputAmount, pool, toRune) => {
     // formula: (x * X * Y) / (x + X) ^ 2
+    const decimalsOut = pool.pool.nativeDecimal !== '-1' ? Number(pool.pool.nativeDecimal) : inputAmount.baseAmount.decimal;
     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
@@ -483,7 +485,7 @@ const getSwapOutput = (inputAmount, pool, toRune) => {
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
     const eightDecimalResult = new CryptoAmount(xchainUtil.baseAmount(result), units);
-    const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
+    const decimals = toRune ? 8 : decimalsOut;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
     return new CryptoAmount(xchainUtil.baseAmount(baseOut, decimals), units);
 };
@@ -594,6 +596,42 @@ const calcNetworkFee = (asset, inbound) => {
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
+/**
+ * Works out the required outbound fee based on the chain.
+ * Call getInboundDetails to get the current outbound fee
+ *
+ * @param sourceAsset
+ * @param inbound detail
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+const calcOutboundFee = (asset, inbound) => {
+    if (asset.synth)
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+    switch (asset.chain) {
+        case xchainUtil.Chain.Bitcoin:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetBTC);
+        case xchainUtil.Chain.BitcoinCash:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetBCH);
+        case xchainUtil.Chain.Litecoin:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetLTC);
+        case xchainUtil.Chain.Doge:
+            // NOTE: UTXO chains estimate fees with a 250 byte size
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetDOGE);
+        case xchainUtil.Chain.Binance:
+            //flat fee
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetBNB);
+        case xchainUtil.Chain.Ethereum:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), xchainUtil.AssetETH);
+        case xchainUtil.Chain.Avalanche:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), xchainUtil.AssetAVAX);
+        case xchainUtil.Chain.Cosmos:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetAtom);
+        case xchainUtil.Chain.THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+    }
+    throw new Error(`could not calculate outbound fee for ${asset.chain}`);
+};
 /**
  * Return the chain for a given Asset This method should live somewhere else.
  * @param chain
@@ -838,14 +876,12 @@ class ThorchainCache {
      * @param expireNetworkValuesCacheMillis - how long should the Mimir/Constants be cached before expiry
      * @returns ThorchainCache
      */
-    constructor(midgard = defaultMidgard, thornode = defaultThornode, expirePoolCacheMillis = 6000, expireAsgardCacheMillis = TEN_MINUTES, expireInboundDetailsCacheMillis = 6000, expireNetworkValuesCacheMillis = TEN_MINUTES) {
-        this.asgardAssetsCache = undefined;
+    constructor(midgard = defaultMidgard, thornode = defaultThornode, expirePoolCacheMillis = 6000, expireInboundDetailsCacheMillis = 6000, expireNetworkValuesCacheMillis = TEN_MINUTES) {
         this.inboundDetailCache = undefined;
         this.networkValuesCache = undefined;
         this.midgard = midgard;
         this.thornode = thornode;
         this.expirePoolCacheMillis = expirePoolCacheMillis;
-        this.expireAsgardCacheMillis = expireAsgardCacheMillis;
         this.expireInboundDetailsCacheMillis = expireInboundDetailsCacheMillis;
         this.expireNetworkValuesCacheMillis = expireNetworkValuesCacheMillis;
         //initialize the cache
@@ -955,29 +991,6 @@ class ThorchainCache {
             }
         });
     }
-    /**
-     * Refreshes the asgardAssetsCache Cache
-     *
-     * NOTE: do not call refereshAsgardCache() directly, call getAsgardAssets() instead
-     * which will refresh the cache if it's expired
-     */
-    refereshAsgardCache() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inboundAddresses = yield this.thornode.getInboundAddresses();
-            const map = {};
-            if (inboundAddresses) {
-                for (const inboundAddress of inboundAddresses) {
-                    if (!inboundAddress.chain)
-                        throw Error('chain needed');
-                    map[inboundAddress.chain] = inboundAddress;
-                }
-                this.asgardAssetsCache = {
-                    lastRefreshed: Date.now(),
-                    inboundAddresses: map,
-                };
-            }
-        });
-    }
     /**
      * Refreshes the InboundDetailCache Cache
      *
@@ -1064,22 +1077,26 @@ class ThorchainCache {
      */
     getExpectedSwapOutput(inputAmount, destinationAsset) {
         return __awaiter(this, void 0, void 0, function* () {
+            let swapOutput;
             if (xchainUtil.isAssetRuneNative(inputAmount.asset)) {
                 //singleswap from rune -> asset
                 const pool = yield this.getPoolForAsset(destinationAsset);
-                return getSingleSwap(inputAmount, pool, false);
+                swapOutput = getSingleSwap(inputAmount, pool, false);
             }
             else if (xchainUtil.isAssetRuneNative(destinationAsset)) {
                 //singleswap from  asset -> rune
                 const pool = yield this.getPoolForAsset(inputAmount.asset);
-                return getSingleSwap(inputAmount, pool, true);
+                swapOutput = getSingleSwap(inputAmount, pool, true);
             }
             else {
                 //doubleswap asset-> asset
                 const inPool = yield this.getPoolForAsset(inputAmount.asset);
                 const destPool = yield this.getPoolForAsset(destinationAsset);
-                return yield getDoubleSwap(inputAmount, inPool, destPool, this);
+                swapOutput = yield getDoubleSwap(inputAmount, inPool, destPool, this);
             }
+            //Note this is needed to return a synth vs. a  native asset on swap out
+            swapOutput.output = new CryptoAmount(swapOutput.output.baseAmount, destinationAsset);
+            return swapOutput;
         });
     }
     /**
@@ -1122,37 +1139,13 @@ class ThorchainCache {
     }
     getRouterAddressForChain(chain) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.getInboundAddresses())[chain];
+            const inboundAsgard = (yield this.getInboundDetails())[chain];
             if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
                 throw new Error('router address is not defined');
             }
             return inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router;
         });
     }
-    /**
-     *
-     * @returns - inbound adresses item
-     */
-    getInboundAddresses() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const millisSinceLastRefeshed = Date.now() - (((_a = this.asgardAssetsCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
-            if (millisSinceLastRefeshed > this.expireAsgardCacheMillis) {
-                try {
-                    yield this.refereshAsgardCache();
-                }
-                catch (e) {
-                    console.error(e);
-                }
-            }
-            if (this.asgardAssetsCache) {
-                return this.asgardAssetsCache.inboundAddresses;
-            }
-            else {
-                throw Error(`Could not refresh refereshAsgardCache `);
-            }
-        });
-    }
     /**
      *
      * @returns - inbound details
@@ -1336,7 +1329,8 @@ class ThorchainQuery {
   
      * @returns The SwapEstimate
      */
-    estimateSwap({ input, destinationAsset, destinationAddress, slipLimit, interfaceID = 999, affiliateAddress = '', affiliateFeePercent = 0, }) {
+    estimateSwap({ input, destinationAsset, destinationAddress, slipLimit = new bignumber_js.BigNumber('0.03'), //default to 3%
+    interfaceID = '555', affiliateAddress = '', affiliateFeeBasisPoints = 0, }) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.isValidSwap({
                 input,
@@ -1344,7 +1338,7 @@ class ThorchainQuery {
                 destinationAddress,
                 slipLimit,
                 affiliateAddress,
-                affiliateFeePercent,
+                affiliateFeeBasisPoints,
                 interfaceID,
             });
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
@@ -1357,7 +1351,7 @@ class ThorchainQuery {
                 destinationAddress,
                 slipLimit,
                 affiliateAddress,
-                affiliateFeePercent,
+                affiliateFeeBasisPoints,
                 interfaceID,
             }, sourceInboundDetails, destinationInboundDetails);
             // Calculate transaction expiry time
@@ -1371,7 +1365,7 @@ class ThorchainQuery {
                 destinationAddress,
                 slipLimit,
                 affiliateAddress,
-                affiliateFeePercent,
+                affiliateFeeBasisPoints,
                 interfaceID,
             }, swapEstimate, sourceInboundDetails, destinationInboundDetails);
             const txDetails = {
@@ -1386,7 +1380,7 @@ class ThorchainQuery {
             }
             else {
                 txDetails.txEstimate.canSwap = true;
-                const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[input.asset.chain];
+                const inboundAsgard = (yield this.thorchainCache.getInboundDetails())[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;
@@ -1406,7 +1400,7 @@ class ThorchainQuery {
                     limit: xchainUtil.baseAmount(limAssetAmount8Decimals),
                     destinationAddress: destinationAddress,
                     affiliateAddress: affiliateAddress,
-                    affiliateFee: swapEstimate.totalFees.affiliateFee.baseAmount,
+                    affiliateFeeBasisPoints: affiliateFeeBasisPoints,
                     interfaceID: interfaceID,
                 });
             }
@@ -1418,6 +1412,7 @@ class ThorchainQuery {
      * @param params
      */
     isValidSwap(params) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (xchainUtil.isAssetRuneNative(params.input.asset)) {
                 if (params.input.baseAmount.decimal !== 8)
@@ -1437,8 +1432,12 @@ class ThorchainQuery {
             if (params.input.baseAmount.lte(0))
                 throw Error('inputAmount must be greater than 0');
             // Affiliate fee % can't exceed 10% because this is set by TC.
-            if (params.affiliateFeePercent && (params.affiliateFeePercent < 0 || params.affiliateFeePercent > 0.1))
-                throw Error(`affiliateFee must be between 0 and 1000 basis points`);
+            if (params.affiliateFeeBasisPoints && (params.affiliateFeeBasisPoints < 0 || params.affiliateFeeBasisPoints > 1000))
+                throw Error(`affiliateFeeBasisPoints must be between 0 and 1000 basis points`);
+            if (params.affiliateFeeBasisPoints && !Number.isInteger(params.affiliateFeeBasisPoints))
+                throw Error(`affiliateFeeBasisPoints must be an integer`);
+            if (((_a = params.slipLimit) === null || _a === void 0 ? void 0 : _a.lte(0)) || ((_b = params.slipLimit) === null || _b === void 0 ? void 0 : _b.gt(1)))
+                throw Error(`slipLimit must be between 0 and 1`);
         });
     }
     /**
@@ -1459,51 +1458,48 @@ class ThorchainQuery {
             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);
-            // Retrieve outbound fee from inboundAddressDetails.
-            const outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails).times(3);
-            // convert fees to rune
-            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, xchainUtil.AssetRuneNative);
-            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, xchainUtil.AssetRuneNative);
+            const inboundFeeInInboundGasAsset = calcNetworkFee(input.asset, sourceInboundDetails);
+            const outboundFeeInOutboundGasAsset = calcOutboundFee(params.destinationAsset, destinationInboundDetails);
             // ----------- Remove Fees from inbound before doing the swap -----------
-            const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune);
+            const inboundFeeInInboundAsset = yield this.thorchainCache.convert(inboundFeeInInboundGasAsset, params.input.asset);
+            const inputMinusInboundFeeInAsset = input.minus(inboundFeeInInboundAsset);
+            // console.log('y', inputMinusInboundFeeInAsset.formatedAssetString())
             // remove any affiliateFee. netInput * affiliateFee (percentage) of the destination asset type
-            const affiliateFeeInRune = inputMinusInboundFeeInRune.times(params.affiliateFeePercent || 0);
-            // remove the affiliate fee from the input.
-            const inputNetAmountInRune = inputMinusInboundFeeInRune.minus(affiliateFeeInRune);
-            // convert back to input asset
-            const inputNetInAsset = yield this.thorchainCache.convert(inputNetAmountInRune, input.asset);
-            // Check outbound fee is equal too or greater than 1 USD * need to find a more permanent solution to this. referencing just 1 stable coin pool has problems
-            if (params.destinationAsset.chain !== xchainUtil.Chain.THORChain && !params.destinationAsset.synth) {
-                const deepestUSDPOOL = yield this.thorchainCache.getDeepestUSDPool();
-                const usdAsset = deepestUSDPOOL.asset;
-                const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
-                const usdMinFee = new CryptoAmount(xchainUtil.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, xchainUtil.AssetRuneNative);
-                }
+            const affiliateFeePercent = params.affiliateFeeBasisPoints ? params.affiliateFeeBasisPoints / 10000 : 0;
+            const affiliateFeeInAsset = inputMinusInboundFeeInAsset.times(affiliateFeePercent);
+            let affiliateFeeSwapOutputInRune;
+            if (xchainUtil.isAssetRuneNative(affiliateFeeInAsset.asset)) {
+                affiliateFeeSwapOutputInRune = {
+                    output: affiliateFeeInAsset,
+                    swapFee: new CryptoAmount(xchainUtil.baseAmount(0), xchainUtil.AssetRuneNative),
+                    slip: new bignumber_js.BigNumber(0),
+                };
+            }
+            else {
+                affiliateFeeSwapOutputInRune = yield this.thorchainCache.getExpectedSwapOutput(affiliateFeeInAsset, xchainUtil.AssetRuneNative);
             }
+            // remove the affiliate fee from the input.
+            const inputNetInAsset = inputMinusInboundFeeInAsset.minus(affiliateFeeInAsset);
             // 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);
+            const swapOutputInDestinationAsset = yield this.thorchainCache.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
             // ---------------- Remove Outbound Fee ---------------------- /
-            const netOutputInRune = outputInRune.minus(outboundFeeInRune);
-            const netOutputInAsset = yield this.thorchainCache.convert(netOutputInRune, params.destinationAsset);
+            const outboundFeeInDestinationAsset = yield this.thorchainCache.convert(outboundFeeInOutboundGasAsset, params.destinationAsset);
+            // console.log('a', assetToString(swapOutputInDestinationAsset.output.asset))
+            // console.log('b', assetToString(outboundFeeInDestinationAsset.asset))
+            // // console.log('x', swapOutputInDestinationAsset.output.formatedAssetString())
+            // // console.log('y', outboundFeeInDestinationAsset.formatedAssetString())
+            const netOutputInAsset = swapOutputInDestinationAsset.output.minus(outboundFeeInDestinationAsset);
             const totalFees = {
-                inboundFee: inboundFeeInRune,
-                swapFee: swapFeeInRune,
-                outboundFee: outboundFeeInRune,
-                affiliateFee: affiliateFeeInRune,
+                inboundFee: inboundFeeInInboundGasAsset,
+                swapFee: swapOutputInDestinationAsset.swapFee,
+                outboundFee: outboundFeeInOutboundGasAsset,
+                affiliateFee: affiliateFeeSwapOutputInRune.output,
+                // totalFees: ,
             };
+            //const totalFeesInUsd = await this.getFeesIn(totalFees, usdAsset)
             const swapEstimate = {
                 totalFees: totalFees,
-                slipPercentage: swapOutput.slip,
+                slipPercentage: swapOutputInDestinationAsset.slip,
                 netOutput: netOutputInAsset,
                 waitTimeSeconds: 0,
                 canSwap: false,
@@ -1518,15 +1514,16 @@ class ThorchainQuery {
      * @returns - constructed memo string
      */
     constructSwapMemo(params) {
+        var _a;
         const limstring = params.limit.amount().toFixed();
         // create LIM with interface ID
-        const lim = limstring.substring(0, limstring.length - 3).concat(params.interfaceID.toString());
+        const lim = limstring.substring(0, limstring.length - 3).concat(params.interfaceID);
         // create the full memo
         let memo = `=:${xchainUtil.assetToString(params.destinationAsset)}`;
         // NOTE: we should validate affiliate address is EITHER: a thorname or valid thorchain address, currently we cannot do this without importing xchain-thorchain
-        if (params.affiliateAddress != '' || params.affiliateFee == undefined) {
+        if (((_a = params.affiliateAddress) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             // NOTE: we should validate destinationAddress address is valid destination address for the asset type requested
-            memo = memo.concat(`:${params.destinationAddress}:${lim}:${params.affiliateAddress}:${params.affiliateFee.amount().toFixed()}`);
+            memo = memo.concat(`:${params.destinationAddress}:${lim}:${params.affiliateAddress}:${params.affiliateFeeBasisPoints}`);
         }
         else {
             memo = memo.concat(`:${params.destinationAddress}:${lim}`);
@@ -1641,6 +1638,9 @@ class ThorchainQuery {
             };
         });
     }
+    // async getTotalFees(inbound: CryptoAmount, swapFee: CryptoAmount, outbound: CryptoAmount, affiliate: CryptoAmount): Promise<TotalFees> {
+    //   return {}
+    // }
     /**
      * Returns the exchange of a CryptoAmount to a different Asset
      *

package/lib/thorchain-cache.d.ts

@@ -1,4 +1,3 @@
-import { InboundAddress } from '@xchainjs/xchain-thornode';
 import { Address, Asset, Chain } from '@xchainjs/xchain-util';
 import { BigNumber } from 'bignumber.js';
 import { CryptoAmount } from './crypto-amount';
@@ -13,11 +12,9 @@ export declare class ThorchainCache {
     readonly midgard: Midgard;
     readonly thornode: Thornode;
     private poolCache;
-    private asgardAssetsCache;
     private inboundDetailCache;
     private networkValuesCache;
     private expirePoolCacheMillis;
-    private expireAsgardCacheMillis;
     private expireInboundDetailsCacheMillis;
     private expireNetworkValuesCacheMillis;
     /**
@@ -30,7 +27,7 @@ export declare class ThorchainCache {
      * @param expireNetworkValuesCacheMillis - how long should the Mimir/Constants be cached before expiry
      * @returns ThorchainCache
      */
-    constructor(midgard?: Midgard, thornode?: Thornode, expirePoolCacheMillis?: number, expireAsgardCacheMillis?: number, expireInboundDetailsCacheMillis?: number, expireNetworkValuesCacheMillis?: number);
+    constructor(midgard?: Midgard, thornode?: Thornode, expirePoolCacheMillis?: number, expireInboundDetailsCacheMillis?: number, expireNetworkValuesCacheMillis?: number);
     /**
      * Gets the exchange rate of the from asset in terms on the to asset
      *
@@ -59,13 +56,6 @@ export declare class ThorchainCache {
      * which will refresh the cache if it's expired
      */
     private refereshPoolCache;
-    /**
-     * Refreshes the asgardAssetsCache Cache
-     *
-     * NOTE: do not call refereshAsgardCache() directly, call getAsgardAssets() instead
-     * which will refresh the cache if it's expired
-     */
-    private refereshAsgardCache;
     /**
      * Refreshes the InboundDetailCache Cache
      *
@@ -105,11 +95,6 @@ export declare class ThorchainCache {
     convert(input: CryptoAmount, outAsset: Asset): Promise<CryptoAmount>;
     private getDecimalForAsset;
     getRouterAddressForChain(chain: Chain): Promise<Address>;
-    /**
-     *
-     * @returns - inbound adresses item
-     */
-    getInboundAddresses(): Promise<Record<string, InboundAddress>>;
     /**
      *
      * @returns - inbound details

package/lib/thorchain-query.d.ts

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

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import { FeeOption } from '@xchainjs/xchain-client';
-import { InboundAddress, LiquidityProvider } from '@xchainjs/xchain-thornode';
+import { LiquidityProvider } from '@xchainjs/xchain-thornode';
 import { Address, Asset, BaseAmount, Chain } from '@xchainjs/xchain-util';
 import { BigNumber } from 'bignumber.js';
 import { CryptoAmount } from './crypto-amount';
@@ -22,10 +22,6 @@ export declare type PoolCache = {
     lastRefreshed: number;
     pools: Record<string, LiquidityPool>;
 };
-export declare type AsgardCache = {
-    lastRefreshed: number;
-    inboundAddresses: Record<string, InboundAddress>;
-};
 export declare type InboundDetailCache = {
     lastRefreshed: number;
     inboundDetails: Record<string, InboundDetail>;
@@ -44,8 +40,8 @@ export declare type EstimateSwapParams = {
     destinationAddress: Address;
     slipLimit?: BigNumber;
     affiliateAddress?: Address;
-    affiliateFeePercent?: number;
-    interfaceID?: number;
+    affiliateFeeBasisPoints?: number;
+    interfaceID?: string;
 };
 export declare type SwapOutput = {
     output: CryptoAmount;
@@ -91,9 +87,9 @@ export declare type ConstructMemo = {
     limit: BaseAmount;
     destinationAddress: Address;
     affiliateAddress: Address;
-    affiliateFee: BaseAmount;
+    affiliateFeeBasisPoints: number;
     feeOption?: FeeOption;
-    interfaceID: number;
+    interfaceID: string;
 };
 export declare type TxDetails = {
     memo: string;

package/lib/utils/swap.d.ts

@@ -58,6 +58,16 @@ export declare const getDoubleSwap: (inputAmount: CryptoAmount, pool1: Liquidity
  * @returns
  */
 export declare const calcNetworkFee: (asset: Asset, inbound: InboundDetail) => CryptoAmount;
+/**
+ * Works out the required outbound fee based on the chain.
+ * Call getInboundDetails to get the current outbound fee
+ *
+ * @param sourceAsset
+ * @param inbound detail
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+export declare const calcOutboundFee: (asset: Asset, inbound: InboundDetail) => CryptoAmount;
 /**
  * Return the chain for a given Asset This method should live somewhere else.
  * @param chain

package/package.json

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