@xchainjs/xchain-thorchain-query 0.1.10 → 0.1.12

package/lib/index.esm.js

@@ -1,11 +1,19 @@
-import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, assetFromString, baseAmount, AssetRuneNative, Chain, AssetAtom, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, assetFromStringEx, isAssetRuneNative, assetAmount } from '@xchainjs/xchain-util';
+import { BNBChain, AssetBNB } from '@xchainjs/xchain-binance';
+import { BTCChain, AssetBTC } from '@xchainjs/xchain-bitcoin';
+import { GAIAChain, AssetATOM } from '@xchainjs/xchain-cosmos';
+import { AssetRuneNative, THORChain, isAssetRuneNative } from '@xchainjs/xchain-thorchain';
+import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, assetFromString, baseAmount, assetFromStringEx, getContractAddressFromAsset, assetAmount } from '@xchainjs/xchain-util';
 import { BigNumber } from 'bignumber.js';
 import { Network } from '@xchainjs/xchain-client';
 import { MidgardApi, Configuration } from '@xchainjs/xchain-midgard';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
+import { AVAXChain, AssetAVAX } from '@xchainjs/xchain-avax';
+import { AssetBCH, BCHChain } from '@xchainjs/xchain-bitcoincash';
+import { DOGEChain, AssetDOGE } from '@xchainjs/xchain-doge';
+import { ETHChain, AssetETH } from '@xchainjs/xchain-ethereum';
+import { LTCChain, AssetLTC } from '@xchainjs/xchain-litecoin';
 import { TransactionsApi, Configuration as Configuration$1, QueueApi, NetworkApi, PoolsApi, LiquidityProvidersApi, SaversApi, QuoteApi } from '@xchainjs/xchain-thornode';
-import { baseAmount as baseAmount$1, AssetRuneNative as AssetRuneNative$1 } from '@xchainjs/xchain-util/lib';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -546,19 +554,19 @@ const calcNetworkFee = (asset, inbound) => {
     if (asset.synth)
         return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     switch (asset.chain) {
-        case Chain.Bitcoin:
+        case BTCChain:
             return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
-        case Chain.BitcoinCash:
+        case BTCChain:
             return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
-        case Chain.Litecoin:
+        case LTCChain:
             return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetLTC);
-        case Chain.Doge:
+        case DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
             return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
-        case Chain.Binance:
+        case BNBChain:
             //flat fee
             return new CryptoAmount(baseAmount(inbound.gasRate), AssetBNB);
-        case Chain.Ethereum:
+        case ETHChain:
             const gasRateinETHGwei = inbound.gasRate;
             const gasRateinETHWei = baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetETH)) {
@@ -567,7 +575,7 @@ const calcNetworkFee = (asset, inbound) => {
             else {
                 return new CryptoAmount(gasRateinETHWei.times(70000), AssetETH);
             }
-        case Chain.Avalanche:
+        case AVAXChain:
             const gasRateinAVAXGwei = inbound.gasRate;
             const gasRateinAVAXWei = baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetAVAX)) {
@@ -576,9 +584,9 @@ const calcNetworkFee = (asset, inbound) => {
             else {
                 return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
             }
-        case Chain.Cosmos:
-            return new CryptoAmount(baseAmount(inbound.gasRate), AssetAtom);
-        case Chain.THORChain:
+        case GAIAChain:
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetATOM);
+        case THORChain:
             return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
@@ -596,25 +604,25 @@ const calcOutboundFee = (asset, inbound) => {
     if (asset.synth)
         return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     switch (asset.chain) {
-        case Chain.Bitcoin:
+        case BTCChain:
             return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBTC);
-        case Chain.BitcoinCash:
+        case BTCChain:
             return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBCH);
-        case Chain.Litecoin:
+        case LTCChain:
             return new CryptoAmount(baseAmount(inbound.outboundFee), AssetLTC);
-        case Chain.Doge:
+        case DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
             return new CryptoAmount(baseAmount(inbound.outboundFee), AssetDOGE);
-        case Chain.Binance:
+        case BNBChain:
             //flat fee
             return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBNB);
-        case Chain.Ethereum:
+        case ETHChain:
             return new CryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetETH);
-        case Chain.Avalanche:
+        case AVAXChain:
             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:
+        case GAIAChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetATOM);
+        case THORChain:
             return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     }
     throw new Error(`could not calculate outbound fee for ${asset.chain}`);
