@xchainjs/xchain-thorchain-query 0.7.17 → 1.0.1

package/lib/index.esm.js

@@ -1,8 +1,8 @@
-import { assetFromString, baseAmount, assetFromStringEx, assetToString, CryptoAmount, eqAsset, CachedValue, assetToBase, assetAmount } from '@xchainjs/xchain-util';
+import { assetFromString, baseAmount, assetFromStringEx, assetToString, CryptoAmount, isSynthAsset, AssetCryptoAmount, eqAsset, CachedValue, isTradeAsset, assetToBase, assetAmount } from '@xchainjs/xchain-util';
 import { BigNumber } from 'bignumber.js';
 import { MidgardQuery } from '@xchainjs/xchain-midgard-query';
 import { Network } from '@xchainjs/xchain-client';
-import { TransactionsApi, Configuration, QueueApi, NetworkApi, PoolsApi, LiquidityProvidersApi, SaversApi, QuoteApi, MimirApi, ThornamesApi } from '@xchainjs/xchain-thornode';
+import { TransactionsApi, Configuration, QueueApi, NetworkApi, PoolsApi, LiquidityProvidersApi, SaversApi, QuoteApi, MimirApi, ThornamesApi, TradeUnitApi, TradeUnitsApi, TradeAccountApi, TradeAccountsApi, RUNEPoolApi } from '@xchainjs/xchain-thornode';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
 
@@ -188,49 +188,48 @@ const getChainAsset = (chain) => {
  */
 const calcNetworkFee = (asset, inbound) => {
     // synths are always 0.02R fee
-    if (asset.synth)
-        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+    if (isSynthAsset(asset))
+        return new AssetCryptoAmount(baseAmount(2000000), AssetRuneNative);
     // if you are swapping a non-gas asset  on a multiAsset chain (ex. ERC-20 on ETH), the
     // gas fees will be paid in a diff asset than the one you are swapping
     switch (asset.chain) {
         case BTCChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBTC);
         case BCHChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetBCH);
         case LTCChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetLTC);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetLTC);
         case DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate.multipliedBy(inbound.outboundTxSize)), AssetDOGE);
         case BNBChain:
-            //flat fee
-            return new CryptoAmount(baseAmount(inbound.gasRate), AssetBNB);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate), AssetBNB);
         case ETHChain:
             const gasRateinETHGwei = inbound.gasRate;
             const gasRateinETHWei = baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetETH)) {
-                return new CryptoAmount(gasRateinETHWei.times(21000), AssetETH);
+                return new AssetCryptoAmount(gasRateinETHWei.times(21000), AssetETH);
             }
             else {
-                return new CryptoAmount(gasRateinETHWei.times(70000), AssetETH);
+                return new AssetCryptoAmount(gasRateinETHWei.times(70000), AssetETH);
             }
         case AVAXChain:
             const gasRateinAVAXGwei = inbound.gasRate;
             const gasRateinAVAXWei = baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetAVAX)) {
-                return new CryptoAmount(gasRateinAVAXWei.times(21000), AssetAVAX);
+                return new AssetCryptoAmount(gasRateinAVAXWei.times(21000), AssetAVAX);
             }
             else {
-                return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
+                return new AssetCryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
             }
         case GAIAChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate), AssetATOM);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate), AssetATOM);
         case THORChain:
-            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+            return new AssetCryptoAmount(baseAmount(2000000), AssetRuneNative);
         case BSCChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate), AssetBSC);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate), AssetBSC);
         case MAYAChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate), AssetMAYA);
+            return new AssetCryptoAmount(baseAmount(inbound.gasRate), AssetMAYA);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
@@ -244,33 +243,33 @@ const calcNetworkFee = (asset, inbound) => {
  * @returns
  */
 const calcOutboundFee = (asset, inbound) => {
-    if (asset.synth)
-        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+    if (isSynthAsset(asset))
+        return new AssetCryptoAmount(baseAmount(2000000), AssetRuneNative);
     switch (asset.chain) {
         case BTCChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBTC);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetBTC);
         case BCHChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBCH);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetBCH);
         case LTCChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetLTC);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetLTC);
         case DOGEChain:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetDOGE);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetDOGE);
         case BNBChain:
             //flat fee
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBNB);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetBNB);
         case ETHChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetETH);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetETH);
         case AVAXChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetAVAX);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetAVAX);
         case GAIAChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetATOM);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetATOM);
         case BSCChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBSC);
