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

package/lib/index.esm.js

@@ -1,6 +1,7 @@
-import { ObservedTxStatusEnum, TransactionsApi, Configuration as Configuration$1, QueueApi, NetworkApi, PoolsApi } from '@xchainjs/xchain-thornode';
-import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, baseAmount, AssetRuneNative, Chain, AssetAtom, AssetLUNA, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, TerraChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, isAssetRuneNative, assetFromString } from '@xchainjs/xchain-util';
+import { ObservedTxStatusEnum, TransactionsApi, Configuration as Configuration$1, QueueApi, NetworkApi, PoolsApi, LiquidityProvidersApi } from '@xchainjs/xchain-thornode';
+import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, baseAmount as baseAmount$1, AssetRuneNative as AssetRuneNative$1, Chain, AssetAtom, AssetLUNA, AssetAVAX, AssetETH, AssetBNB, AssetDOGE, AssetLTC, AssetBCH, AssetBTC, AvalancheChain, TerraChain, DOGEChain, LTCChain, BCHChain, CosmosChain, THORChain, ETHChain, BTCChain, BNBChain, isAssetRuneNative, assetFromString, assetAmount, assetFromStringEx } from '@xchainjs/xchain-util';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
+import { baseAmount, AssetRuneNative } from '@xchainjs/xchain-util/lib';
 import { Network } from '@xchainjs/xchain-client';
 import { MidgardApi, Configuration } from '@xchainjs/xchain-midgard';
 import axios from 'axios';
@@ -176,14 +177,114 @@ var TxStage;
     TxStage[TxStage["OUTBOUND_QUEUED"] = 3] = "OUTBOUND_QUEUED";
     TxStage[TxStage["OUTBOUND_CHAIN_UNCONFIRMED"] = 4] = "OUTBOUND_CHAIN_UNCONFIRMED";
     TxStage[TxStage["OUTBOUND_CHAIN_CONFIRMED"] = 5] = "OUTBOUND_CHAIN_CONFIRMED";
