@xchainjs/xchain-thorchain-query 0.2.3 → 0.2.5

package/lib/index.esm.js

@@ -1,18 +1,9 @@
-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, assetAmount, getContractAddressFromAsset } 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 { BCHChain, AssetBCH } 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, MimirApi } from '@xchainjs/xchain-thornode';
 
 /*! *****************************************************************************
@@ -77,6 +68,14 @@ const DefaultChainAttributes = {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
     },
+    BSC: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 3,
+    },
+    MAYA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
 };
 
 /**
@@ -196,148 +195,29 @@ class LiquidityPool {
     }
 }
 
-const defaultMidgardConfig = {
-    mainnet: {
-        apiRetries: 3,
-        midgardBaseUrls: ['https://midgard.ninerealms.com'],
-    },
-    stagenet: {
-        apiRetries: 3,
-        midgardBaseUrls: ['https://stagenet-midgard.ninerealms.com'],
-    },
-    testnet: {
-        apiRetries: 3,
-        midgardBaseUrls: ['https://testnet.midgard.thorchain.info'],
-    },
-};
-class Midgard {
-    constructor(network = Network.Mainnet, config) {
-        this.network = network;
-        this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig[this.network];
-        axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
-        this.midgardApis = this.config.midgardBaseUrls.map((url) => new MidgardApi(new Configuration({ basePath: url })));
-    }
-    /**
-     *
-     * @returns an array of Pools
-     */
-    getPools() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    return (yield api.getPools()).data;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw new Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Gets the latest block using the Health endpoint within Midgard
-     *
-     * @returns
-     */
-    getLatestBlockHeight() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const data = (yield api.getHealth()).data;
-                    return +data.scannerHeight;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Gets actions object for any of the parameters
-     * @param txHash transaction id
-     * @returns Type Action array of objects
-     */
-    getActions(address, txid, asset, type, affiliate, limit, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
-                    return actions;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return member details based on valid liquidity position
-     * @param address - needed to query for Lp details
-     * @returns - object type of Member Detail
-     */
-    getMember(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const memberDetail = (yield api.getMemberDetail(address)).data;
-                    return memberDetail;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return pool statistics for a particular asset
-     * @param asset - asset string to query its pool stats
-     * @returns - type object poolstatsDetail
-     */
-    getPoolStats(asset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const poolDetail = (yield api.getPoolStats(asset)).data;
-                    return poolDetail;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return THORNameDetails for a particular name
-     * @param name - thorname string to query
-     * @returns - type object THORNameDetails
-     */
-    getTHORNameDetails(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const resp = yield api.getTHORNameDetail(name);
-                    if (resp.status == 404) {
-                        return undefined;
-                    }
-                    else if (resp.status == 200) {
-                        return resp.data;
-                    }
-                }
-                catch (e) {
-                    // if (resp.status == 404) {
-                    //   return undefined
-                    // }
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-}
+const AssetBNB = assetFromStringEx('BNB.BNB');
+const AssetAVAX = assetFromStringEx('AVAX.AVAX');
+const AssetBTC = assetFromStringEx('BTC.BTC');
+const AssetBCH = assetFromStringEx('BCH.BHC');
+const AssetETH = assetFromStringEx('ETH.ETH');
+const AssetDOGE = assetFromStringEx('DOGE.DOGE');
+const AssetLTC = assetFromStringEx('LTC.LTC');
+const AssetATOM = assetFromStringEx('GAIA.ATOM');
+const AssetMAYA = assetFromStringEx('MAYA.CACAO');
+const AssetBSC = assetFromStringEx('BSC.BNB');
+const AssetRuneNative = assetFromStringEx('THOR.RUNE');
+const BNBChain = 'BNB';
+const BTCChain = 'BTC';
+const BCHChain = 'BCH';
+const ETHChain = 'ETH';
+const GAIAChain = 'GAIA';
+const DOGEChain = 'DOGE';
+const LTCChain = 'LTC';
+const AVAXChain = 'AVAX';
+const MAYAChain = 'MAYA';
+const BSCChain = 'BSC';
+const THORChain = 'THOR';
+const isAssetRuneNative = (asset) => assetToString(asset) === assetToString(AssetRuneNative);
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
@@ -491,6 +371,10 @@ const getChainAsset = (chain) => {
             return AssetDOGE;
         case AVAXChain:
             return AssetAVAX;
+        case BSCChain:
+            return AssetBSC;
+        case MAYAChain:
+            return AssetMAYA;
         default:
             throw Error('Unknown chain');
     }
@@ -540,58 +424,300 @@ const calcNetworkFee = (asset, inbound) => {
             else {
                 return new CryptoAmount(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);
+        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);
+            }
+            else {
+                return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
+            }
+        case GAIAChain:
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetATOM);
+        case THORChain:
+            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+        case BSCChain:
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetBSC);
+        case MAYAChain:
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetMAYA);
+    }
+    throw new Error(`could not calculate inbound fee for ${asset.chain}`);
+};
+/**
+ * Works out the required outbound fee based on the chain.
+ * Call getInboundDetails to get the current outbound fee
+ *
+ * @param sourceAsset
+ * @param inbound detail
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+const calcOutboundFee = (asset, inbound) => {
+    if (asset.synth)
+        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+    switch (asset.chain) {
+        case BTCChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBTC);
+        case BCHChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBCH);
+        case LTCChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetLTC);
+        case DOGEChain:
+            // NOTE: UTXO chains estimate fees with a 250 byte size
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetDOGE);
+        case BNBChain:
+            //flat fee
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBNB);
+        case ETHChain:
+            return new CryptoAmount(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);
+        case GAIAChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetATOM);
+        case BSCChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBSC);
+        case THORChain:
+            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+        case MAYAChain:
+            return new CryptoAmount(baseAmount(2000000), AssetMAYA);
+    }
+    throw new Error(`could not calculate outbound fee for ${asset.chain}`);
+};
+
+/**
+ * https://dev.thorchain.org/thorchain-dev/interface-guide/math#lp-units-add
+ * @param liquidity - asset amount added
+ * @param pool  - pool depths
+ * @returns liquidity units - ownership of pool
+ */
+const getLiquidityUnits = (liquidity, pool) => {
+    const baseAmount8decimals = getBaseAmountWithDiffDecimals(liquidity.asset, 8);
+    const P = new BigNumber(pool.pool.liquidityUnits);
+    const r = liquidity.rune.baseAmount.amount();
+    const a = baseAmount8decimals;
+    const R = pool.runeBalance.amount();
+    const A = pool.assetBalance.amount();
+    const part1 = R.times(a);
+    const part2 = r.times(A);
+    const numerator = P.times(part1.plus(part2));
+    const denominator = R.times(A).times(2);
+    const result = numerator.div(denominator);
+    return result;
+};
+/**
+ *
+ * @param unitData - units for both asset and rune
+ * @param pool - pool that the asset is bound to
+ * @returns - pool share of both asset and rune in percentage
+ */
+const getPoolShare = (unitData, pool) => {
+    // formula: (rune * part) / total; (asset * part) / total
+    const units = unitData.liquidityUnits;
+    const total = unitData.totalUnits;
+    const R = pool.runeBalance.amount();
+    const T = pool.assetBalance.amount();
+    const asset = T.times(units).div(total);
+    const rune = R.times(units).div(total);
+    const poolShareDetail = {
+        assetShare: new CryptoAmount(baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(baseAmount(rune), AssetRuneNative),
+    };
+    return poolShareDetail;
+};
+/**
+ *
+ * @param poolShare - the share of asset and rune added to the pool
+ * @param pool - Pool that the asset is attached to
+ * @returns - returns bignumber representing a slip percentage
+ */
+const getSlipOnLiquidity = (stake, pool) => {
+    const baseAmount8decimals = getBaseAmountWithDiffDecimals(stake.asset, 8);
+    // formula: (t * R - T * r)/ (T*r + R*T)
+    const r = stake.rune.baseAmount.amount();
+    const t = baseAmount8decimals;
+    const R = pool.runeBalance.amount();
+    const T = pool.assetBalance.amount();
+    const numerator = t.times(R).minus(T.times(r));
+    const denominator = T.times(r).plus(R.times(T));
+    const result = numerator.div(denominator).abs();
+    return result;
+};
+/**
+ * https://docs.thorchain.org/thorchain-finance/continuous-liquidity-pools#impermanent-loss-protection
+ * @param poolShare - the share of asset and rune added to the pool
+ * @param pool - Pool that the asset is attached to
+ * @param block - blockl object with current, last added and the constant blocksforlossProtection
+ * @returns
+ */
+// Blocks for full protection 1440000 // 100 days
+const getLiquidityProtectionData = (depositValue, poolShare, block) => {
+    //Coverage formula coverage=((A0∗P1)+R0)−((A1∗P1)+R1)=>((A0∗R1/A1)+R0)−(R1+R1)
+    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
+    const R0 = depositValue.rune.amount(); // rune deposit value
+    const A0 = depositValue.asset.amount(); // asset deposit value
+    const R1 = poolShare.runeShare.baseAmount.amount(); // rune amount to redeem
+    const A1 = poolShare.assetShare.baseAmount.amount(); // asset amount to redeem
+    const P1 = R1.div(A1); // Pool ratio at withdrawal
+    const part1 = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1)); // start position minus end position
+    const part2 = A0.times(R1.div(A1)).plus(R0).minus(R1.plus(R1)); // different way to check position
+    const coverage = part1 >= part2 ? part1 : part2; // Coverage represents how much ILP a LP is entitled to
+    const currentHeight = block.current;
+    const heightLastAdded = block.lastAdded || 0; //default to zero if undefined
+    const blocksforfullprotection = block.fullProtection;
+    const fractionOfFullILPProtection = (currentHeight - heightLastAdded) / blocksforfullprotection;
+    const protectionProgress = Math.min(fractionOfFullILPProtection, 1); // percentage of entitlement, max 100%
+    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(maxILP), AssetRuneNative),
+        totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
+    };
+    return ILProtection;
+};
+
+const defaultMidgardConfig = {
+    mainnet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://midgard.ninerealms.com'],
+    },
+    stagenet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://stagenet-midgard.ninerealms.com'],
+    },
+    testnet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://testnet.midgard.thorchain.info'],
+    },
+};
+class Midgard {
+    constructor(network = Network.Mainnet, config) {
+        this.network = network;
+        this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig[this.network];
+        axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
+        this.midgardApis = this.config.midgardBaseUrls.map((url) => new MidgardApi(new Configuration({ basePath: url })));
+    }
+    /**
+     *
+     * @returns an array of Pools
+     */
+    getPools() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    return (yield api.getPools()).data;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw new Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Gets the latest block using the Health endpoint within Midgard
+     *
+     * @returns
+     */
+    getLatestBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const data = (yield api.getHealth()).data;
+                    return +data.scannerHeight;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Gets actions object for any of the parameters
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(address, txid, asset, type, affiliate, limit, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
+                    return actions;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return member details based on valid liquidity position
+     * @param address - needed to query for Lp details
+     * @returns - object type of Member Detail
+     */
+    getMember(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const memberDetail = (yield api.getMemberDetail(address)).data;
+                    return memberDetail;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
             }
-            else {
-                return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return pool statistics for a particular asset
+     * @param asset - asset string to query its pool stats
+     * @returns - type object poolstatsDetail
+     */
+    getPoolStats(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const poolDetail = (yield api.getPoolStats(asset)).data;
+                    return poolDetail;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
             }
-        case GAIAChain:
-            return new CryptoAmount(baseAmount(inbound.gasRate), AssetATOM);
-        case THORChain:
-            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+            throw Error(`Midgard not responding`);
+        });
     }