+            return new AssetCryptoAmount(baseAmount(inbound.outboundFee), AssetBSC);
         case THORChain:
-            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+            return new AssetCryptoAmount(baseAmount(2000000), AssetRuneNative);
         case MAYAChain:
-            return new CryptoAmount(baseAmount(2000000), AssetMAYA);
+            return new AssetCryptoAmount(baseAmount(2000000), AssetMAYA);
     }
     throw new Error(`could not calculate outbound fee for ${asset.chain}`);
 };
@@ -394,6 +393,11 @@ class Thornode {
         this.quoteApi = this.config.thornodeBaseUrls.map((url) => new QuoteApi(new Configuration({ basePath: url })));
         this.mimirApi = this.config.thornodeBaseUrls.map((url) => new MimirApi(new Configuration({ basePath: url })));
         this.thornamesApi = this.config.thornodeBaseUrls.map((url) => new ThornamesApi(new Configuration({ basePath: url })));
+        this.tradeUnitApi = this.config.thornodeBaseUrls.map((url) => new TradeUnitApi(new Configuration({ basePath: url })));
+        this.tradeUnitsApi = this.config.thornodeBaseUrls.map((url) => new TradeUnitsApi(new Configuration({ basePath: url })));
+        this.tradeAccountApi = this.config.thornodeBaseUrls.map((url) => new TradeAccountApi(new Configuration({ basePath: url })));
+        this.tradeAccountsApi = this.config.thornodeBaseUrls.map((url) => new TradeAccountsApi(new Configuration({ basePath: url })));
+        this.runePoolApi = this.config.thornodeBaseUrls.map((url) => new RUNEPoolApi(new Configuration({ basePath: url })));
     }
     /**
      * Returns the oubound transactions held by THORChain due to outbound delay
@@ -814,6 +818,129 @@ class Thornode {
             throw new Error(`THORNode is not responding`);
         });
     }
+    /*
+     * Returns the total units and depth of a trade asset
+     * @param {string} asset Trade asset
+     * @param {number} height Optional - Block height
+     * @returns Returns the total units and depth of a trade asset
+     */
+    getTradeAssetUnits(asset, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeUnitApi) {
+                try {
+                    const resp = (yield api.tradeUnit(asset, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get asset trade units`);
+        });
+    }
+    /**
+     * Returns the total units and depth for each trade asset
+     * @param {number} height Block height
+     * @returns Returns the total units and depth for each trade asset
+     */
+    getTradeAssetsUnits(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeUnitsApi) {
+                try {
+                    const resp = (yield api.tradeUnits(height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get trade units`);
+        });
+    }
+    /**
+     * Returns the units and depth of a trade account address
+     * @param {Address} address Thorchain address
+     * @param {number} height Optional - Block height
+     * @returns Returns the units and depth of a trade account
+     */
+    getTradeAssetAccount(address, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeAccountApi) {
+                try {
+                    const resp = (yield api.tradeAccount(address, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get trade asset account`);
+        });
+    }
+    /**
+     * Returns all trade accounts for an asset
+     * @param {Address} address Thorchain address
+     * @param {number} height Optional - Block height
+     * @returns Returns all trade accounts for an asset
+     */
+    getTradeAssetAccounts(asset, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.tradeAccountsApi) {
+                try {
+                    const resp = (yield api.tradeAccounts(asset, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get trade asset accounts`);
+        });
+    }
+    /**
+     * Get rune pool information
+     * @param {number} height block height
+     * @returns {RUNEPoolResponse} the pool information for the RUNE pool.
+     */
+    getRunePool(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.runePoolApi) {
+                try {
+                    const resp = (yield api.runePool(height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get Rune pool`);
+        });
+    }
+    /**
+     * Get Rune pool provider information
+     * @param {string} address of which return the info
+     * @param {number} height block height
+     * @returns {RUNEProvider} the RUNE Provider information for an address.
+     */
+    getRunePoolProvider(address, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.runePoolApi) {
+                try {
+                    const resp = (yield api.runeProvider(address, height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get Rune pool provider info`);
+        });
+    }
+    /**
+     * Get all Rune pool providers information
+     * @param {number} height block height
+     * @returns {RUNEProvidersResponse} all Rune Providers.
+     */
+    getRunePoolProviders(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.runePoolApi) {
+                try {
+                    const resp = (yield api.runeProviders(height)).data;
+                    return resp;
+                }
+                catch (e) { }
+            }
+            throw new Error(`THORNode is not responding. Can not get all Rune providers info`);
+        });
+    }
 }
 
 // Constants