-})(TxStage || (TxStage = {}));
+})(TxStage || (TxStage = {}));
+// export type LiquidityProvider = {
+//   asset: string
+//   rune_address: string
+//   asset_address: string
+//   last_add_height: number
+//   last_withdraw_height: number
+//   units: number
+//   pending_rune: number
+//   pending_asset: number
+//   pending_tx_Id: string
+//   rune_deposit_value: number
+//   asset_deposit_value: number
+// }
+
+/**
+ * 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 P = new BigNumber(pool.pool.liquidityUnits);
+    const r = liquidity.rune.amount();
+    const a = liquidity.asset.amount();
+    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.amount();
+    const total = unitData.totalUnits.amount();
+    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) => {
+    // formula: (t * R - T * r)/ (T*r + R*T)
+    const r = stake.rune.amount();
+    const t = stake.asset.amount();
+    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 protectionProgress = (currentHeight - heightLastAdded) / blocksforfullprotection; // percentage of entitlement
+    const result = coverage.times(protectionProgress); // impermanent loss protection result
+    const ILProtection = {
+        ILProtection: new CryptoAmount(baseAmount(result), AssetRuneNative),
+        totalDays: (protectionProgress * 100).toFixed(2),
+    };
+    return ILProtection;
+};
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
     let baseAmountOut = inputAmount.baseAmount.amount();
     const adjustDecimals = outDecimals - inDecimals;
     baseAmountOut = baseAmountOut.times(Math.pow(10, adjustDecimals));
-    return baseAmount(baseAmountOut, outDecimals).amount();
+    return baseAmount$1(baseAmountOut, outDecimals).amount();
 };
 /**
  *
@@ -198,14 +299,14 @@ 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 ? AssetRuneNative : pool.asset;
+    const units = toRune ? AssetRuneNative$1 : pool.asset;
     const numerator = x.times(x).multipliedBy(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
-    const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
+    const eightDecimalResult = new CryptoAmount(baseAmount$1(result), units);
     const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
-    const swapFee = new CryptoAmount(baseAmount(baseOut, decimals), units);
+    const swapFee = new CryptoAmount(baseAmount$1(baseOut, decimals), units);
     //console.log(` swapFee ${swapFee.assetAmountFixedString()} `)
     return swapFee;
 };
@@ -236,15 +337,15 @@ 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 ? AssetRuneNative : pool.asset;
+    const units = toRune ? AssetRuneNative$1 : pool.asset;
     // const decimals = toRune || !pool.decimals ? 8 : pool.decimals
     const numerator = x.times(X).times(Y);
     const denominator = x.plus(X).pow(2);
     const result = numerator.div(denominator);
-    const eightDecimalResult = new CryptoAmount(baseAmount(result), units);
+    const eightDecimalResult = new CryptoAmount(baseAmount$1(result), units);
     const decimals = toRune ? 8 : inputAmount.baseAmount.decimal;
     const baseOut = getBaseAmountWithDiffDecimals(eightDecimalResult, decimals);
-    return new CryptoAmount(baseAmount(baseOut, decimals), units);
+    return new CryptoAmount(baseAmount$1(baseOut, decimals), units);
 };
 const getDoubleSwapOutput = (inputAmount, pool1, pool2) => {
     // formula: getSwapOutput(pool1) => getSwapOutput(pool2)
@@ -281,7 +382,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, AssetRuneNative);
+    const fee2InRune = yield thorchainCache.convert(fee2InAsset, AssetRuneNative$1);
     const result = fee1InRune.plus(fee2InRune);
     return result;
 });
@@ -314,23 +415,23 @@ const getDoubleSwap = (inputAmount, pool1, pool2, thorchainCache) => __awaiter(v
  */
 const calcNetworkFee = (asset, gasRate) => {
     if (asset.synth)
-        return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+        return new CryptoAmount(baseAmount$1(2000000), AssetRuneNative$1);
     switch (asset.chain) {
         case Chain.Bitcoin:
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(1000)), AssetBTC);
+            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(1000)), AssetBTC);
         case Chain.BitcoinCash:
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(1500)), AssetBCH);
+            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(1500)), AssetBCH);
         case Chain.Litecoin:
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(250)), AssetLTC);
+            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(250)), AssetLTC);
         case Chain.Doge:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(1000)), AssetDOGE);
+            return new CryptoAmount(baseAmount$1(gasRate.multipliedBy(1000)), AssetDOGE);
         case Chain.Binance:
             //flat fee
-            return new CryptoAmount(baseAmount(gasRate), AssetBNB);
+            return new CryptoAmount(baseAmount$1(gasRate), AssetBNB);
         case Chain.Ethereum:
             const gasRateinETHGwei = gasRate;
-            const gasRateinETHWei = baseAmount(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
+            const gasRateinETHWei = baseAmount$1(gasRateinETHGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetETH)) {
                 return new CryptoAmount(gasRateinETHWei.times(21000), AssetETH);
             }
@@ -339,7 +440,7 @@ const calcNetworkFee = (asset, gasRate) => {
             }
         case Chain.Avalanche:
             const gasRateinAVAXGwei = gasRate;