@@ -634,15 +642,15 @@ const getChainAsset = (chain) => {
             return AssetETH;
         case THORChain:
             return AssetRuneNative;
-        case CosmosChain:
-            return AssetAtom;
+        case GAIAChain:
+            return AssetATOM;
         case BCHChain:
             return AssetBCH;
         case LTCChain:
             return AssetLTC;
         case DOGEChain:
             return AssetDOGE;
-        case AvalancheChain:
+        case AVAXChain:
             return AssetAVAX;
         default:
             throw Error('Unknown chain');
@@ -664,7 +672,7 @@ const getChain = (chain) => {
         case 'THOR':
             return THORChain;
         case 'GAIA':
-            return CosmosChain;
+            return GAIAChain;
         case 'BCH':
             return BCHChain;
         case 'LTC':
@@ -1123,7 +1131,7 @@ class ThorchainCache {
             }
             // add mock THORCHAIN inbound details
             const details = {
-                chain: Chain.THORChain,
+                chain: THORChain,
                 address: '',
                 router: '',
                 gasRate: new BigNumber(0),
@@ -1134,7 +1142,7 @@ class ThorchainCache {
                 haltedTrading: !!mimirDetails['HALTTRADING'],
                 haltedLP: false, //
             };
-            inboundDetails[Chain.THORChain] = details;
+            inboundDetails[THORChain] = details;
             this.inboundDetailCache = {
                 lastRefreshed: Date.now(),
                 inboundDetails,
@@ -1341,8 +1349,8 @@ const getPoolShare = (unitData, pool) => {
     const asset = T.times(units).div(total);
     const rune = R.times(units).div(total);
     const poolShareDetail = {
-        assetShare: new CryptoAmount(baseAmount$1(asset), pool.asset),
-        runeShare: new CryptoAmount(baseAmount$1(rune), AssetRuneNative$1),
+        assetShare: new CryptoAmount(baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(baseAmount(rune), AssetRuneNative),
     };
     return poolShareDetail;
 };
@@ -1391,7 +1399,7 @@ const getLiquidityProtectionData = (depositValue, poolShare, block) => {
     const result = coverage.times(protectionProgress); // impermanent loss protection result
     const maxILP = result.lt(0) ? new BigNumber(0) : result; // max negative ILP to 0
     const ILProtection = {
-        ILProtection: new CryptoAmount(baseAmount$1(maxILP), AssetRuneNative$1),
+        ILProtection: new CryptoAmount(baseAmount(maxILP), AssetRuneNative),
         totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
     };
     return ILProtection;
@@ -1597,6 +1605,15 @@ class ThorchainQuery {
             return swapEstimate;
         });
     }
+    abbreviateAssetString(asset) {
+        const contractAddress = getContractAddressFromAsset(asset);
+        if (contractAddress && contractAddress.length > 5) {
+            const abrev = contractAddress.substring(contractAddress.length - 5);
+            const sep = asset.chain !== THORChain && asset.synth ? '/' : '.';
+            return `${asset.chain}${sep}${asset.ticker}-${abrev}`;
+        }
+        return assetToString(asset);
+    }
     /**
      *
      * @param params - swap object
@@ -1605,21 +1622,16 @@ class ThorchainQuery {
     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);
-        // create the full memo
-        let memo = `=:${assetToString(params.destinationAsset)}`;
+        let memo = `=:${this.abbreviateAssetString(params.destinationAsset)}:${params.destinationAddress}:${lim}`;
         // NOTE: we should validate affiliate address is EITHER: a thorname or valid thorchain address, currently we cannot do this without importing xchain-thorchain
         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.affiliateFeeBasisPoints}`);
-        }
-        else {
-            memo = memo.concat(`:${params.destinationAddress}:${lim}`);
+            memo = memo.concat(`:${params.affiliateAddress}:${params.affiliateFeeBasisPoints}`);
         }
         // If memo length is too long for BTC, trim it
         if (eqAsset(params.input.asset, AssetBTC) && memo.length > 80) {
-            memo = `=:${assetToString(params.destinationAsset)}:${params.destinationAddress}`;
+            memo = `=:${this.abbreviateAssetString(params.destinationAsset)}:${params.destinationAddress}:${lim}`;
         }
         return memo;
     }
@@ -1628,7 +1640,7 @@ class ThorchainQuery {
     // private async validateAffiliateAddress(affiliateAddress: string) {
     //   // Affiliate address should be THORName or THORAddress
     //   if (affiliateAddress.length > 0) {
-    //     const isValidThorchainAddress = this.clients[Chain.THORChain].validateAddress(affiliateAddress)
+    //     const isValidThorchainAddress = this.clients[THORChain].validateAddress(affiliateAddress)
     //     const isValidThorname = await this.isThorname(affiliateAddress)
     //     if (!(isValidThorchainAddress || isValidThorname))
     //       throw Error(`affiliateAddress ${affiliateAddress} is not a valid THOR address`)
@@ -1755,10 +1767,10 @@ class ThorchainQuery {
         return __awaiter(this, void 0, void 0, function* () {
             // RUNE, BNB and Synths have near instant finality, so no conf counting required. - need to make a BFT only case.
             if (isAssetRuneNative(inbound.asset) ||
-                inbound.asset.chain == AssetBNB.chain ||
-                inbound.asset.chain == AssetAtom.chain ||
+                inbound.asset.chain == BNBChain ||
+                inbound.asset.chain == GAIAChain ||
                 inbound.asset.synth) {
-                return this.chainAttributes[Chain.THORChain].avgBlockTimeInSecs;
+                return this.chainAttributes[THORChain].avgBlockTimeInSecs;
             }
             // Get the gas asset for the inbound.asset.chain
             const chainGasAsset = getChainAsset(inbound.asset.chain);
@@ -1789,7 +1801,7 @@ class ThorchainQuery {
                 .amount()
                 .toNumber();
             const getScheduledOutboundValue = yield this.thorchainCache.midgard.getScheduledOutboundValue();
-            const thorChainblocktime = this.chainAttributes[Chain.THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
+            const thorChainblocktime = this.chainAttributes[THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
             // If asset is equal to Rune set runeValue as outbound amount else set it to the asset's value in rune
             const runeValue = yield this.thorchainCache.convert(outboundAmount, AssetRuneNative);
             // Check rune value amount
@@ -2277,7 +2289,7 @@ class TransactionStage {
                 case 1:
                     if (((_b = (_a = txData.observed_tx) === null || _a === void 0 ? void 0 : _a.tx) === null || _b === void 0 ? void 0 : _b.chain) != undefined) {
                         sourceChain = getChain(txData.observed_tx.tx.chain);
-                        if (sourceChain == (Chain.Bitcoin || Chain.BitcoinCash || Chain.Litecoin)) {
+                        if (sourceChain == (BTCChain || BCHChain || LTCChain)) {
                             const lastBlockHeight = lastBlock.find((obj) => obj.chain === sourceChain);
                             const checkConf = yield this.checkConfcounting(sourceChain, lastBlockHeight, txData.observed_tx);
                             transactionProgress.seconds = checkConf.seconds;

package/lib/index.js

@@ -2,14 +2,22 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var xchainBinance = require('@xchainjs/xchain-binance');
+var xchainBitcoin = require('@xchainjs/xchain-bitcoin');
+var xchainCosmos = require('@xchainjs/xchain-cosmos');
+var xchainThorchain = require('@xchainjs/xchain-thorchain');
 var xchainUtil = require('@xchainjs/xchain-util');
 var bignumber_js = require('bignumber.js');
 var xchainClient = require('@xchainjs/xchain-client');
 var xchainMidgard = require('@xchainjs/xchain-midgard');
 var axios = require('axios');
 var axiosRetry = require('axios-retry');
+var xchainAvax = require('@xchainjs/xchain-avax');
+var xchainBitcoincash = require('@xchainjs/xchain-bitcoincash');
+var xchainDoge = require('@xchainjs/xchain-doge');
+var xchainEthereum = require('@xchainjs/xchain-ethereum');
+var xchainLitecoin = require('@xchainjs/xchain-litecoin');
 var xchainThornode = require('@xchainjs/xchain-thornode');
-var lib = require('@xchainjs/xchain-util/lib');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -278,7 +286,7 @@ class Midgard {
             for (const baseUrl of this.config.midgardBaseUrls) {
                 try {
                     const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
-                    const value = new CryptoAmount(xchainUtil.baseAmount(data['scheduled_outbound_value']), xchainUtil.AssetRuneNative);
+                    const value = new CryptoAmount(xchainUtil.baseAmount(data['scheduled_outbound_value']), xchainThorchain.AssetRuneNative);
                     return value;
                 }
                 catch (e) {
@@ -436,7 +444,7 @@ const getSwapFee = (inputAmount, pool, toRune) => {
     const x = getBaseAmountWithDiffDecimals(inputAmount, 8);
     const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
     const Y = toRune ? pool.runeBalance.amount() : pool.assetBalance.amount(); // output is rune if toRune
-    const units = toRune ? xchainUtil.AssetRuneNative : pool.asset;
+    const units = toRune ? xchainThorchain.AssetRuneNative : pool.asset;
     const numerator = x.times(x).multipliedBy(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
@@ -475,7 +483,7 @@ const getSwapOutput = (inputAmount, pool, toRune) => {
     const x = getBaseAmountWithDiffDecimals(inputAmount, 8);
     const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
     const Y = toRune ? pool.runeBalance.amount() : pool.assetBalance.amount(); // output is rune if toRune
-    const units = toRune ? xchainUtil.AssetRuneNative : pool.asset;
+    const units = toRune ? xchainThorchain.AssetRuneNative : pool.asset;
     // const decimals = toRune || !pool.decimals ? 8 : pool.decimals
     const numerator = x.times(X).times(Y);
     const denominator = x.plus(X).pow(2);
@@ -520,7 +528,7 @@ const getDoubleSwapFee = (inputAmount, pool1, pool2, thorchainCache) => __awaite
     const fee1InRune = getSwapFee(inputAmount, pool1, true);
     const swapOutput = getSwapOutput(inputAmount, pool1, true);
     const fee2InAsset = getSwapFee(swapOutput, pool2, false);
-    const fee2InRune = yield thorchainCache.convert(fee2InAsset, xchainUtil.AssetRuneNative);
+    const fee2InRune = yield thorchainCache.convert(fee2InAsset, xchainThorchain.AssetRuneNative);
     const result = fee1InRune.plus(fee2InRune);
     return result;
 });
@@ -553,42 +561,42 @@ const getDoubleSwap = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(v
  */
 const calcNetworkFee = (asset, inbound) => {
     if (asset.synth)
-        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
     switch (asset.chain) {
-        case xchainUtil.Chain.Bitcoin:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainUtil.AssetBTC);
-        case xchainUtil.Chain.BitcoinCash:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainUtil.AssetBCH);
-        case xchainUtil.Chain.Litecoin:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainUtil.AssetLTC);
-        case xchainUtil.Chain.Doge:
+        case xchainBitcoin.BTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainBitcoin.AssetBTC);
+        case xchainBitcoin.BTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainBitcoincash.AssetBCH);
+        case xchainLitecoin.LTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainLitecoin.AssetLTC);
+        case xchainDoge.DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainUtil.AssetDOGE);
-        case xchainUtil.Chain.Binance:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), xchainDoge.AssetDOGE);
+        case xchainBinance.BNBChain:
             //flat fee
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainUtil.AssetBNB);
-        case xchainUtil.Chain.Ethereum:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainBinance.AssetBNB);
+        case xchainEthereum.ETHChain:
             const gasRateinETHGwei = inbound.gasRate;
             const gasRateinETHWei = xchainUtil.baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