-    throw new Error(`could not calculate inbound fee for ${asset.chain}`);
-};
-/**
- * Works out the required outbound fee based on the chain.
- * Call getInboundDetails to get the current outbound fee
- *
- * @param sourceAsset
- * @param inbound detail
- * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
- * @returns
- */
-const calcOutboundFee = (asset, inbound) => {
-    if (asset.synth)
-        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
-    switch (asset.chain) {
-        case BTCChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBTC);
-        case BCHChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBCH);
-        case LTCChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetLTC);
-        case DOGEChain:
-            // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetDOGE);
-        case BNBChain:
-            //flat fee
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBNB);
-        case ETHChain:
-            return new CryptoAmount(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);
-        case GAIAChain:
-            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetATOM);
-        case THORChain:
-            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+    /**
+     * Function to return THORNameDetails for a particular name
+     * @param name - thorname string to query
+     * @returns - type object THORNameDetails
+     */
+    getTHORNameDetails(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const resp = yield api.getTHORNameDetail(name);
+                    if (resp.status == 404) {
+                        return undefined;
+                    }
+                    else if (resp.status == 200) {
+                        return resp.data;
+                    }
+                }
+                catch (e) {
+                    // if (resp.status == 404) {
+                    //   return undefined
+                    // }
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
     }