-            const gasRateinAVAXWei = baseAmount(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
+            const gasRateinAVAXWei = baseAmount$1(gasRateinAVAXGwei.multipliedBy(Math.pow(10, 9)), 18);
             if (eqAsset(asset, AssetAVAX)) {
                 return new CryptoAmount(gasRateinAVAXWei.times(21000), AssetAVAX);
             }
@@ -347,11 +448,11 @@ const calcNetworkFee = (asset, gasRate) => {
                 return new CryptoAmount(gasRateinAVAXWei.times(70000), AssetAVAX);
             }
         case Chain.Terra:
-            return new CryptoAmount(baseAmount(gasRate), AssetLUNA);
+            return new CryptoAmount(baseAmount$1(gasRate), AssetLUNA);
         case Chain.Cosmos:
-            return new CryptoAmount(baseAmount(gasRate), AssetAtom);
+            return new CryptoAmount(baseAmount$1(gasRate), AssetAtom);
         case Chain.THORChain:
-            return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+            return new CryptoAmount(baseAmount$1(2000000), AssetRuneNative$1);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
@@ -369,7 +470,7 @@ const getChainAsset = (chain) => {
         case ETHChain:
             return AssetETH;
         case THORChain:
-            return AssetRuneNative;
+            return AssetRuneNative$1;
         case CosmosChain:
             return AssetAtom;
         case BCHChain:
@@ -555,13 +656,13 @@ class ThorchainQuery {
                 ? params.input
                 : yield this.thorchainCache.convert(params.input, params.input.asset);
             // If asset is already rune native, skip the convert
-            const inputInRune = input.asset === AssetRuneNative ? input : yield this.thorchainCache.convert(input, AssetRuneNative);
+            const inputInRune = input.asset === AssetRuneNative$1 ? input : yield this.thorchainCache.convert(input, AssetRuneNative$1);
             const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails.gas_rate);
             let outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails.gas_rate);
             outboundFeeInAsset = outboundFeeInAsset.times(3);
             // convert fees to rune
-            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, AssetRuneNative);
-            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, AssetRuneNative);
+            const inboundFeeInRune = yield this.thorchainCache.convert(inboundFeeInAsset, AssetRuneNative$1);
+            let outboundFeeInRune = yield this.thorchainCache.convert(outboundFeeInAsset, AssetRuneNative$1);
             // ---------- Remove Fees from inbound before doing the swap -----------
             // TODO confirm with chris about this change, was there a reason why this was commented out?
             const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune);
@@ -577,18 +678,18 @@ class ThorchainQuery {
                 const deepestUSDPOOL = yield this.thorchainCache.getDeepestUSDPool();
                 const usdAsset = deepestUSDPOOL.asset;
                 const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
-                const usdMinFee = new CryptoAmount(baseAmount(networkValues['MINIMUML1OUTBOUNDFEEUSD']), usdAsset);
+                const usdMinFee = new CryptoAmount(baseAmount$1(networkValues['MINIMUML1OUTBOUNDFEEUSD']), usdAsset);
                 // const FeeInUSD = await this.convert(outboundFeeInRune, usdAsset)
                 const checkOutboundFee = (yield this.convert(outboundFeeInRune, usdAsset)).gte(usdMinFee);
                 if (!checkOutboundFee) {
                     const newFee = usdMinFee;
-                    outboundFeeInRune = yield this.convert(newFee, AssetRuneNative);
+                    outboundFeeInRune = yield this.convert(newFee, AssetRuneNative$1);
                 }
             }
             // Now calculate swap output based on inputNetAmount
             const swapOutput = yield this.thorchainCache.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
-            const swapFeeInRune = yield this.thorchainCache.convert(swapOutput.swapFee, AssetRuneNative);
-            const outputInRune = yield this.thorchainCache.convert(swapOutput.output, AssetRuneNative);
+            const swapFeeInRune = yield this.thorchainCache.convert(swapOutput.swapFee, AssetRuneNative$1);
+            const outputInRune = yield this.thorchainCache.convert(swapOutput.output, AssetRuneNative$1);
             // ---------------- Remove Outbound Fee ---------------------- /
             const netOutputInRune = outputInRune.minus(outboundFeeInRune);
             const netOutputInAsset = yield this.thorchainCache.convert(netOutputInRune, params.destinationAsset);
@@ -689,8 +790,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, AssetRuneNative);
-            const feesInRune = yield this.getFeesIn(estimate.totalFees, AssetRuneNative);
+            const inputInRune = yield this.thorchainCache.convert(params.input, AssetRuneNative$1);
+            const feesInRune = yield this.getFeesIn(estimate.totalFees, AssetRuneNative$1);
             const totalSwapFeesInRune = feesInRune.inboundFee
                 .plus(feesInRune.outboundFee)
                 .plus(feesInRune.swapFee)