-            if (xchainUtil.eqAsset(asset, xchainUtil.AssetETH)) {
-                return new CryptoAmount(gasRateinETHWei.times(21000), xchainUtil.AssetETH);
+            if (xchainUtil.eqAsset(asset, xchainEthereum.AssetETH)) {
+                return new CryptoAmount(gasRateinETHWei.times(21000), xchainEthereum.AssetETH);
             }
             else {
-                return new CryptoAmount(gasRateinETHWei.times(70000), xchainUtil.AssetETH);
+                return new CryptoAmount(gasRateinETHWei.times(70000), xchainEthereum.AssetETH);
             }
-        case xchainUtil.Chain.Avalanche:
+        case xchainAvax.AVAXChain:
             const gasRateinAVAXGwei = inbound.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.AssetAVAX);
+            if (xchainUtil.eqAsset(asset, xchainAvax.AssetAVAX)) {
+                return new CryptoAmount(gasRateinAVAXWei.times(21000), xchainAvax.AssetAVAX);
             }
             else {
-                return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainUtil.AssetAVAX);
+                return new CryptoAmount(gasRateinAVAXWei.times(70000), xchainAvax.AssetAVAX);
             }
-        case xchainUtil.Chain.Cosmos:
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainUtil.AssetAtom);
-        case xchainUtil.Chain.THORChain:
-            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+        case xchainCosmos.GAIAChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.gasRate), xchainCosmos.AssetATOM);
+        case xchainThorchain.THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
@@ -603,28 +611,28 @@ const calcNetworkFee = (asset, inbound) => {
  */
 const calcOutboundFee = (asset, inbound) => {
     if (asset.synth)
-        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.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:
+        case xchainBitcoin.BTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainBitcoin.AssetBTC);
+        case xchainBitcoin.BTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainBitcoincash.AssetBCH);
+        case xchainLitecoin.LTCChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainLitecoin.AssetLTC);
+        case xchainDoge.DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainUtil.AssetDOGE);
-        case xchainUtil.Chain.Binance:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainDoge.AssetDOGE);
+        case xchainBinance.BNBChain:
             //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);
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainBinance.AssetBNB);
+        case xchainEthereum.ETHChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), xchainEthereum.AssetETH);
+        case xchainAvax.AVAXChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), xchainAvax.AssetAVAX);
+        case xchainCosmos.GAIAChain:
+            return new CryptoAmount(xchainUtil.baseAmount(inbound.outboundFee), xchainCosmos.AssetATOM);
+        case xchainThorchain.THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainThorchain.AssetRuneNative);
     }
     throw new Error(`could not calculate outbound fee for ${asset.chain}`);
 };
@@ -635,24 +643,24 @@ const calcOutboundFee = (asset, inbound) => {
  */
 const getChainAsset = (chain) => {
     switch (chain) {
-        case xchainUtil.BNBChain:
-            return xchainUtil.AssetBNB;
-        case xchainUtil.BTCChain:
-            return xchainUtil.AssetBTC;
-        case xchainUtil.ETHChain:
-            return xchainUtil.AssetETH;
-        case xchainUtil.THORChain:
-            return xchainUtil.AssetRuneNative;
-        case xchainUtil.CosmosChain:
-            return xchainUtil.AssetAtom;
-        case xchainUtil.BCHChain:
-            return xchainUtil.AssetBCH;
-        case xchainUtil.LTCChain:
-            return xchainUtil.AssetLTC;
-        case xchainUtil.DOGEChain:
-            return xchainUtil.AssetDOGE;
-        case xchainUtil.AvalancheChain:
-            return xchainUtil.AssetAVAX;
+        case xchainBinance.BNBChain:
+            return xchainBinance.AssetBNB;
+        case xchainBitcoin.BTCChain:
+            return xchainBitcoin.AssetBTC;
+        case xchainEthereum.ETHChain:
+            return xchainEthereum.AssetETH;
+        case xchainThorchain.THORChain:
+            return xchainThorchain.AssetRuneNative;
+        case xchainCosmos.GAIAChain:
+            return xchainCosmos.AssetATOM;
+        case xchainBitcoincash.BCHChain:
+            return xchainBitcoincash.AssetBCH;
+        case xchainLitecoin.LTCChain:
+            return xchainLitecoin.AssetLTC;
+        case xchainDoge.DOGEChain:
+            return xchainDoge.AssetDOGE;
+        case xchainAvax.AVAXChain:
+            return xchainAvax.AssetAVAX;
         default:
             throw Error('Unknown chain');
     }
@@ -665,21 +673,21 @@ const getChainAsset = (chain) => {
 const getChain = (chain) => {
     switch (chain) {
         case 'BNB':
-            return xchainUtil.BNBChain;
+            return xchainBinance.BNBChain;
         case 'BTC':
-            return xchainUtil.BTCChain;
+            return xchainBitcoin.BTCChain;
         case 'ETH':
-            return xchainUtil.ETHChain;
+            return xchainEthereum.ETHChain;
         case 'THOR':
-            return xchainUtil.THORChain;
+            return xchainThorchain.THORChain;
         case 'GAIA':
-            return xchainUtil.CosmosChain;
+            return xchainCosmos.GAIAChain;
         case 'BCH':
-            return xchainUtil.BCHChain;
+            return xchainBitcoincash.BCHChain;
         case 'LTC':
-            return xchainUtil.LTCChain;
+            return xchainLitecoin.LTCChain;
         case 'DOGE':
-            return xchainUtil.DOGEChain;
+            return xchainDoge.DOGEChain;
         default:
             throw Error('Unknown chain');
     }
@@ -1001,12 +1009,12 @@ class ThorchainCache {
             if (xchainUtil.eqAsset(from, to)) {
                 exchangeRate = SAME_ASSET_EXCHANGE_RATE;
             }
-            else if (xchainUtil.isAssetRuneNative(from)) {
+            else if (xchainThorchain.isAssetRuneNative(from)) {
                 //  Runes per Asset
                 const lpTo = yield this.getPoolForAsset(to);
                 exchangeRate = lpTo.assetToRuneRatio;
             }
-            else if (xchainUtil.isAssetRuneNative(to)) {
+            else if (xchainThorchain.isAssetRuneNative(to)) {
                 //  Asset per rune
                 const lpFrom = yield this.getPoolForAsset(from);
                 exchangeRate = lpFrom.runeToAssetRatio;
@@ -1030,7 +1038,7 @@ class ThorchainCache {
      */
     getPoolForAsset(asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (xchainUtil.isAssetRuneNative(asset))
+            if (xchainThorchain.isAssetRuneNative(asset))
                 throw Error(`AssetRuneNative doesn't have a pool`);
             const pools = yield this.getPools();
             // Note: we use ticker, not asset string to get the same pool for both assets and synths
@@ -1132,7 +1140,7 @@ class ThorchainCache {
             }
             // add mock THORCHAIN inbound details
             const details = {
-                chain: xchainUtil.Chain.THORChain,
+                chain: xchainThorchain.THORChain,
                 address: '',
                 router: '',
                 gasRate: new bignumber_js.BigNumber(0),
@@ -1143,7 +1151,7 @@ class ThorchainCache {
                 haltedTrading: !!mimirDetails['HALTTRADING'],
                 haltedLP: false, //
             };
-            inboundDetails[xchainUtil.Chain.THORChain] = details;
+            inboundDetails[xchainThorchain.THORChain] = details;
             this.inboundDetailCache = {
                 lastRefreshed: Date.now(),
                 inboundDetails,
@@ -1180,12 +1188,12 @@ class ThorchainCache {
     getExpectedSwapOutput(inputAmount, destinationAsset) {
         return __awaiter(this, void 0, void 0, function* () {
             let swapOutput;
-            if (xchainUtil.isAssetRuneNative(inputAmount.asset)) {
+            if (xchainThorchain.isAssetRuneNative(inputAmount.asset)) {
                 //singleswap from rune -> asset
                 const pool = yield this.getPoolForAsset(destinationAsset);
                 swapOutput = getSingleSwap(inputAmount, pool, false);
             }
-            else if (xchainUtil.isAssetRuneNative(destinationAsset)) {
+            else if (xchainThorchain.isAssetRuneNative(destinationAsset)) {
                 //singleswap from  asset -> rune
                 const pool = yield this.getPoolForAsset(inputAmount.asset);
                 swapOutput = getSingleSwap(inputAmount, pool, true);
@@ -1228,7 +1236,7 @@ class ThorchainCache {
     }
     getDecimalForAsset(asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!xchainUtil.isAssetRuneNative(asset)) {
+            if (!xchainThorchain.isAssetRuneNative(asset)) {
                 const pool = yield this.getPoolForAsset(asset);
                 const decimals = Number(pool.pool.nativeDecimal);
                 if (decimals > 0)
@@ -1350,8 +1358,8 @@ const getPoolShare = (unitData, pool) => {
     const asset = T.times(units).div(total);
     const rune = R.times(units).div(total);
     const poolShareDetail = {
-        assetShare: new CryptoAmount(lib.baseAmount(asset), pool.asset),
-        runeShare: new CryptoAmount(lib.baseAmount(rune), lib.AssetRuneNative),
+        assetShare: new CryptoAmount(xchainUtil.baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(xchainUtil.baseAmount(rune), xchainThorchain.AssetRuneNative),
     };
     return poolShareDetail;
 };
@@ -1400,7 +1408,7 @@ const getLiquidityProtectionData = (depositValue, poolShare, block) => {
     const result = coverage.times(protectionProgress); // impermanent loss protection result
     const maxILP = result.lt(0) ? new bignumber_js.BigNumber(0) : result; // max negative ILP to 0
     const ILProtection = {
-        ILProtection: new CryptoAmount(lib.baseAmount(maxILP), lib.AssetRuneNative),
+        ILProtection: new CryptoAmount(xchainUtil.baseAmount(maxILP), xchainThorchain.AssetRuneNative),
         totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
     };
     return ILProtection;
@@ -1518,7 +1526,7 @@ class ThorchainQuery {
     isValidSwap(params) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (xchainUtil.isAssetRuneNative(params.input.asset)) {
+            if (xchainThorchain.isAssetRuneNative(params.input.asset)) {
                 if (params.input.baseAmount.decimal !== 8)
                     throw Error(`input asset ${xchainUtil.assetToString(params.input.asset)}  must have decimals of 8`);
             }
@@ -1572,15 +1580,15 @@ class ThorchainQuery {
             const affiliateFeePercent = params.affiliateFeeBasisPoints ? params.affiliateFeeBasisPoints / 10000 : 0;
             const affiliateFeeInAsset = inputMinusInboundFeeInAsset.times(affiliateFeePercent);
             let affiliateFeeSwapOutputInRune;
-            if (xchainUtil.isAssetRuneNative(affiliateFeeInAsset.asset)) {
+            if (xchainThorchain.isAssetRuneNative(affiliateFeeInAsset.asset)) {
                 affiliateFeeSwapOutputInRune = {
                     output: affiliateFeeInAsset,
-                    swapFee: new CryptoAmount(xchainUtil.baseAmount(0), xchainUtil.AssetRuneNative),
+                    swapFee: new CryptoAmount(xchainUtil.baseAmount(0), xchainThorchain.AssetRuneNative),
                     slip: new bignumber_js.BigNumber(0),
                 };
             }
             else {
-                affiliateFeeSwapOutputInRune = yield this.thorchainCache.getExpectedSwapOutput(affiliateFeeInAsset, xchainUtil.AssetRuneNative);
+                affiliateFeeSwapOutputInRune = yield this.thorchainCache.getExpectedSwapOutput(affiliateFeeInAsset, xchainThorchain.AssetRuneNative);
             }
             // remove the affiliate fee from the input.
             const inputNetInAsset = inputMinusInboundFeeInAsset.minus(affiliateFeeInAsset);
@@ -1606,6 +1614,15 @@ class ThorchainQuery {
             return swapEstimate;
         });
     }
+    abbreviateAssetString(asset) {
+        const contractAddress = xchainUtil.getContractAddressFromAsset(asset);
+        if (contractAddress && contractAddress.length > 5) {
+            const abrev = contractAddress.substring(contractAddress.length - 5);
+            const sep = asset.chain !== xchainThorchain.THORChain && asset.synth ? '/' : '.';
+            return `${asset.chain}${sep}${asset.ticker}-${abrev}`;
+        }
+        return xchainUtil.assetToString(asset);
+    }
     /**
      *
      * @param params - swap object
@@ -1614,21 +1631,16 @@ class ThorchainQuery {
     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);
-        // create the full memo
-        let memo = `=:${xchainUtil.assetToString(params.destinationAsset)}`;
+        let memo = `=:${this.abbreviateAssetString(params.destinationAsset)}:${params.destinationAddress}:${lim}`;
         // NOTE: we should validate affiliate address is EITHER: a thorname or valid thorchain address, currently we cannot do this without importing xchain-thorchain
         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.affiliateFeeBasisPoints}`);
-        }
-        else {
-            memo = memo.concat(`:${params.destinationAddress}:${lim}`);
+            memo = memo.concat(`:${params.affiliateAddress}:${params.affiliateFeeBasisPoints}`);
         }
         // If memo length is too long for BTC, trim it
-        if (xchainUtil.eqAsset(params.input.asset, xchainUtil.AssetBTC) && memo.length > 80) {
-            memo = `=:${xchainUtil.assetToString(params.destinationAsset)}:${params.destinationAddress}`;
+        if (xchainUtil.eqAsset(params.input.asset, xchainBitcoin.AssetBTC) && memo.length > 80) {
+            memo = `=:${this.abbreviateAssetString(params.destinationAsset)}:${params.destinationAddress}:${lim}`;
         }
         return memo;
     }
@@ -1637,7 +1649,7 @@ class ThorchainQuery {
     // private async validateAffiliateAddress(affiliateAddress: string) {
     //   // Affiliate address should be THORName or THORAddress
     //   if (affiliateAddress.length > 0) {
-    //     const isValidThorchainAddress = this.clients[Chain.THORChain].validateAddress(affiliateAddress)
+    //     const isValidThorchainAddress = this.clients[THORChain].validateAddress(affiliateAddress)
     //     const isValidThorname = await this.isThorname(affiliateAddress)
     //     if (!(isValidThorchainAddress || isValidThorname))
     //       throw Error(`affiliateAddress ${affiliateAddress} is not a valid THOR address`)
@@ -1665,12 +1677,12 @@ class ThorchainQuery {
             const errors = [];
             const sourceAsset = params.input.asset;
             const destAsset = params.destinationAsset;
-            if (!xchainUtil.isAssetRuneNative(sourceAsset)) {
+            if (!xchainThorchain.isAssetRuneNative(sourceAsset)) {
                 const sourcePool = yield this.thorchainCache.getPoolForAsset(sourceAsset);
                 if (!sourcePool.isAvailable())
                     errors.push(`sourceAsset ${sourceAsset.ticker} does not have a valid liquidity pool`);
             }
-            if (!xchainUtil.isAssetRuneNative(destAsset)) {
+            if (!xchainThorchain.isAssetRuneNative(destAsset)) {
                 const destPool = yield this.thorchainCache.getPoolForAsset(destAsset);
                 if (!destPool.isAvailable())
                     errors.push(`destinationAsset ${destAsset.ticker} does not have a valid liquidity pool`);
@@ -1704,8 +1716,8 @@ class ThorchainQuery {
     checkCoverFees(params, estimate) {
         return __awaiter(this, void 0, void 0, function* () {
             let result = undefined;
-            const inputInRune = yield this.thorchainCache.convert(params.input, xchainUtil.AssetRuneNative);
-            const feesInRune = yield this.getFeesIn(estimate.totalFees, xchainUtil.AssetRuneNative);
+            const inputInRune = yield this.thorchainCache.convert(params.input, xchainThorchain.AssetRuneNative);
+            const feesInRune = yield this.getFeesIn(estimate.totalFees, xchainThorchain.AssetRuneNative);
             const totalSwapFeesInRune = feesInRune.inboundFee
                 .plus(feesInRune.outboundFee)
                 .plus(feesInRune.swapFee)
@@ -1763,11 +1775,11 @@ class ThorchainQuery {
     confCounting(inbound) {
         return __awaiter(this, void 0, void 0, function* () {
             // RUNE, BNB and Synths have near instant finality, so no conf counting required. - need to make a BFT only case.
-            if (xchainUtil.isAssetRuneNative(inbound.asset) ||
-                inbound.asset.chain == xchainUtil.AssetBNB.chain ||
-                inbound.asset.chain == xchainUtil.AssetAtom.chain ||
+            if (xchainThorchain.isAssetRuneNative(inbound.asset) ||
+                inbound.asset.chain == xchainBinance.BNBChain ||
+                inbound.asset.chain == xchainCosmos.GAIAChain ||
                 inbound.asset.synth) {
-                return this.chainAttributes[xchainUtil.Chain.THORChain].avgBlockTimeInSecs;
+                return this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs;
             }
             // Get the gas asset for the inbound.asset.chain
             const chainGasAsset = getChainAsset(inbound.asset.chain);
@@ -1792,15 +1804,15 @@ class ThorchainQuery {
     outboundDelay(outboundAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const networkValues = yield this.thorchainCache.getNetworkValues();
-            const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), xchainUtil.AssetRuneNative);
+            const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), xchainThorchain.AssetRuneNative);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
-            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainUtil.AssetRuneNative).assetAmount
+            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainThorchain.AssetRuneNative).assetAmount
                 .amount()
                 .toNumber();
             const getScheduledOutboundValue = yield this.thorchainCache.midgard.getScheduledOutboundValue();
-            const thorChainblocktime = this.chainAttributes[xchainUtil.Chain.THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
+            const thorChainblocktime = this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
             // If asset is equal to Rune set runeValue as outbound amount else set it to the asset's value in rune
-            const runeValue = yield this.thorchainCache.convert(outboundAmount, xchainUtil.AssetRuneNative);
+            const runeValue = yield this.thorchainCache.convert(outboundAmount, xchainThorchain.AssetRuneNative);
             // Check rune value amount
             if (runeValue.lt(minTxOutVolumeThreshold)) {
                 return thorChainblocktime;
@@ -1831,7 +1843,7 @@ class ThorchainQuery {
             const errors = [];
             if (params.asset.asset.synth || params.rune.asset.synth)
                 errors.push('you cannot add liquidity with a synth');
-            if (!xchainUtil.isAssetRuneNative(params.rune.asset))
+            if (!xchainThorchain.isAssetRuneNative(params.rune.asset))
                 errors.push('params.rune must be THOR.RUNE');
             const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset.asset);
             const lpUnits = getLiquidityUnits({ asset: params.asset, rune: params.rune }, assetPool);
@@ -1845,7 +1857,7 @@ class ThorchainQuery {
             const runeWaitTimeSeconds = yield this.confCounting(params.rune);
             const waitTimeSeconds = assetWaitTimeSeconds > runeWaitTimeSeconds ? assetWaitTimeSeconds : runeWaitTimeSeconds;
             let assetInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), params.asset.asset);
-            let runeInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), xchainUtil.AssetRuneNative);
+            let runeInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), xchainThorchain.AssetRuneNative);
             if (!params.asset.assetAmount.eq(0)) {
                 assetInboundFee = calcNetworkFee(params.asset.asset, inboundDetails[params.asset.asset.chain]);
                 if (assetInboundFee.assetAmount.amount().times(3).gt(params.asset.assetAmount.amount()))
@@ -1856,7 +1868,7 @@ class ThorchainQuery {
                 if (runeInboundFee.assetAmount.amount().times(3).gt(params.rune.assetAmount.amount()))
                     errors.push(`Rune amount is less than fees`);
             }
-            const totalFees = (yield this.convert(assetInboundFee, xchainUtil.AssetRuneNative)).plus(runeInboundFee);
+            const totalFees = (yield this.convert(assetInboundFee, xchainThorchain.AssetRuneNative)).plus(runeInboundFee);
             const slip = getSlipOnLiquidity({ asset: params.asset, rune: params.rune }, assetPool);
             const estimateLP = {
                 assetPool: assetPool.pool.asset,
@@ -1986,9 +1998,9 @@ class ThorchainQuery {
             }
             const allInboundDetails = yield this.thorchainCache.getInboundDetails();
             const inboundDetails = allInboundDetails[params.asset.chain];
-            const runeInbound = calcNetworkFee(xchainUtil.AssetRuneNative, inboundDetails);
+            const runeInbound = calcNetworkFee(xchainThorchain.AssetRuneNative, inboundDetails);
             const assetInbound = calcNetworkFee(params.asset, inboundDetails);
-            const runeOutbound = calcOutboundFee(xchainUtil.AssetRuneNative, inboundDetails);
+            const runeOutbound = calcOutboundFee(xchainThorchain.AssetRuneNative, inboundDetails);
             const assetOutbound = calcOutboundFee(params.asset, inboundDetails);
             const estimateLP = {
                 assetAddress: memberDetail.position.asset_address,
@@ -1998,18 +2010,18 @@ class ThorchainQuery {
                     minToSend: {
                         rune: dustValues.rune,
                         asset: dustValues.asset,
-                        total: (yield this.convert(dustValues.asset, xchainUtil.AssetRuneNative)).plus(dustValues.rune),
+                        total: (yield this.convert(dustValues.asset, xchainThorchain.AssetRuneNative)).plus(dustValues.rune),
                     },
                     fees: {
                         rune: runeInbound,
                         asset: assetInbound,
-                        total: (yield this.convert(assetInbound, xchainUtil.AssetRuneNative)).plus(runeInbound),
+                        total: (yield this.convert(assetInbound, xchainThorchain.AssetRuneNative)).plus(runeInbound),
                     },
                 },
                 outboundFee: {
                     asset: assetOutbound,
                     rune: runeOutbound,
-                    total: (yield this.convert(assetOutbound, xchainUtil.AssetRuneNative)).plus(runeOutbound),
+                    total: (yield this.convert(assetOutbound, xchainThorchain.AssetRuneNative)).plus(runeOutbound),
                 },
                 assetAmount: poolShare.assetShare,
                 runeAmount: poolShare.runeShare,
@@ -2032,8 +2044,8 @@ class ThorchainQuery {
             switch (asset.chain) {
                 case 'BNB':
                     dustValues = {
-                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.000001)), xchainUtil.AssetBNB),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.000001)), xchainBinance.AssetBNB),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 case 'BTC':
@@ -2042,42 +2054,42 @@ class ThorchainQuery {
                     // 10k sats
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.0001)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 case 'ETH':
                     // 0 wei
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 case 'THOR':
                     // 0 Rune
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 case 'GAIA':
                     // 0 GAIA
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 case 'DOGE':
                     // 1 million sats
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.01)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 case 'AVAX':
                     // 0 AVAX
                     dustValues = {
                         asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
-                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainThorchain.AssetRuneNative),
                     };
                     return dustValues;
                 default:
@@ -2151,7 +2163,7 @@ class ThorchainQuery {
      */
     estimateWithdrawSaver(withdrawParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (xchainUtil.isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
+            if (xchainThorchain.isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
                 throw Error(`Native Rune and synth assets are not supported only L1's`);
             const withdrawQuote = yield this.thorchainCache.thornode.getSaversWithdrawQuote(withdrawParams);
             if (!withdrawQuote.expected_amount_out)
@@ -2286,7 +2298,7 @@ class TransactionStage {
                 case 1:
                     if (((_b = (_a = txData.observed_tx) === null || _a === void 0 ? void 0 : _a.tx) === null || _b === void 0 ? void 0 : _b.chain) != undefined) {
                         sourceChain = getChain(txData.observed_tx.tx.chain);
-                        if (sourceChain == (xchainUtil.Chain.Bitcoin || xchainUtil.Chain.BitcoinCash || xchainUtil.Chain.Litecoin)) {
+                        if (sourceChain == (xchainBitcoin.BTCChain || xchainBitcoincash.BCHChain || xchainLitecoin.LTCChain)) {
                             const lastBlockHeight = lastBlock.find((obj) => obj.chain === sourceChain);
                             const checkConf = yield this.checkConfcounting(sourceChain, lastBlockHeight, txData.observed_tx);
                             transactionProgress.seconds = checkConf.seconds;
@@ -2396,7 +2408,7 @@ class TransactionStage {
             else {
                 if ((scheduledQueueItem === null || scheduledQueueItem === void 0 ? void 0 : scheduledQueueItem.height) && (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) {
                     stageStatus.seconds =
-                        (scheduledQueueItem.height - (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) * this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs;
+                        (scheduledQueueItem.height - (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) * this.chainAttributes[xchainThorchain.THORChain].avgBlockTimeInSecs;
                 }
             }
             return stageStatus;

package/lib/thorchain-checktx.d.ts

@@ -4,7 +4,7 @@ import { ChainAttributes, TransactionProgress } from './types';
 export declare class TransactionStage {
     readonly thorchainCache: ThorchainCache;
     private chainAttributes;
-    constructor(thorchainCache: ThorchainCache, chainAttributes?: Record<Chain, ChainAttributes>);
+    constructor(thorchainCache: ThorchainCache, chainAttributes?: Record<string, ChainAttributes>);
     /**
      *
      * @param inboundTxHash - Input needed to determine the transaction stage

package/lib/thorchain-query.d.ts

@@ -1,4 +1,4 @@
-import { Asset, Chain } from '@xchainjs/xchain-util';
+import { Asset } from '@xchainjs/xchain-util';
 import { CryptoAmount } from './crypto-amount';
 import { ThorchainCache } from './thorchain-cache';
 import { AddliquidityPosition, ChainAttributes, EstimateAddLP, EstimateAddSaver, EstimateSwapParams, EstimateWithdrawLP, EstimateWithdrawSaver, LiquidityPosition, PoolRatios, SaversPosition, SaversWithdraw, TotalFees, TxDetails, WithdrawLiquidityPosition, getSaver } from './types';
@@ -17,7 +17,7 @@ export declare class ThorchainQuery {
      * @param chainAttributes - atrributes used to calculate waitTime & conf counting
      * @returns ThorchainAMM
      */
-    constructor(thorchainCache?: ThorchainCache, chainAttributes?: Record<Chain, ChainAttributes>);
+    constructor(thorchainCache?: ThorchainCache, chainAttributes?: Record<string, ChainAttributes>);
     /**
      * Provides a swap estimate for the given swap detail. Will check the params for errors before trying to get the estimate.
      * Uses current pool data, works out inbound and outboud fee, affiliate fees and works out the expected wait time for the swap (in and out)
@@ -45,6 +45,7 @@ export declare class ThorchainQuery {
      * @returns
      */
     private calcSwapEstimate;
+    private abbreviateAssetString;
     /**
      *
      * @param params - swap object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-query",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "license": "MIT",
   "description": "Thorchain query module that is resposible for estimating swap calculations and add/remove liquidity for thorchain ",
   "keywords": [
@@ -33,20 +33,38 @@
     "postversion": "git push --follow-tags"
   },
   "devDependencies": {
-    "@xchainjs/xchain-client": "^0.13.4",
+    "@xchainjs/xchain-avax": "^0.1.3",
+    "@xchainjs/xchain-binance": "^5.6.6",
+    "@xchainjs/xchain-bitcoin": "^0.20.7",
+    "@xchainjs/xchain-bitcoincash": "^0.15.6",
+    "@xchainjs/xchain-client": "^0.13.5",
+    "@xchainjs/xchain-cosmos": "^0.20.6",
+    "@xchainjs/xchain-doge": "^0.5.6",
+    "@xchainjs/xchain-ethereum": "^0.27.6",
+    "@xchainjs/xchain-litecoin": "^0.10.8",
     "@xchainjs/xchain-midgard": "^0.4.0",
+    "@xchainjs/xchain-thorchain": "^0.27.7",
     "@xchainjs/xchain-thornode": "^0.1.3",
-    "@xchainjs/xchain-util": "^0.11.0",
+    "@xchainjs/xchain-util": "^0.12.0",
     "axios": "^0.25.0",
     "axios-retry": "^3.2.5",
     "bignumber.js": "^9.0.0",
     "rimraf": "~3.0.2"
   },
   "peerDependencies": {
-    "@xchainjs/xchain-client": "^0.13.4",
+    "@xchainjs/xchain-avax": "^0.1.3",
+    "@xchainjs/xchain-binance": "^5.6.6",
+    "@xchainjs/xchain-bitcoincash": "^0.15.6",
+    "@xchainjs/xchain-cosmos": "^0.20.6",
+    "@xchainjs/xchain-doge": "^0.5.6",
+    "@xchainjs/xchain-ethereum": "^0.27.6",
+    "@xchainjs/xchain-bitcoin": "^0.20.7",
+    "@xchainjs/xchain-litecoin": "^0.10.8",
+    "@xchainjs/xchain-client": "^0.13.5",
     "@xchainjs/xchain-midgard": "^0.4.1",
+    "@xchainjs/xchain-thorchain": "^0.27.7",
     "@xchainjs/xchain-thornode": "^0.1.5",
-    "@xchainjs/xchain-util": "^0.11.1",
+    "@xchainjs/xchain-util": "^0.12.0",
     "axios": "^0.25.0",
     "axios-retry": "^3.2.5",
     "bignumber.js": "^9.0.0",