-    throw new Error(`could not calculate outbound fee for ${asset.chain}`);
-};
+}
 
 const defaultThornodeConfig = {
     mainnet: {
@@ -1356,97 +1482,6 @@ class ThorchainCache {
     }
 }
 
-/**
- * https://dev.thorchain.org/thorchain-dev/interface-guide/math#lp-units-add
- * @param liquidity - asset amount added
- * @param pool  - pool depths
- * @returns liquidity units - ownership of pool
- */
-const getLiquidityUnits = (liquidity, pool) => {
-    const baseAmount8decimals = getBaseAmountWithDiffDecimals(liquidity.asset, 8);
-    const P = new BigNumber(pool.pool.liquidityUnits);
-    const r = liquidity.rune.baseAmount.amount();
-    const a = baseAmount8decimals;
-    const R = pool.runeBalance.amount();
-    const A = pool.assetBalance.amount();
-    const part1 = R.times(a);
-    const part2 = r.times(A);
-    const numerator = P.times(part1.plus(part2));
-    const denominator = R.times(A).times(2);
-    const result = numerator.div(denominator);
-    return result;
-};
-/**
- *
- * @param unitData - units for both asset and rune
- * @param pool - pool that the asset is bound to
- * @returns - pool share of both asset and rune in percentage
- */
-const getPoolShare = (unitData, pool) => {
-    // formula: (rune * part) / total; (asset * part) / total
-    const units = unitData.liquidityUnits;
-    const total = unitData.totalUnits;
-    const R = pool.runeBalance.amount();
-    const T = pool.assetBalance.amount();
-    const asset = T.times(units).div(total);
-    const rune = R.times(units).div(total);
-    const poolShareDetail = {
-        assetShare: new CryptoAmount(baseAmount(asset), pool.asset),
-        runeShare: new CryptoAmount(baseAmount(rune), AssetRuneNative),
-    };
-    return poolShareDetail;
-};
-/**
- *
- * @param poolShare - the share of asset and rune added to the pool
- * @param pool - Pool that the asset is attached to
- * @returns - returns bignumber representing a slip percentage
- */
-const getSlipOnLiquidity = (stake, pool) => {
-    const baseAmount8decimals = getBaseAmountWithDiffDecimals(stake.asset, 8);
-    // formula: (t * R - T * r)/ (T*r + R*T)
-    const r = stake.rune.baseAmount.amount();
-    const t = baseAmount8decimals;
-    const R = pool.runeBalance.amount();
-    const T = pool.assetBalance.amount();
-    const numerator = t.times(R).minus(T.times(r));
-    const denominator = T.times(r).plus(R.times(T));
-    const result = numerator.div(denominator).abs();
-    return result;
-};
-/**
- * https://docs.thorchain.org/thorchain-finance/continuous-liquidity-pools#impermanent-loss-protection
- * @param poolShare - the share of asset and rune added to the pool
- * @param pool - Pool that the asset is attached to
- * @param block - blockl object with current, last added and the constant blocksforlossProtection
- * @returns
- */
-// Blocks for full protection 1440000 // 100 days
-const getLiquidityProtectionData = (depositValue, poolShare, block) => {
-    //Coverage formula coverage=((A0∗P1)+R0)−((A1∗P1)+R1)=>((A0∗R1/A1)+R0)−(R1+R1)
-    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
-    const R0 = depositValue.rune.amount(); // rune deposit value
-    const A0 = depositValue.asset.amount(); // asset deposit value
-    const R1 = poolShare.runeShare.baseAmount.amount(); // rune amount to redeem
-    const A1 = poolShare.assetShare.baseAmount.amount(); // asset amount to redeem
-    const P1 = R1.div(A1); // Pool ratio at withdrawal
-    const part1 = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1)); // start position minus end position
-    const part2 = A0.times(R1.div(A1)).plus(R0).minus(R1.plus(R1)); // different way to check position
-    const coverage = part1 >= part2 ? part1 : part2; // Coverage represents how much ILP a LP is entitled to
-    const currentHeight = block.current;
-    const heightLastAdded = block.lastAdded || 0; //default to zero if undefined
-    const blocksforfullprotection = block.fullProtection;
-    const fractionOfFullILPProtection = (currentHeight - heightLastAdded) / blocksforfullprotection;
-    const protectionProgress = Math.min(fractionOfFullILPProtection, 1); // percentage of entitlement, max 100%
-    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(maxILP), AssetRuneNative),
-        totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
-    };
-    return ILProtection;
-};
-
 const BN_1 = new BigNumber(1);
 const defaultCache = new ThorchainCache();
 /**
@@ -2149,6 +2184,20 @@ class ThorchainQuery {
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
+                case 'BSC':
+                    // 0 BSC
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'MAYA':
+                    // 0 MAYA
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                    };
+                    return dustValues;
                 default:
                     throw Error('Unknown chain');
             }
@@ -2159,7 +2208,17 @@ class ThorchainQuery {
     estimateAddSaver(addAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             let errors = [];
+            // check for errors before sending quote
             errors = yield this.getAddSaversEstimateErrors(addAmount);
+            // request param amount should always be in 1e8 which is why we pass in adjusted decimals if chain decimals != 8
+            const newAddAmount = addAmount.baseAmount.decimal != 8 ? getBaseAmountWithDiffDecimals(addAmount, 8) : addAmount.baseAmount.amount();
+            // Fetch quote
+            const depositQuote = yield this.thorchainCache.thornode.getSaversDepositQuote(assetToString(addAmount.asset), newAddAmount.toNumber());
+            // error handling
+            const response = JSON.parse(JSON.stringify(depositQuote));
+            if (response.error)
+                errors.push(`Thornode request quote failed: ${response.error}`);
+            // Return errors if there is any
             if (errors.length > 0) {
                 return {
                     assetAmount: addAmount,
@@ -2179,29 +2238,27 @@ class ThorchainQuery {
                     errors,
                 };
             }
-            // request param amount should always be in 1e8 which is why we pass in adjusted decimals if chain decimals != 8
-            const newAddAmount = addAmount.baseAmount.decimal != 8 ? getBaseAmountWithDiffDecimals(addAmount, 8) : addAmount.baseAmount.amount();
-            const depositQuote = yield this.thorchainCache.thornode.getSaversDepositQuote(assetToString(addAmount.asset), newAddAmount.toNumber());
             // Calculate transaction expiry time of the vault address
             const currentDatetime = new Date();
             const minutesToAdd = 15;
             const expiryDatetime = new Date(currentDatetime.getTime() + minutesToAdd * 60000);
+            // Calculate seconds
             const estimatedWait = depositQuote.inbound_confirmation_seconds
                 ? depositQuote.inbound_confirmation_seconds
                 : yield this.confCounting(addAmount);
             const pool = (yield this.thorchainCache.getPoolForAsset(addAmount.asset)).pool;
-            if (addAmount.baseAmount.lte(depositQuote.expected_amount_out))
-                errors.push(`Amount being added to savers can't pay for fees`);
+            // Organise fees
             const saverFees = {
                 affiliate: new CryptoAmount(baseAmount(depositQuote.fees.affiliate), addAmount.asset),
                 asset: assetFromStringEx(depositQuote.fees.asset),
                 outbound: new CryptoAmount(baseAmount(depositQuote.fees.outbound), addAmount.asset),
             };
+            // define savers cap
             const saverCap = 0.3 * +pool.assetDepth;
             const saverCapFilledPercent = (+pool.saversDepth / saverCap) * 100;
             const estimateAddSaver = {
                 assetAmount: new CryptoAmount(baseAmount(depositQuote.expected_amount_out), addAmount.asset),
-                estimatedDepositValue: new CryptoAmount(baseAmount(depositQuote.expected_amount_out), saverFees.asset),
+                estimatedDepositValue: new CryptoAmount(baseAmount(depositQuote.expected_amount_deposit), addAmount.asset),
                 fee: saverFees,
                 expiry: expiryDatetime,
                 toAddress: depositQuote.inbound_address,
@@ -2222,12 +2279,56 @@ class ThorchainQuery {
      */
     estimateWithdrawSaver(withdrawParams) {
         return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            // return error if Asset in is incorrect
             if (isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
-                throw Error(`Native Rune and synth assets are not supported only L1's`);
+                errors.push(`Native Rune and synth assets are not supported only L1's`);
+            const inboundDetails = yield this.thorchainCache.getInboundDetails();
+            // Check to see if there is a position before calling withdraw quote
+            const checkPositon = yield this.getSaverPosition(withdrawParams);
+            if (checkPositon.errors.length > 0) {
+                for (let i = 0; i < checkPositon.errors.length; i++) {
+                    errors.push(checkPositon.errors[i]);
+                }
+                return {
+                    expectedAssetAmount: new CryptoAmount(assetToBase(assetAmount(checkPositon.redeemableValue.assetAmount.amount())), withdrawParams.asset),
+                    fee: {
+                        affiliate: new CryptoAmount(assetToBase(assetAmount(0)), withdrawParams.asset),
+                        asset: withdrawParams.asset,
+                        outbound: new CryptoAmount(assetToBase(assetAmount(calcOutboundFee(withdrawParams.asset, inboundDetails[withdrawParams.asset.chain]).assetAmount.amount())), withdrawParams.asset),
+                    },
+                    expiry: new Date(0),
+                    toAddress: '',
+                    memo: '',
+                    estimatedWaitTime: -1,
+                    slipBasisPoints: -1,
+                    dustAmount: new CryptoAmount(baseAmount(0), withdrawParams.asset),
+                    errors,
+                };
+            }
+            // Request withdraw quote
             const withdrawQuote = yield this.thorchainCache.thornode.getSaversWithdrawQuote(withdrawParams);
-            if (!withdrawQuote.expected_amount_out)
-                throw Error(`Could not quote withdrawal ${JSON.stringify(withdrawQuote)}`);
-            // const pool = (await this.thorchainCache.getPoolForAsset(withdrawParams.asset)).pool
+            // error handling
+            const response = JSON.parse(JSON.stringify(withdrawQuote));
+            if (response.error)
+                errors.push(`Thornode request quote failed: ${response.error}`);
+            if (errors.length > 0) {
+                return {
+                    expectedAssetAmount: new CryptoAmount(assetToBase(assetAmount(0)), withdrawParams.asset),
+                    fee: {
+                        affiliate: new CryptoAmount(assetToBase(assetAmount(0)), withdrawParams.asset),
+                        asset: withdrawParams.asset,
+                        outbound: new CryptoAmount(assetToBase(assetAmount(0)), withdrawParams.asset),
+                    },
+                    expiry: new Date(0),
+                    toAddress: '',
+                    memo: '',
+                    estimatedWaitTime: -1,
+                    slipBasisPoints: -1,
+                    dustAmount: new CryptoAmount(baseAmount(0), withdrawParams.asset),
+                    errors,
+                };
+            }
             // Calculate transaction expiry time of the vault address
             const currentDatetime = new Date();
             const minutesToAdd = 15;
@@ -2247,6 +2348,7 @@ class ThorchainQuery {
                 estimatedWaitTime: estimatedWait,
                 slipBasisPoints: withdrawQuote.slippage_bps,
                 dustAmount: new CryptoAmount(baseAmount(withdrawQuote.dust_amount), withdrawParams.asset),
+                errors,
             };
             return estimateWithdrawSaver;
         });