@@ -777,13 +878,15 @@ class ThorchainQuery {
     outboundDelay(outboundAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const networkValues = yield this.thorchainCache.getNetworkValues();
-            const minTxOutVolumeThreshold = new CryptoAmount(baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative);
+            const minTxOutVolumeThreshold = new CryptoAmount(baseAmount$1(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative$1);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
-            let txOutDelayRate = new CryptoAmount(baseAmount(networkValues['TXOUTDELAYRATE']), AssetRuneNative);
+            let txOutDelayRate = new CryptoAmount(baseAmount$1(networkValues['TXOUTDELAYRATE']), AssetRuneNative$1).assetAmount
+                .amount()
+                .toNumber();
             const getScheduledOutboundValue = yield this.thorchainCache.midgard.getScheduledOutboundValue();
             const thorChainblocktime = this.chainAttributes[Chain.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);
+            const runeValue = yield this.thorchainCache.convert(outboundAmount, AssetRuneNative$1);
             // Check rune value amount
             if (runeValue.lt(minTxOutVolumeThreshold)) {
                 return thorChainblocktime;
@@ -797,11 +900,9 @@ class ThorchainQuery {
             // calculate the if outboundAmountTotal is over the volume threshold
             const volumeThreshold = outboundAmountTotal.div(minTxOutVolumeThreshold);
             // check delay rate
-            txOutDelayRate = txOutDelayRate.minus(volumeThreshold).baseAmount.amount().lt(1)
-                ? new CryptoAmount(baseAmount(1), AssetRuneNative)
-                : txOutDelayRate;
+            txOutDelayRate = txOutDelayRate - volumeThreshold.assetAmount.amount().toNumber() <= 1 ? 1 : txOutDelayRate;
             // calculate the minimum number of blocks in the future the txn has to be
-            let minBlocks = runeValue.div(txOutDelayRate).baseAmount.amount().toNumber();
+            let minBlocks = runeValue.assetAmount.amount().toNumber() / txOutDelayRate;
             minBlocks = minBlocks > maxTxOutOffset ? maxTxOutOffset : minBlocks;
             return minBlocks * thorChainblocktime;
         });
@@ -836,10 +937,12 @@ class ThorchainQuery {
             if (!pool)
                 throw Error(`No pool found from memo`);
             const getAsset = assetFromString(pool[1].toUpperCase());
+            if (!getAsset)
+                throw Error(`Invalid pool asset`);
             // Retrieve thorchain blockHeight for the tx
             if (!((_b = txData.observed_tx.tx) === null || _b === void 0 ? void 0 : _b.id))
                 throw Error('No action observed');
-            const recordedAction = yield this.thorchainCache.midgard.getActions(txData.observed_tx.tx.id);
+            const recordedAction = yield this.thorchainCache.midgard.getActions('', txData.observed_tx.tx.id);
             const recordedTCBlock = recordedAction.find((block) => {
                 return block;
             });
@@ -1013,6 +1116,228 @@ class ThorchainQuery {
             return txStatus;
         });
     }
+    /**
+     * Estimates a liquidity position for given crypto amount value, both asymmetrical and symetrical
+     * @param params - parameters needed for a estimated liquidity position
+     * @returns - type object EstimateLP
+     */
+    estimateAddLP(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (params.asset.asset.synth || params.rune.asset.synth)
+                errors.push('you cannot add liquidity with a synth');
+            if (!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.baseAmount, rune: params.rune.baseAmount }, assetPool);
+            const inboundDetails = yield this.thorchainCache.midgard.getInboundDetails();
+            const unitData = {
+                liquidityUnits: baseAmount$1(lpUnits),
+                totalUnits: baseAmount$1(assetPool.pool.liquidityUnits),
+            };
+            const poolShare = getPoolShare(unitData, assetPool);
+            const assetWaitTimeSeconds = yield this.confCounting(params.asset);
+            const runeWaitTimeSeconds = yield this.confCounting(params.rune);
+            const waitTimeSeconds = assetWaitTimeSeconds > runeWaitTimeSeconds ? assetWaitTimeSeconds : runeWaitTimeSeconds;
+            let assetInboundFee = new CryptoAmount(baseAmount$1(0), params.asset.asset);
+            let runeInboundFee = new CryptoAmount(baseAmount$1(0), AssetRuneNative$1);
+            if (!params.asset.assetAmount.eq(0)) {
+                assetInboundFee = calcNetworkFee(params.asset.asset, inboundDetails[params.asset.asset.chain].gas_rate);
+                if (assetInboundFee.assetAmount.amount().times(3).gt(params.asset.assetAmount.amount()))
+                    errors.push(`Asset amount is less than fees`);
+            }
+            if (!params.rune.assetAmount.eq(0)) {
+                runeInboundFee = calcNetworkFee(params.rune.asset, inboundDetails[params.rune.asset.chain].gas_rate);
+                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, AssetRuneNative$1)).plus(runeInboundFee);
+            const slip = getSlipOnLiquidity({ asset: params.asset.baseAmount, rune: params.rune.baseAmount }, assetPool);
+            const estimateLP = {
+                slipPercent: slip.times(100),
+                poolShare: poolShare,
+                lpUnits: baseAmount$1(lpUnits),
+                runeToAssetRatio: assetPool.runeToAssetRatio,
+                transactionFee: {
+                    assetFee: assetInboundFee,
+                    runeFee: runeInboundFee,
+                    totalFees: totalFees,
+                },
+                estimatedWaitSeconds: waitTimeSeconds,
+                errors,
+                canAdd: errors.length > 0 ? false : true,
+            };
+            return estimateLP;
+        });
+    }
+    /**
+     * @param - Asset for lp
+     * @param address - address used for Lp
+     * @returns - Type Object liquidityPosition
+     */
+    checkLiquidityPosition(asset, assetOrRuneAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolAsset = yield this.thorchainCache.getPoolForAsset(asset);
+            if (!poolAsset)
+                throw Error(`Could not find pool for ${asset}`);
+            const liquidityProvider = yield this.thorchainCache.thornode.getLiquidityProvider(poolAsset.assetString, assetOrRuneAddress);
+            if (!liquidityProvider)
+                throw Error(`Could not find LP for ${assetOrRuneAddress}`);
+            // Current block number for that chain
+            const blockData = (yield this.thorchainCache.thornode.getLastBlock()).find((item) => item.chain === asset.chain);
+            if (!blockData)
+                throw Error(`Could not get block data`);
+            // Pools total units & Lp's total units
+            const unitData = {
+                totalUnits: baseAmount$1(poolAsset.pool.liquidityUnits),
+                liquidityUnits: baseAmount$1(liquidityProvider.units),
+            };
+            //console.log(`unit data`, unitData.totalUnits.amount().toNumber(), unitData.liquidityUnits.amount().toNumber())
+            const networkValues = yield this.thorchainCache.midgard.getNetworkValues();
+            const block = {
+                current: blockData.thorchain,
+                lastAdded: liquidityProvider.last_add_height,
+                fullProtection: networkValues['FULLIMPLOSSPROTECTIONBLOCKS'],
+            };
+            //
+            const currentLP = {
+                asset: baseAmount$1(liquidityProvider.asset_deposit_value),
+                rune: baseAmount$1(liquidityProvider.rune_deposit_value),
+            };
+            const poolShare = getPoolShare(unitData, poolAsset);
+            // console.log(poolShare.assetShare.toNumber(), poolShare.runeShare.toNumber())
+            // console.log(poolAsset.pool.liquidityUnits)
+            const impermanentLossProtection = getLiquidityProtectionData(currentLP, poolShare, block);
+            const lpPosition = {
+                poolShare,
+                position: liquidityProvider,
+                impermanentLossProtection: impermanentLossProtection,
+            };
+            return lpPosition;
+        });
+    }
+    /**
+     * Do not send assetNativeRune, There is no pool for it.
+     * @param asset - asset required to find the pool
+     * @returns - object type ratios
+     */
+    getPoolRatios(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetPool = yield this.thorchainCache.getPoolForAsset(asset);
+            const poolRatio = {
+                assetToRune: assetPool.assetToRuneRatio,
+                runeToAsset: assetPool.runeToAssetRatio,
+            };
+            return poolRatio;
+        });
+    }
+    /**
+     *
+     * @param params
+     */
+    estimateWithdrawLP(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Caution Dust Limits: BTC,BCH,LTC chains 10k sats; DOGE 1m Sats; ETH 0 wei; THOR 0 RUNE.
+            if (!params.assetAddress)
+                throw Error(`can't estimate lp without an asset address`);
+            const memberDetail = yield this.checkLiquidityPosition(params.asset, params.assetAddress);
+            const dustValues = yield this.getDustValues(params.asset); // returns asset and rune dust values
+            const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset);
+            // get pool share from unit data
+            const poolShare = getPoolShare({
+                liquidityUnits: baseAmount$1(memberDetail.position.units),
+                totalUnits: baseAmount$1(assetPool.pool.liquidityUnits),
+            }, assetPool);
+            // calculate total fees
+            const totalFees = (yield this.convert(dustValues.asset, AssetRuneNative$1)).plus(dustValues.rune);
+            // get slip on liquidity removal
+            const slip = getSlipOnLiquidity({
+                asset: poolShare.assetShare.baseAmount,
+                rune: poolShare.runeShare.baseAmount,
+            }, assetPool);
+            // TODO make sure we compare wait times for withdrawing both rune and asset OR just rune OR just asset
+            const waitTimeSecondsForAsset = yield this.confCounting(poolShare.assetShare.div(params.percentage / 100));
+            const waitTimeSecondsForRune = yield this.confCounting(poolShare.runeShare.div(params.percentage / 100));
+            let waitTimeSeconds = 0;
+            if (params.assetAddress && params.runeAddress) {
+                waitTimeSeconds = waitTimeSecondsForAsset + waitTimeSecondsForRune;
+            }
+            else if (params.assetAddress) {
+                waitTimeSeconds = waitTimeSecondsForAsset;
+            }
+            else {
+                waitTimeSeconds = waitTimeSecondsForRune;
+            }
+            const estimateLP = {
+                slipPercent: slip.times(100),
+                transactionFee: {
+                    assetFee: dustValues.asset,
+                    runeFee: dustValues.rune,
+                    totalFees: totalFees,
+                },
+                assetAmount: poolShare.assetShare,
+                runeAmount: poolShare.runeShare,
+                estimatedWaitSeconds: waitTimeSeconds,
+                impermanentLossProtection: memberDetail.impermanentLossProtection,
+            };
+            return estimateLP;
+        });
+    }
+    /**
+     * // can this become a quried constant? added to inbound_addresses or something
+     * @param asset - asset needed to retrieve dust values
+     * @returns - object type dust values
+     */
+    getDustValues(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let dustValues;
+            switch (asset.chain) {
+                case 'BNB':
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0.000001)), AssetBNB),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                    };
+                    return dustValues;
+                case 'BTC'  :
+                    // 10k sats
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0.0001)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                    };
+                    return dustValues;
+                case 'ETH':
+                    // 0 wei
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                    };
+                    return dustValues;
+                case 'THOR':
+                    // 0 Rune
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                    };
+                    return dustValues;
+                case 'GAIA':
+                    // 0 GAIA
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                    };
+                    return dustValues;
+                case 'DOGE':
+                    // 1 million sats
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0.01)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative$1),
+                    };
+                    return dustValues;
+                default:
+                    throw Error('Unknown chain');
+            }
+        });
+    }
 }
 
 /**
@@ -1027,8 +1352,8 @@ class LiquidityPool {
         this.asset = asset;
         this.decimals = decimals;
         this.assetString = this.pool.asset;
-        this.assetBalance = baseAmount(this.pool.assetDepth);
-        this.runeBalance = baseAmount(this.pool.runeDepth);
+        this.assetBalance = baseAmount$1(this.pool.assetDepth);
+        this.runeBalance = baseAmount$1(this.pool.runeDepth);
         this.runeToAssetRatio = this.runeBalance.amount().div(this.assetBalance.amount());
         this.assetToRuneRatio = this.assetBalance.amount().div(this.runeBalance.amount());
     }
@@ -1042,12 +1367,15 @@ const TEN_MINUTES = 10 * 60 * 1000;
 const DEFAULT_THORCHAIN_DECIMALS = 8;
 const USD_ASSETS = {
     mainnet: [
-        assetFromString('BNB.BUSD-BD1'),
-        assetFromString('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48'),
-        assetFromString('ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7'),
+        assetFromStringEx('BNB.BUSD-BD1'),
+        assetFromStringEx('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48'),
+        assetFromStringEx('ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7'),
+    ],
+    stagenet: [assetFromStringEx('ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7')],
+    testnet: [
+        assetFromStringEx('BNB.BUSD-74E'),
+        assetFromStringEx('ETH.USDT-0XA3910454BF2CB59B8B3A401589A3BACC5CA42306'),
     ],
-    stagenet: [assetFromString('ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7')],
-    testnet: [assetFromString('BNB.BUSD-74E'), assetFromString('ETH.USDT-0XA3910454BF2CB59B8B3A401589A3BACC5CA42306')],
 };
 /**
  * This class manages retrieving information from up to date Thorchain
@@ -1279,7 +1607,7 @@ class ThorchainCache {
             let baseAmountOut = input.baseAmount.times(exchangeRate).amount();
             const adjustDecimals = outDecimals - inDecimals;
             baseAmountOut = baseAmountOut.times(Math.pow(10, adjustDecimals));
-            const amt = baseAmount(baseAmountOut, outDecimals);
+            const amt = baseAmount$1(baseAmountOut, outDecimals);
             const result = new CryptoAmount(amt, outAsset);
             // console.log(
             //   `${input.formatedAssetString()} ${input.asset.ticker} = ${result.formatedAssetString()} ${outAsset.ticker}`,
@@ -1306,6 +1634,10 @@ class ThorchainCache {
             return inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router;
         });
     }
+    /**
+     *
+     * @returns - inbound adresses item
+     */
     getInboundAddressesItems() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1326,6 +1658,10 @@ class ThorchainCache {
             }
         });
     }
