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

package/lib/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var xchainThornode = require('@xchainjs/xchain-thornode');
 var xchainUtil = require('@xchainjs/xchain-util');
 var BigNumber = require('bignumber.js');
+var lib = require('@xchainjs/xchain-util/lib');
 var xchainClient = require('@xchainjs/xchain-client');
 var xchainMidgard = require('@xchainjs/xchain-midgard');
 var axios = require('axios');
@@ -185,7 +186,107 @@ class CryptoAmount {
     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";
-})(exports.TxStage || (exports.TxStage = {}));
+})(exports.TxStage || (exports.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.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(lib.baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(lib.baseAmount(rune), lib.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(lib.baseAmount(result), lib.AssetRuneNative),
+        totalDays: (protectionProgress * 100).toFixed(2),
+    };
+    return ILProtection;
+};
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
@@ -788,7 +889,9 @@ class ThorchainQuery {
             const networkValues = yield this.thorchainCache.getNetworkValues();
             const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), xchainUtil.AssetRuneNative);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
-            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainUtil.AssetRuneNative);
+            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainUtil.AssetRuneNative).assetAmount
+                .amount()
+                .toNumber();
             const getScheduledOutboundValue = yield this.thorchainCache.midgard.getScheduledOutboundValue();
             const thorChainblocktime = this.chainAttributes[xchainUtil.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
@@ -806,11 +909,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(xchainUtil.baseAmount(1), xchainUtil.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;
         });
@@ -850,7 +951,7 @@ class ThorchainQuery {
             // 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;
             });
@@ -1024,6 +1125,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 (!xchainUtil.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: xchainUtil.baseAmount(lpUnits),
+                totalUnits: xchainUtil.baseAmount(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(xchainUtil.baseAmount(0), params.asset.asset);
+            let runeInboundFee = new CryptoAmount(xchainUtil.baseAmount(0), xchainUtil.AssetRuneNative);
+            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, xchainUtil.AssetRuneNative)).plus(runeInboundFee);
+            const slip = getSlipOnLiquidity({ asset: params.asset.baseAmount, rune: params.rune.baseAmount }, assetPool);
+            const estimateLP = {
+                slipPercent: slip.times(100),
+                poolShare: poolShare,
+                lpUnits: xchainUtil.baseAmount(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: xchainUtil.baseAmount(poolAsset.pool.liquidityUnits),
+                liquidityUnits: xchainUtil.baseAmount(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: xchainUtil.baseAmount(liquidityProvider.asset_deposit_value),
+                rune: xchainUtil.baseAmount(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: xchainUtil.baseAmount(memberDetail.position.units),
+                totalUnits: xchainUtil.baseAmount(assetPool.pool.liquidityUnits),
+            }, assetPool);
+            // calculate total fees
+            const totalFees = (yield this.convert(dustValues.asset, xchainUtil.AssetRuneNative)).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(xchainUtil.assetToBase(xchainUtil.assetAmount(0.000001)), xchainUtil.AssetBNB),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'BTC'  :
+                    // 10k sats
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.0001)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'ETH':
+                    // 0 wei
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'THOR':
+                    // 0 Rune
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'GAIA':
+                    // 0 GAIA
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'DOGE':
+                    // 1 million sats
+                    dustValues = {
+                        asset: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0.01)), asset),
+                        rune: new CryptoAmount(xchainUtil.assetToBase(xchainUtil.assetAmount(0)), xchainUtil.AssetRuneNative),
+                    };
+                    return dustValues;
+                default:
+                    throw Error('Unknown chain');
+            }
+        });
+    }
 }
 
 /**
@@ -1320,6 +1643,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* () {
@@ -1340,6 +1667,10 @@ class ThorchainCache {
             }
         });
     }
+    /**
+     *
+     * @returns - inbound details
+     */
     getInboundDetails() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1360,6 +1691,10 @@ class ThorchainCache {
             }
         });
     }
+    /**
+     *
+     * @returns - network values
+     */
     getNetworkValues() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1399,95 +1734,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: {
@@ -1584,6 +1837,10 @@ class Midgard {
             return inboundDetails;
         });
     }
+    /**
+     *
+     * @returns - constants
+     */
     getConstantsDetails() {
         return __awaiter(this, void 0, void 0, function* () {
             const path = '/v2/thorchain/constants';
@@ -1661,15 +1918,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) {
@@ -1679,6 +1936,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 = {
@@ -1708,6 +2003,7 @@ class Thornode {
         this.queueApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.QueueApi(new xchainThornode.Configuration({ basePath: url })));
         this.networkApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.NetworkApi(new xchainThornode.Configuration({ basePath: url })));
         this.poolsApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.PoolsApi(new xchainThornode.Configuration({ basePath: url })));
+        this.liquidityProvidersApi = this.config.thornodeBaseUrls.map((url) => new xchainThornode.LiquidityProvidersApi(new xchainThornode.Configuration({ basePath: url })));
     }
     /**
      * Returns the oubound transactions held by THORChain due to outbound delay
@@ -1731,6 +2027,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) {
@@ -1749,6 +2050,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) {
@@ -1763,6 +2069,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) {
@@ -1778,6 +2088,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`);
+        });
+    }
 }
 
 exports.CryptoAmount = CryptoAmount;

package/lib/thorchain-cache.d.ts

@@ -105,8 +105,20 @@ export declare class ThorchainCache {
     convert(input: CryptoAmount, outAsset: Asset): Promise<CryptoAmount>;
     private getDecimalForAsset;
     getRouterAddressForChain(chain: Chain): Promise<Address>;
+    /**
+     *
+     * @returns - inbound adresses item
+     */
     getInboundAddressesItems(): Promise<Record<string, InboundAddressesItem>>;
+    /**
+     *
+     * @returns - inbound details
+     */
     getInboundDetails(): Promise<Record<string, InboundDetail>>;
+    /**
+     *
+     * @returns - network values
+     */
     getNetworkValues(): Promise<Record<string, number>>;
     getDeepestUSDPool(): Promise<LiquidityPool>;
 }