@@ -856,18 +983,22 @@ class ThorchainCache {
             }
             else if (isAssetRuneNative(from)) {
                 //  Runes per Asset
-                const lpTo = yield this.getPoolForAsset(to);
+                const poolToAsset = isSynthAsset(to) || isTradeAsset(to) ? yield this.getAnalogAsset(to) : to;
+                const lpTo = yield this.getPoolForAsset(poolToAsset);
                 exchangeRate = lpTo.assetToRuneRatio;
             }
             else if (isAssetRuneNative(to)) {
                 //  Asset per rune
-                const lpFrom = yield this.getPoolForAsset(from);
+                const poolFromAsset = isSynthAsset(from) || isTradeAsset(from) ? yield this.getAnalogAsset(from) : from;
+                const lpFrom = yield this.getPoolForAsset(poolFromAsset);
                 exchangeRate = lpFrom.runeToAssetRatio;
             }
             else {
                 //  AssetA per AssetB
-                const lpFrom = yield this.getPoolForAsset(from);
-                const lpTo = yield this.getPoolForAsset(to);
+                const poolFromAsset = isSynthAsset(from) || isTradeAsset(from) ? yield this.getAnalogAsset(from) : from;
+                const poolToAsset = isSynthAsset(to) || isTradeAsset(to) ? yield this.getAnalogAsset(to) : to;
+                const lpFrom = yield this.getPoolForAsset(poolFromAsset);
+                const lpTo = yield this.getPoolForAsset(poolToAsset);
                 // from/R * R/to = from/to
                 exchangeRate = lpFrom.runeToAssetRatio.times(lpTo.assetToRuneRatio);
             }
@@ -1057,6 +1188,17 @@ class ThorchainCache {
             }
         });
     }
+    getAnalogAsset(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pools = yield this.getPools();
+            const analogAssetPool = Object.values(pools).find((pool) => {
+                return (pool.asset.chain === asset.chain && pool.asset.ticker === asset.ticker && pool.asset.symbol === asset.symbol);
+            });
+            if (!analogAssetPool)
+                throw Error(`Can not find analog asset pool for ${assetToString(asset)}`);
+            return analogAssetPool.asset;
+        });
+    }
 }
 
 const defaultCache = new ThorchainCache();
@@ -1110,13 +1252,13 @@ class ThorchainQuery {
                 return {
                     memo: ``,
                     toAddress: ``,
-                    dustThreshold: new CryptoAmount(baseAmount(0), AssetRuneNative),
+                    dustThreshold: new AssetCryptoAmount(baseAmount(0), AssetRuneNative),
                     expiry: new Date(),
                     txEstimate: {
                         totalFees: {
                             asset: destinationAsset,
-                            affiliateFee: new CryptoAmount(baseAmount(0), AssetRuneNative),
-                            outboundFee: new CryptoAmount(baseAmount(0), AssetRuneNative),
+                            affiliateFee: new AssetCryptoAmount(baseAmount(0), AssetRuneNative),
+                            outboundFee: new AssetCryptoAmount(baseAmount(0), AssetRuneNative),
                         },
                         slipBasisPoints: 0,
                         netOutput: new CryptoAmount(baseAmount(0), destinationAsset),
@@ -1124,7 +1266,7 @@ class ThorchainQuery {
                         inboundConfirmationSeconds: 0,
                         canSwap: false,
                         errors,
-                        netOutputStreaming: new CryptoAmount(baseAmount(0), AssetRuneNative),
+                        netOutputStreaming: new AssetCryptoAmount(baseAmount(0), AssetRuneNative),
                         maxStreamingQuantity: 0,
                         outboundDelayBlocks: 0,
                         streamingSlipBasisPoints: 0,
@@ -1153,19 +1295,19 @@ class ThorchainQuery {
                 expiry: new Date(swapQuote.expiry * 1000),
                 txEstimate: {
                     totalFees: {
-                        asset: fromAsset,
+                        asset: destinationAsset,
                         affiliateFee: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(swapQuote.fees.affiliate), feeAsset), feeAssetDecimals),
                         outboundFee: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(swapQuote.fees.outbound), feeAsset), feeAssetDecimals),
                     },
-                    slipBasisPoints: swapQuote.slippage_bps,
+                    slipBasisPoints: swapQuote.fees.slippage_bps,
                     netOutput: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(swapQuote.expected_amount_out), destinationAsset), destinationAssetDecimals),