+    /**
+     *
+     * @returns - inbound details
+     */
     getInboundDetails() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1346,6 +1682,10 @@ class ThorchainCache {
             }
         });
     }
+    /**
+     *
+     * @returns - network values
+     */
     getNetworkValues() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1385,95 +1725,13 @@ class ThorchainCache {
     }
 }
 
-/**
- *
- * @param liquidity - asset amount added
- * @param pool  - pool depths
- * @returns liquidity units
- */
-const getLiquidityUnits = (liquidity, pool) => {
-    // formula: ((R + T) (r T + R t))/(4 R T)
-    // part1 * (part2 + part3) / denominator
-    const r = liquidity.rune;
-    const t = liquidity.asset;
-    const R = pool.runeBalance.amount().plus(r); // Must add r first
-    const T = pool.assetBalance.amount().plus(t); // Must add t first
-    const part1 = R.plus(T);
-    const part2 = r.times(T);
-    const part3 = R.times(t);
-    const numerator = part1.times(part2.plus(part3));
-    const denominator = R.times(T).times(4);
-    const result = numerator.div(denominator);
-    return result;
-};
-/**
- *
- * @param unitData
- * @param pool
- * @returns
- */
-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 liquidityData = {
-        asset: asset,
-        rune: rune,
-    };
-    return liquidityData;
-};
-/**
- *
- * @param liquidity
- * @param pool
- * @returns
- */
-const getSlipOnLiquidity = (liquidity, pool) => {
-    // formula: (t * R - T * r)/ (T*r + R*T)
-    const r = liquidity.rune;
-    const t = liquidity.asset;
-    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;
-};
-/**
- *
- * @param liquidity
- * @param pool
- * @param block
- * @returns
- */
-// Blocks for full protection 144000 // 100 days
-const getLiquidityProtectionData = (liquidity, pool, block) => {
-    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
-    const R0 = liquidity.rune; // symetrical value of rune deposit
-    const A0 = liquidity.asset; // symetrical value of asset deposit
-    const R1 = pool.runeBalance.amount(); // rune to redeem
-    const A1 = pool.assetBalance.amount(); // asset to redeem
-    const P1 = R1.div(A1); // Pool ratio at withdrawal
-    const coverage = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1));
-    const currentHeight = block.current;
-    const heightLastAdded = block.lastAdded;
-    const blocksforfullprotection = block.fullProtection;
-    const protectionProgress = (currentHeight - heightLastAdded) / blocksforfullprotection;
-    const result = protectionProgress * coverage.toNumber(); // impermanent loss protection result
-    return result;
-};
-
 const defaultMidgardConfig = {
     mainnet: {
         apiRetries: 3,
         midgardBaseUrls: [
+            'https://midgard.ninerealms.com',
             'https://midgard.thorchain.info',
             'https://midgard.thorswap.net',
-            'https://midgard.ninerealms.com',
         ],
     },
     stagenet: {
@@ -1570,6 +1828,10 @@ class Midgard {
             return inboundDetails;
         });
     }