@@ -2258,31 +2360,37 @@ class ThorchainQuery {
      */
     getSaverPosition(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            const inboundDetails = yield this.thorchainCache.getInboundDetails();
             const blockData = (yield this.thorchainCache.thornode.getLastBlock()).find((item) => item.chain === params.asset.chain);
             const savers = (yield this.thorchainCache.thornode.getSavers(`${params.asset.chain}.${params.asset.ticker}`)).find((item) => item.asset_address === params.address);
             const pool = (yield this.thorchainCache.getPoolForAsset(params.asset)).pool;
             if (!savers)
-                throw Error(`Could not find position for ${params.address}`);
-            if (!savers.last_add_height)
-                throw Error(`Could not find position for ${params.address}`);
+                errors.push(`Could not find position for ${params.address}`);
+            if (!(savers === null || savers === void 0 ? void 0 : savers.last_add_height))
+                errors.push(`Could not find position for ${params.address}`);
             if (!(blockData === null || blockData === void 0 ? void 0 : blockData.thorchain))
-                throw Error(`Could not get thorchain block height`);
-            const ownerUnits = Number(savers.units);
-            const lastAdded = Number(savers.last_add_height);
+                errors.push(`Could not get thorchain block height`);
+            const outboundFee = yield calcOutboundFee(params.asset, inboundDetails[params.asset.chain]);
+            if (Number(savers === null || savers === void 0 ? void 0 : savers.asset_redeem_value) < outboundFee.baseAmount.amount().toNumber())
+                errors.push(`Unlikely to withdraw balance as outbound fee is greater than redeemable amount`);
+            const ownerUnits = Number(savers === null || savers === void 0 ? void 0 : savers.units);
+            const lastAdded = Number(savers === null || savers === void 0 ? void 0 : savers.last_add_height);
             const saverUnits = Number(pool.saversUnits);
             const assetDepth = Number(pool.saversDepth);
             const redeemableValue = (ownerUnits / saverUnits) * assetDepth;
-            const depositAmount = new CryptoAmount(baseAmount(savers.asset_deposit_value), params.asset);
+            const depositAmount = new CryptoAmount(baseAmount(savers === null || savers === void 0 ? void 0 : savers.asset_deposit_value), params.asset);
             const redeemableAssetAmount = new CryptoAmount(baseAmount(redeemableValue), params.asset);
-            const saversAge = ((blockData === null || blockData === void 0 ? void 0 : blockData.thorchain) - lastAdded) / ((365 * 86400) / 6);
+            const saversAge = (Number(blockData === null || blockData === void 0 ? void 0 : blockData.thorchain) - lastAdded) / ((365 * 86400) / 6);
             const saverGrowth = redeemableAssetAmount.minus(depositAmount).div(depositAmount).times(100);
             const saversPos = {
                 depositValue: depositAmount,
                 redeemableValue: redeemableAssetAmount,
-                lastAddHeight: savers.last_add_height,
+                lastAddHeight: Number(savers === null || savers === void 0 ? void 0 : savers.last_add_height),
                 percentageGrowth: saverGrowth.assetAmount.amount().toNumber(),
                 ageInYears: saversAge,
                 ageInDays: saversAge * 365,
+                errors,
             };
             return saversPos;
         });
@@ -2301,6 +2409,9 @@ class ThorchainQuery {
             const pool = (yield this.thorchainCache.getPoolForAsset(addAmount.asset)).pool;
             if (pool.status.toLowerCase() !== 'available')
                 errors.push(`Pool is not available for this asset ${assetToString(addAmount.asset)}`);
+            const inboundFee = calcNetworkFee(addAmount.asset, inboundDetails[addAmount.asset.chain]);
+            if (addAmount.lte(inboundFee))
+                errors.push(`Add amount does not cover fees`);
             return errors;
         });
     }
@@ -2740,4 +2851,4 @@ class TransactionStage {
     }
 }
 
-export { AddLpStatus, AddSaverStatus, CryptoAmount, InboundStatus, LiquidityPool, Midgard, RefundStatus, SwapStatus, ThorchainCache, ThorchainQuery, Thornode, TransactionStage, TxType, WithdrawStatus, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity };
+export { AVAXChain, AddLpStatus, AddSaverStatus, AssetATOM, AssetAVAX, AssetBCH, AssetBNB, AssetBSC, AssetBTC, AssetDOGE, AssetETH, AssetLTC, AssetMAYA, AssetRuneNative, BCHChain, BNBChain, BSCChain, BTCChain, CryptoAmount, DOGEChain, ETHChain, GAIAChain, InboundStatus, LTCChain, LiquidityPool, MAYAChain, Midgard, RefundStatus, SwapStatus, THORChain, ThorchainCache, ThorchainQuery, Thornode, TransactionStage, TxType, WithdrawStatus, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity, isAssetRuneNative };