-                    netOutputStreaming: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(swapQuote.expected_amount_out_streaming), destinationAsset), destinationAssetDecimals),
+                    netOutputStreaming: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(swapQuote.expected_amount_out), destinationAsset), destinationAssetDecimals),
                     outboundDelaySeconds: swapQuote.outbound_delay_seconds,
                     inboundConfirmationSeconds: swapQuote.inbound_confirmation_seconds,
                     recommendedMinAmountIn: swapQuote.recommended_min_amount_in,
                     maxStreamingQuantity: swapQuote.max_streaming_quantity ? swapQuote.max_streaming_quantity : 0,
                     outboundDelayBlocks: swapQuote.outbound_delay_blocks,
-                    streamingSlipBasisPoints: swapQuote.streaming_slippage_bps,
+                    streamingSlipBasisPoints: swapQuote.fees.slippage_bps,
                     streamingSwapBlocks: swapQuote.streaming_swap_blocks ? swapQuote.streaming_swap_blocks : 0,
                     streamingSwapSeconds: swapQuote.streaming_swap_seconds ? swapQuote.streaming_swap_seconds : 0,
                     totalSwapSeconds: swapQuote.total_swap_seconds ? swapQuote.total_swap_seconds : 0,
@@ -1202,16 +1344,16 @@ class ThorchainQuery {
             // Retrieve network values
             const networkValues = yield this.thorchainCache.getNetworkValues();
             // Create CryptoAmounts for minimum transaction out volume threshold and maximum transaction out offset
-            const minTxOutVolumeThreshold = new CryptoAmount(baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative);
+            const minTxOutVolumeThreshold = new AssetCryptoAmount(baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
             // Get the delay rate for outbound transactions
-            let txOutDelayRate = new CryptoAmount(baseAmount(networkValues['TXOUTDELAYRATE']), AssetRuneNative).assetAmount
+            let txOutDelayRate = new AssetCryptoAmount(baseAmount(networkValues['TXOUTDELAYRATE']), AssetRuneNative).assetAmount
                 .amount()
                 .toNumber();
             // Get the outbound queue
             const getQueue = yield this.thorchainCache.thornode.getQueue();
             // Create a CryptoAmount for the scheduled outbound value
-            const outboundValue = new CryptoAmount(baseAmount(getQueue.scheduled_outbound_value), AssetRuneNative);
+            const outboundValue = new AssetCryptoAmount(baseAmount(getQueue.scheduled_outbound_value), AssetRuneNative);
             // Get the average block time for THORChain
             const thorChainblocktime = this.chainAttributes[THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
             // Convert the outbound amount to its value in RUNE
@@ -1284,7 +1426,7 @@ class ThorchainQuery {
             if (isAssetRuneNative(inbound.asset) ||
                 inbound.asset.chain == BNBChain ||
                 inbound.asset.chain == GAIAChain ||
-                inbound.asset.synth) {
+                isSynthAsset(inbound.asset)) {
                 // Return the average block time for THORChain
                 return this.chainAttributes[THORChain].avgBlockTimeInSecs;
             }
@@ -1309,8 +1451,9 @@ class ThorchainQuery {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
             // Check if either of the assets are synths or if the rune is not THOR.RUNE
-            if (params.asset.asset.synth || params.rune.asset.synth)
+            if (isSynthAsset(params.asset.asset) || isSynthAsset(params.rune.asset)) {
                 errors.push('you cannot add liquidity with a synth');
+            }
             if (!isAssetRuneNative(params.rune.asset))
                 errors.push('params.rune must be THOR.RUNE');
             // Get the pool for the asset
@@ -1332,7 +1475,7 @@ class ThorchainQuery {
             const waitTimeSeconds = assetWaitTimeSeconds > runeWaitTimeSeconds ? assetWaitTimeSeconds : runeWaitTimeSeconds;
             // Calculate inbound fees
             let assetInboundFee = new CryptoAmount(baseAmount(0), params.asset.asset);
-            let runeInboundFee = new CryptoAmount(baseAmount(0), AssetRuneNative);
+            let runeInboundFee = new AssetCryptoAmount(baseAmount(0), AssetRuneNative);
             if (!params.asset.assetAmount.eq(0)) {
                 assetInboundFee = calcNetworkFee(params.asset.asset, inboundDetails[params.asset.asset.chain]);
                 if (assetInboundFee.assetAmount.amount().times(3).gt(params.asset.assetAmount.amount()))
@@ -1461,7 +1604,7 @@ class ThorchainQuery {
             // Check liquidity position for the provided asset
             const memberDetail = yield this.checkLiquidityPosition(params.asset, assetOrRuneAddress);
             // Get dust values
-            const dustValues = yield this.getDustValues(params.asset); // returns asset and rune dust values
+            const dustValues = yield this.getDustValues(getChainAsset(params.asset.chain)); // returns asset and rune dust values
             // Get asset pool
             const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset);
             // Calculate pool share
@@ -1544,58 +1687,58 @@ class ThorchainQuery {
             switch (asset.chain) {
                 case 'BNB':
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0.000001, assetDecimals)), AssetBNB),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0.000001, assetDecimals)), AssetBNB),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'BTC':
                 case `BCH`:
                 case `LTC`:
                     // Dust value: 10k sats
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0.0001, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0.0001, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'ETH':
                     // Dust value: 0 wei
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'THOR':
                     // Dust value: 0 Rune
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'GAIA':
                     // Dust value: 0 GAIA
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'DOGE':
                     // Dust value: 1 million sats
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0.01, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0.01, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'AVAX':
                     // Dust value: 0 AVAX
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'BSC':
                     // Dust value: 0 BSC
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'MAYA':
                     // Dust value: 0 MAYA
                     return {
-                        asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
-                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                        asset: new AssetCryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
+                        rune: new AssetCryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 default:
                     throw Error('Unknown chain'); // Throw error for unknown chain
@@ -1660,19 +1803,20 @@ class ThorchainQuery {
             // Get fee asset decimals
             const feeAssetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(addAmount.asset);
             // Organize fees
+            const feeAsset = assetFromStringEx(depositQuote.fees.asset);
             const saverFees = {
                 affiliate: getCryptoAmountWithNotation(
                 // Affiliate fee
                 new CryptoAmount(baseAmount(depositQuote.fees.affiliate), addAmount.asset), // Convert to base amount
                 assetDecimals),
-                asset: assetFromStringEx(depositQuote.fees.asset),
+                asset: feeAsset,
                 outbound: getCryptoAmountWithNotation(
                 // Outbound fee
-                new CryptoAmount(baseAmount(depositQuote.fees.outbound), assetFromStringEx(depositQuote.fees.asset)), // Convert to base amount
+                new CryptoAmount(baseAmount(depositQuote.fees.outbound), feeAsset), // Convert to base amount
                 feeAssetDecimals),
                 liquidity: getCryptoAmountWithNotation(
                 // Liquidity fee
-                new CryptoAmount(baseAmount(depositQuote.fees.liquidity), assetFromStringEx(depositQuote.fees.asset)), // Convert to base amount
+                new CryptoAmount(baseAmount(depositQuote.fees.liquidity), feeAsset), // Convert to base amount
                 feeAssetDecimals),
                 totalBps: depositQuote.fees.total_bps || 0, // Total basis points
             };
@@ -1694,7 +1838,7 @@ class ThorchainQuery {
                 memo: depositQuote.memo,
                 estimatedWaitTime: depositQuote.inbound_confirmation_seconds || 0,
                 canAddSaver: errors.length === 0,
-                slipBasisPoints: depositQuote.slippage_bps,
+                slipBasisPoints: depositQuote.fees.slippage_bps,
                 saverCapFilledPercent,
                 recommendedMinAmountIn: depositQuote.recommended_min_amount_in,
                 errors, // Errors
@@ -1711,7 +1855,7 @@ class ThorchainQuery {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = []; // Initialize errors array
             // Return error if asset in is incorrect
-            if (isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
+            if (isAssetRuneNative(withdrawParams.asset) || isSynthAsset(withdrawParams.asset))
                 errors.push(`Native Rune and synth assets are not supported only L1's`);
             // Get inbound details
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
@@ -1723,8 +1867,8 @@ class ThorchainQuery {
                     errors.push(checkPositon.errors[i]);
                 }
                 return {
-                    dustAmount: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
-                    dustThreshold: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
+                    dustAmount: new AssetCryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
+                    dustThreshold: new AssetCryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
                     expectedAssetAmount: new CryptoAmount(// Expected asset amount
                     assetToBase(assetAmount(checkPositon.redeemableValue.assetAmount.amount())), // Convert to base amount
                     withdrawParams.asset),
@@ -1756,8 +1900,8 @@ class ThorchainQuery {
             if (errors.length > 0) {
                 // Return default values and errors if there are any errors
                 return {
-                    dustAmount: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
-                    dustThreshold: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
+                    dustAmount: new AssetCryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
+                    dustThreshold: new AssetCryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
                     expectedAssetAmount: new CryptoAmount(assetToBase(assetAmount(0)), withdrawParams.asset),
                     fee: {
                         affiliate: new CryptoAmount(baseAmount(0), withdrawParams.asset),
@@ -1786,9 +1930,9 @@ class ThorchainQuery {
             // Create an EstimateWithdrawSaver object with the necessary data
             const estimateWithdrawSaver = {
                 // Format the dust amount with appropriate notation and decimals
-                dustAmount: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.dust_amount), chainAsset), chainAssetDecimals),
+                dustAmount: getCryptoAmountWithNotation(new AssetCryptoAmount(baseAmount(withdrawQuote.dust_amount), chainAsset), chainAssetDecimals),
                 // Format the dust threshold with appropriate notation and decimals
-                dustThreshold: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.dust_threshold), chainAsset), chainAssetDecimals),
+                dustThreshold: getCryptoAmountWithNotation(new AssetCryptoAmount(baseAmount(withdrawQuote.dust_threshold), chainAsset), chainAssetDecimals),
                 // Format the expected asset amount with appropriate notation and decimals
                 expectedAssetAmount: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.expected_amount_out), withdrawParams.asset), withdrawAssetDecimals),
                 // Format the withdrawal fees with appropriate notation and decimals
@@ -1814,7 +1958,7 @@ class ThorchainQuery {
                 // Set the outbound delay seconds
                 outBoundDelaySeconds: withdrawQuote.outbound_delay_seconds || 0,
                 // Set the slip basis points
-                slipBasisPoints: withdrawQuote.slippage_bps,
+                slipBasisPoints: withdrawQuote.fees.slippage_bps,
                 // Set the errors
                 errors,
             };
@@ -1914,7 +2058,7 @@ class ThorchainQuery {
             // Calculate inbound fee for the provided asset
             const inboundFee = new CryptoAmount(baseAmount(inboundDetails[addAmount.asset.chain].gasRate), addAmount.asset);
             // Convert inbound fee to the same asset as the addAmount to ensure consistency in calculations
-            const inboundFeeInAddAmountAsset = yield this.convert(inboundFee, addAmount.asset);
+            const inboundFeeInAddAmountAsset = (yield this.convert(inboundFee, addAmount.asset));
             // Check if the addAmount covers the inbound fees
             if (addAmount.lte(inboundFeeInAddAmountAsset))
                 errors.push(`Add amount does not cover fees`);
@@ -1977,7 +2121,7 @@ class ThorchainQuery {
                     outbound: loanOpenResp.fees.outbound,
                     total_bps: loanOpenResp.fees.total_bps,
                 },
-                slippageBps: loanOpenResp.slippage_bps,
+                slippageBps: loanOpenResp.fees.slippage_bps,
                 router: loanOpenResp.router,
                 expiry: loanOpenResp.expiry,
                 warning: loanOpenResp.warning,
@@ -2050,7 +2194,7 @@ class ThorchainQuery {
                     outbound: loanCloseResp.fees.outbound,
                     total_bps: loanCloseResp.fees.total_bps,
                 },
-                slippageBps: loanCloseResp.slippage_bps,
+                slippageBps: loanCloseResp.fees.slippage_bps,
                 router: loanCloseResp.router,
                 expiry: loanCloseResp.expiry,
                 warning: loanCloseResp.warning,
@@ -2244,6 +2388,159 @@ class ThorchainQuery {
             };
         });
     }
+    /*
+     * Returns the total units and depth of a trade asset
+     * @param {TradeAssetUnitsParams} params Get trade asset unit params
+     * @returns {TradeAssetUnits} Returns the total units and depth of a trade asset
+     */
+    getTradeAssetUnits({ asset, height }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { units, depth } = yield this.thorchainCache.thornode.getTradeAssetUnits(assetToString(asset), height);
+            const decimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(asset);
+            return {
+                asset,
+                units: new CryptoAmount(baseAmount(units, decimals), asset),
+                depth: new CryptoAmount(baseAmount(depth, decimals), asset),
+            };
+        });
+    }
+    /*
+     * Returns the total units and depth for each trade asset
+     * @param {TradeAssetsUnitsParams} params Get trade asset unit params
+     * @returns {TradeAssetUnits[]} Returns the total units and depth for each trade asset
+     */
+    getTradeAssetsUnits(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tradeAssetsUnits = yield this.thorchainCache.thornode.getTradeAssetsUnits(params === null || params === void 0 ? void 0 : params.height);
+            const parseData = ({ asset, units, depth }) => __awaiter(this, void 0, void 0, function* () {
+                const tradeAsset = assetFromStringEx(asset);
+                const decimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(tradeAsset);
+                return {
+                    asset: tradeAsset,
+                    units: new CryptoAmount(baseAmount(units, decimals), tradeAsset),
+                    depth: new CryptoAmount(baseAmount(depth, decimals), tradeAsset),
+                };
+            });
+            return Promise.all(tradeAssetsUnits.map(parseData));
+        });
+    }
+    /**
+     * Returns the units and depth of a trade account address
+     * @param {TradeAssetsUnitsParams} params Get trade asset unit params
+     * @returns {TradeAssetUnits[]} Returns the total units and depth for each trade asset
+     */
+    getAddressTradeAccounts({ address, height, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = yield this.thorchainCache.thornode.getTradeAssetAccount(address, height);
+            const parseData = (tradeAssetInfo) => __awaiter(this, void 0, void 0, function* () {
+                const asset = assetFromStringEx(tradeAssetInfo.asset);
+                return {
+                    asset,
+                    address,
+                    balance: new CryptoAmount(baseAmount(tradeAssetInfo.units), asset),
+                    lastAddHeight: tradeAssetInfo.last_add_height ? +tradeAssetInfo.last_add_height : undefined,
+                    lastWithdrawHeight: tradeAssetInfo.last_withdraw_height ? +tradeAssetInfo.last_withdraw_height : undefined,
+                };
+            });
+            return Promise.all(account.map(parseData));
+        });
+    }
+    /**
+     * Returns all trade accounts for a trade asset
+     * @param {TradeAssetAccountsParams} params Get Trade asset accounts params
+     * @param {number} height Optional - Block height
+     * @returns Returns all trade accounts for an asset
+     */
+    getTradeAssetAccounts({ asset, height }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accounts = yield this.thorchainCache.thornode.getTradeAssetAccounts(assetToString(asset), height);
+            const decimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(asset);
+            return accounts.map((account) => {
+                return {
+                    address: account.owner,
+                    asset,
+                    balance: new CryptoAmount(baseAmount(account.units, decimals), asset),
+                    lastAddHeight: account.last_add_height ? +account.last_add_height : undefined,
+                    lastWithdrawHeight: account.last_withdraw_height ? +account.last_withdraw_height : undefined,
+                };
+            });
+        });
+    }
+    /**
+     * Get Rune pool
+     * @param {GetRunePoolParmas} params Get Rune pool params
+     * @returns {RunePool} Rune pool information
+     */
+    getRunePool(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = yield this.thorchainCache.thornode.getRunePool(params === null || params === void 0 ? void 0 : params.height);
+            return {
+                pol: {
+                    runeDeposited: new AssetCryptoAmount(baseAmount(pool.pol.rune_deposited, THORCHAIN_DECIMAL), AssetRuneNative),
+                    runeWithdrawn: new AssetCryptoAmount(baseAmount(pool.pol.rune_withdrawn, THORCHAIN_DECIMAL), AssetRuneNative),
+                    value: new AssetCryptoAmount(baseAmount(pool.pol.value, THORCHAIN_DECIMAL), AssetRuneNative),
+                    pnl: new AssetCryptoAmount(baseAmount(pool.pol.pnl, THORCHAIN_DECIMAL), AssetRuneNative),
+                    currentRuneDeposited: new AssetCryptoAmount(baseAmount(pool.pol.current_deposit, THORCHAIN_DECIMAL), AssetRuneNative),
+                },
+                providers: {
+                    units: pool.providers.units,
+                    pendingUnits: pool.providers.pending_units,
+                    pendingRune: new AssetCryptoAmount(baseAmount(pool.providers.pending_rune, THORCHAIN_DECIMAL), AssetRuneNative),
+                    value: new AssetCryptoAmount(baseAmount(pool.providers.value, THORCHAIN_DECIMAL), AssetRuneNative),
+                    pnl: new AssetCryptoAmount(baseAmount(pool.providers.pnl, THORCHAIN_DECIMAL), AssetRuneNative),
+                    currentRuneDeposited: new AssetCryptoAmount(baseAmount(pool.providers.current_deposit, THORCHAIN_DECIMAL), AssetRuneNative),
+                },
+                reserve: {
+                    units: pool.reserve.units,
+                    value: new AssetCryptoAmount(baseAmount(pool.reserve.value, THORCHAIN_DECIMAL), AssetRuneNative),
+                    pnl: new AssetCryptoAmount(baseAmount(pool.reserve.pnl, THORCHAIN_DECIMAL), AssetRuneNative),
+                    currentRuneDeposited: new AssetCryptoAmount(baseAmount(pool.reserve.current_deposit, THORCHAIN_DECIMAL), AssetRuneNative),
+                },
+            };
+        });
+    }
+    /**
+     * Get Rune pool provider position
+     * @param {RunePoolProviderParams} params Get Rune pool provider position params
+     * @returns {RunePoolProvider} Rune pool provider position
+     */
+    getRunePoolProvider({ address, height }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const position = yield this.thorchainCache.thornode.getRunePoolProvider(address, height);
+            return {
+                address: position.rune_address,
+                units: position.units,
+                value: new AssetCryptoAmount(baseAmount(position.value), AssetRuneNative),
+                pnl: new AssetCryptoAmount(baseAmount(position.pnl), AssetRuneNative),
+                depositAmount: new AssetCryptoAmount(baseAmount(position.deposit_amount), AssetRuneNative),
+                withdrawAmount: new AssetCryptoAmount(baseAmount(position.withdraw_amount), AssetRuneNative),
+                lastDepositHeight: position.last_deposit_height,
+                lastWithdrawHeight: position.last_withdraw_height,
+            };
+        });
+    }
+    /**
+     * Get all Rune pool providers position
+     * @param {RunePoolProvidersParams} params Get Rune pool provider position params
+     * @returns {RunePoolProvider[]} All Rune pool providers position
+     */
+    getRunePoolProviders(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const positions = yield this.thorchainCache.thornode.getRunePoolProviders(params === null || params === void 0 ? void 0 : params.height);
+            return positions.map((position) => {
+                return {
+                    address: position.rune_address,
+                    units: position.units,
+                    value: new AssetCryptoAmount(baseAmount(position.value), AssetRuneNative),
+                    pnl: new AssetCryptoAmount(baseAmount(position.pnl), AssetRuneNative),
+                    depositAmount: new AssetCryptoAmount(baseAmount(position.deposit_amount), AssetRuneNative),
+                    withdrawAmount: new AssetCryptoAmount(baseAmount(position.withdraw_amount), AssetRuneNative),
+                    lastDepositHeight: position.last_deposit_height,
+                    lastWithdrawHeight: position.last_withdraw_height,
+                };
+            });
+        });
+    }
 }
 
 /**
@@ -2786,7 +3083,7 @@ class TransactionStage {
             const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
             const currentHeight = lastBlockObj.find((obj) => obj.chain == asset.chain);
             let blockHeight;
-            if (asset.chain === THORChain || asset.synth) {
+            if (asset.chain === THORChain || isSynthAsset(asset)) {
                 const currentHeight = lastBlockObj.find((obj) => obj);
                 blockHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
             }