+    /**
+     *
+     * @returns - constants
+     */
     getConstantsDetails() {
         return __awaiter(this, void 0, void 0, function* () {
             const path = '/v2/thorchain/constants';
@@ -1595,7 +1857,7 @@ class Midgard {
             for (const baseUrl of this.config.midgardBaseUrls) {
                 try {
                     const { data } = yield axios.get(`${baseUrl}${path}`);
-                    const value = new CryptoAmount(baseAmount(data['scheduled_outbound_value']), AssetRuneNative);
+                    const value = new CryptoAmount(baseAmount$1(data['scheduled_outbound_value']), AssetRuneNative$1);
                     return value;
                 }
                 catch (e) {
@@ -1647,15 +1909,15 @@ class Midgard {
         });
     }
     /**
-     * Gets actions related to a txID
+     * Gets actions object for any of the parameters
      * @param txHash transaction id
      * @returns Type Action array of objects
      */
-    getActions(txHash) {
+    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('', txHash)).data.actions;
+                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
                     return actions;
                 }
                 catch (e) {
@@ -1665,6 +1927,44 @@ class Midgard {
             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`);
+        });
+    }
 }
 
 const defaultThornodeConfig = {
@@ -1694,6 +1994,7 @@ class Thornode {
         this.queueApi = this.config.thornodeBaseUrls.map((url) => new QueueApi(new Configuration$1({ basePath: url })));
         this.networkApi = this.config.thornodeBaseUrls.map((url) => new NetworkApi(new Configuration$1({ basePath: url })));
         this.poolsApi = this.config.thornodeBaseUrls.map((url) => new PoolsApi(new Configuration$1({ basePath: url })));
+        this.liquidityProvidersApi = this.config.thornodeBaseUrls.map((url) => new LiquidityProvidersApi(new Configuration$1({ basePath: url })));
     }
     /**
      * Returns the oubound transactions held by THORChain due to outbound delay
@@ -1717,6 +2018,11 @@ class Thornode {
             throw Error(`THORNode not responding`);
         });
     }
+    /**
+     *
+     * @param txHash - transaction hash
+     * @returns - transaction object
+     */
     getTxData(txHash) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.transactionsApi) {
@@ -1735,6 +2041,11 @@ class Thornode {
             throw new Error(`THORNode not responding`);
         });
     }
+    /**
+     *
+     * @param height - optional thorchain height only
+     * @returns - last block data || or block data pertaining to that height number
+     */
     getLastBlock(height) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.networkApi) {
@@ -1749,6 +2060,10 @@ class Thornode {
             throw new Error(`THORNode not responding`);
         });
     }
+    /**
+     *
+     * @returns - thorchain pool
+     */
     getPools() {
         return __awaiter(this, void 0, void 0, function* () {
             for (const api of this.poolsApi) {
@@ -1764,6 +2079,27 @@ class Thornode {
             throw new Error(`THORNode not responding`);
         });
     }
+    /**
+     *
+     * @param asset - asset string
+     * @param address - address
+     * @param height - optional block height, defaults to current tip
+     * @returns
+     */
+    getLiquidityProvider(asset, address, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.liquidityProvidersApi) {
+                try {
+                    const lps = (yield api.liquidityProviders(asset, height)).data;
+                    return lps.find((lp) => lp.asset_address === address || lp.rune_address === address);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error(`THORNode not responding`);
+        });
+    }
 }
 
 export { CryptoAmount, LiquidityPool, Midgard, ThorchainCache, ThorchainQuery, Thornode, TxStage, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity };