@xchainjs/xchain-thorchain-query 0.7.2 → 0.7.4

package/lib/index.esm.js

@@ -31,55 +31,56 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+// Default attributes for each chain
 const DefaultChainAttributes = {
     BCH: {
         blockReward: 6.25,
-        avgBlockTimeInSecs: 600,
+        avgBlockTimeInSecs: 600, // Average block time for Bitcoin Cash in seconds
     },
     BTC: {
         blockReward: 6.25,
-        avgBlockTimeInSecs: 600,
+        avgBlockTimeInSecs: 600, // Average block time for Bitcoin in seconds
     },
     ETH: {
         blockReward: 2,
-        avgBlockTimeInSecs: 13,
+        avgBlockTimeInSecs: 13, // Average block time for Ethereum in seconds
     },
     AVAX: {
         blockReward: 2,
-        avgBlockTimeInSecs: 3,
+        avgBlockTimeInSecs: 3, // Average block time for Avalanche in seconds
     },
     LTC: {
         blockReward: 12.5,
-        avgBlockTimeInSecs: 150,
+        avgBlockTimeInSecs: 150, // Average block time for Litecoin in seconds
     },
     DOGE: {
         blockReward: 10000,
-        avgBlockTimeInSecs: 60,
+        avgBlockTimeInSecs: 60, // Average block time for Dogecoin in seconds
     },
     GAIA: {
         blockReward: 0,
-        avgBlockTimeInSecs: 6,
+        avgBlockTimeInSecs: 6, // Average block time for Gaia in seconds
     },
     BNB: {
         blockReward: 0,
-        avgBlockTimeInSecs: 6,
+        avgBlockTimeInSecs: 6, // Average block time for Binance Coin in seconds
     },
     THOR: {
         blockReward: 0,
-        avgBlockTimeInSecs: 6,
+        avgBlockTimeInSecs: 6, // Average block time for THORChain in seconds
     },
     BSC: {
         blockReward: 0,
-        avgBlockTimeInSecs: 3,
+        avgBlockTimeInSecs: 3, // Average block time for Binance Smart Chain in seconds
     },
     MAYA: {
         blockReward: 0,
-        avgBlockTimeInSecs: 6,
+        avgBlockTimeInSecs: 6, // Average block time for MAYAChain in seconds
     },
 };
 
 /**
- * Represent a Liquidity Pool in Thorchain
+ * Represents a Liquidity Pool in Thorchain
  */
 class LiquidityPool {
     constructor(thornodeDetails) {
@@ -92,9 +93,14 @@ class LiquidityPool {
         this.assetString = this.thornodeDetails.asset;
         this.assetBalance = baseAmount(this.thornodeDetails.balance_asset);
         this.runeBalance = baseAmount(this.thornodeDetails.balance_rune);
+        // Calculate the ratio of Rune to the asset and the ratio of the asset to Rune
         this.runeToAssetRatio = this.runeBalance.amount().div(this.assetBalance.amount());
         this.assetToRuneRatio = this.assetBalance.amount().div(this.runeBalance.amount());
     }
+    /**
+     * Checks if the liquidity pool is available
+     * @returns {boolean} True if the liquidity pool is available, otherwise false
+     */
     isAvailable() {
         return this.thornodeDetails.status.toLowerCase() === 'available';
     }
@@ -809,36 +815,37 @@ class Thornode {
     }
 }
 
+// Constants
 const SAME_ASSET_EXCHANGE_RATE = new BigNumber(1);
 const TEN_MINUTES = 10 * 60 * 1000;
+// Default instances
 const defaultThornode = new Thornode();
 const defaultMidgardQuery = new MidgardQuery();
 /**
- * This class manages retrieving information from up to date Thorchain
+ * This class manages retrieving information from up-to-date Thorchain.
  */
 class ThorchainCache {
     /**
      * Constructor to create a ThorchainCache
-     *
-     * @param thornode - an instance of the thornode API (could be pointing to stagenet,testnet,mainnet)
-     * @param midgardQuery - an instance of the midgard query class (could be pointing to stagenet,testnet,mainnet)
-     * @param expirePoolCacheMillis - how long should the pools be cached before expiry
-     * @param expireInboundDetailsCacheMillis - how long should the InboundDetails be cached before expiry
-     * @param expireNetworkValuesCacheMillis - how long should the Mimir/Constants be cached before expiry
+     * @param thornode - An instance of the Thornode API (could be pointing to stagenet, testnet, or mainnet).
+     * @param midgardQuery - An instance of the MidgardQuery class (could be pointing to stagenet, testnet, or mainnet).
+     * @param expirePoolCacheMillis - How long the pools should be cached before expiry.
+     * @param expireInboundDetailsCacheMillis - How long the InboundDetails should be cached before expiry.
+     * @param expireNetworkValuesCacheMillis - How long the Mimir/Constants should be cached before expiry.
      * @returns ThorchainCache
      */
     constructor(thornode = defaultThornode, midgardQuery = defaultMidgardQuery, expirePoolCacheMillis = 6000, expireInboundDetailsCacheMillis = 6000, expireNetworkValuesCacheMillis = TEN_MINUTES) {
         this.thornode = thornode;
         this.midgardQuery = midgardQuery;
+        // Initialize cached values
         this.poolCache = new CachedValue(() => this.refreshPoolCache(), expirePoolCacheMillis);
         this.inboundDetailCache = new CachedValue(() => this.refreshInboundDetailCache(), expireInboundDetailsCacheMillis);
         this.networkValuesCache = new CachedValue(() => thornode.getNetworkValues(), expireNetworkValuesCacheMillis);
     }
     /**
-     * Gets the exchange rate of the from asset in terms on the to asset
-     *
-     * @param asset - cannot be RUNE.
-     * @returns Promise<BigNumber>
+     * Gets the exchange rate of the `from` asset in terms of the `to` asset.
+     * @param asset - The asset to swap from.
+     * @returns Promise<BigNumber> - The exchange rate.
      */
     getExchangeRate(from, to) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -868,10 +875,9 @@ class ThorchainCache {
         });
     }
     /**
-     * Gets the Liquidity Pool for a given Asset
-     *
-     * @param asset - cannot be RUNE, since Rune is the other side of each pool.
-     * @returns Promise<LiquidityPool>
+     * Gets the Liquidity Pool for a given Asset.
+     * @param asset - The asset to retrieve the pool for.
+     * @returns Promise<LiquidityPool> - The liquidity pool.
      */
     getPoolForAsset(asset) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -889,9 +895,8 @@ class ThorchainCache {
     }
     /**
      * Get all the Liquidity Pools currently cached.
-     * if the cache is expired, the pools wioll be re-fetched from thornode
-     *
-     * @returns Promise<Record<string, LiquidityPool>>
+     * If the cache is expired, the pools will be re-fetched from Thornode.
+     * @returns Promise<Record<string, LiquidityPool>> - The liquidity pools.
      */
     getPools() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -905,7 +910,8 @@ class ThorchainCache {
         });
     }
     /**
-     * Refreshes the Pool Cache
+     * Refreshes the Pool Cache.
+     * @returns Promise<Record<string, LiquidityPool> |
      */
     refreshPoolCache() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -935,14 +941,17 @@ class ThorchainCache {
         });
     }
     /**
-     * Refreshes the InboundDetailCache Cache
+     * Refreshes the InboundDetailCache Cache.
+     * @returns Promise<Record<string, InboundDetail>> - The refreshed inbound detail cache.
      */
     refreshInboundDetailCache() {
         return __awaiter(this, void 0, void 0, function* () {
+            // Fetching mimir details and all inbound addresses concurrently
             const [mimirDetails, allInboundAddresses] = yield Promise.all([
                 this.thornode.getMimir(),
                 this.thornode.getInboundAddresses(),
             ]);
+            // Mapping inbound details
             const inboundDetails = {};
             for (const inbound of allInboundAddresses) {
                 const chain = inbound.chain;
@@ -954,6 +963,7 @@ class ThorchainCache {
                     !inbound.outbound_fee ||
                     !inbound.gas_rate_units)
                     throw new Error(`Missing required inbound info`);
+                // Adding mock THORCHAIN inbound details
                 const details = {
                     chain: chain,
                     address: inbound.address,
@@ -986,13 +996,10 @@ class ThorchainCache {
         });
     }
     /**
-     * Returns the exchange of a CryptoAmount to a different Asset
-     *
-     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
-     *
-     * @param input - amount/asset to convert to outAsset
-     * @param outAsset - the Asset you want to convert to
-     * @returns CryptoAmount of input
+     * Returns the exchange of a CryptoAmount to a different Asset.
+     * @param input - The amount/asset to convert.
+     * @param outAsset - The asset you want to convert to.
+     * @returns Promise<CryptoAmount> - The converted amount.
      */
     convert(input, outAsset) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1007,6 +1014,11 @@ class ThorchainCache {
             return result;
         });
     }
+    /**
+     * Gets the router address for a given chain.
+     * @param chain - The chain to get the router address for.
+     * @returns Promise<Address> - The router address.
+     */
     getRouterAddressForChain(chain) {
         return __awaiter(this, void 0, void 0, function* () {
             const inboundAsgard = (yield this.getInboundDetails())[chain];
@@ -1017,8 +1029,8 @@ class ThorchainCache {
         });
     }
     /**
-     *
-     * @returns - inbound details
+     * Gets the inbound details.
+     * @returns Promise<Record<string, InboundDetail>> - The inbound details.
      */
     getInboundDetails() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1031,8 +1043,8 @@ class ThorchainCache {
         });
     }
     /**
-     *
-     * @returns - network values
+     * Gets the network values.
+     * @returns Promise<Record<string, number>> - The network values.
      */
     getNetworkValues() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1048,7 +1060,7 @@ class ThorchainCache {
 
 const defaultCache = new ThorchainCache();
 /**
- * THORChain Class for interacting with THORChain.
+ * ThorchainQuery Class for interacting with THORChain.
  * Recommended main class to use for swapping with THORChain
  * Has access to Midgard and THORNode data
  */
@@ -1064,14 +1076,14 @@ class ThorchainQuery {
         this.thorchainCache = thorchainCache;
         this.chainAttributes = chainAttributes;
     }
-    /**
+    /** Quote a swap transaction.
      *
-     * @param quoteSwapParams -  input params
-     * @returns
+     * @param quoteSwapParams - Input parameters for the swap quote.
+     * @returns Transaction details including memo, address, fees, etc.
      */
     quoteSwap({ fromAsset, destinationAsset, amount, destinationAddress, streamingInterval, streamingQuantity, toleranceBps, affiliateBps, affiliateAddress, height, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            // validates swap, and pushes error if there is one
+            // Validates swap and pushes error if there is one
             const errors = [];
             const error = yield this.validateAmount(amount);
             if (error)
@@ -1079,13 +1091,14 @@ class ThorchainQuery {
             const fromAssetString = assetToString(fromAsset);
             const toAssetString = assetToString(destinationAsset);
             const inputAmount = getBaseAmountWithDiffDecimals(amount, 8);
-            // fetch quote
+            // Fetch quote
             const swapQuote = yield this.thorchainCache.thornode.getSwapQuote(fromAssetString, toAssetString, inputAmount.toNumber(), destinationAddress, streamingInterval, streamingQuantity, toleranceBps, affiliateBps, affiliateAddress, height);
-            // error handling for fetch response
+            // Error handling for fetch response
             const response = JSON.parse(JSON.stringify(swapQuote));
             if (response.error)
                 errors.push(`Thornode request quote: ${response.error}`);
             if (errors.length > 0) {
+                // If there are errors, construct and return a transaction details object with error information
                 return {
                     memo: ``,
                     toAddress: ``,
@@ -1163,63 +1176,70 @@ class ThorchainQuery {
      */
     validateAmount(cryptoAmount) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Get the number of decimals for the asset
             const assetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(cryptoAmount.asset);
+            // Check if the base amount decimal is equal to the asset's decimal
             if (cryptoAmount.baseAmount.decimal !== assetDecimals)
                 return new Error(`Invalid number of decimals: ${assetToString(cryptoAmount.asset)} must have ${assetDecimals} decimals`);
         });
     }
     /**
      * Works out how long an outbound Tx will be held by THORChain before sending.
-     *
      * @param outboundAmount: CryptoAmount  being sent.
      * @returns required delay in seconds
      * @see https://gitlab.com/thorchain/thornode/-/blob/develop/x/thorchain/manager_txout_current.go#L548
      */
     outboundDelay(outboundAmount) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Retrieve network values
             const networkValues = yield this.thorchainCache.getNetworkValues();
+            // Create CryptoAmounts for minimum transaction out volume threshold and maximum transaction out offset
             const minTxOutVolumeThreshold = new CryptoAmount(baseAmount(networkValues['MINTXOUTVOLUMETHRESHOLD']), AssetRuneNative);
             const maxTxOutOffset = networkValues['MAXTXOUTOFFSET'];
+            // Get the delay rate for outbound transactions
             let txOutDelayRate = new CryptoAmount(baseAmount(networkValues['TXOUTDELAYRATE']), AssetRuneNative).assetAmount
                 .amount()
                 .toNumber();
+            // Get the outbound queue
             const getQueue = yield this.thorchainCache.thornode.getQueue();
+            // Create a CryptoAmount for the scheduled outbound value
             const outboundValue = new CryptoAmount(baseAmount(getQueue.scheduled_outbound_value), AssetRuneNative);
+            // Get the average block time for THORChain
             const thorChainblocktime = this.chainAttributes[THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
-            // If asset is equal to Rune set runeValue as outbound amount else set it to the asset's value in rune
+            // Convert the outbound amount to its value in RUNE
             const runeValue = yield this.thorchainCache.convert(outboundAmount, AssetRuneNative);
-            // Check rune value amount
+            // Check if the rune value is less than the minimum transaction out volume threshold
             if (runeValue.lt(minTxOutVolumeThreshold)) {
                 return thorChainblocktime;
             }
-            // Rune value in the outbound queue
+            // Check if the outbound value is undefined
             if (outboundValue == undefined) {
                 throw new Error(`Could not return Scheduled Outbound Value`);
             }
-            // Add OutboundAmount in rune to the oubound queue
+            // Calculate the total outbound amount in rune
             const outboundAmountTotal = runeValue.plus(outboundValue);
-            // calculate the if outboundAmountTotal is over the volume threshold
+            // Calculate the volume threshold
             const volumeThreshold = outboundAmountTotal.div(minTxOutVolumeThreshold);
-            // check delay rate
+            // Adjust the delay rate based on the volume threshold
             txOutDelayRate = txOutDelayRate - volumeThreshold.assetAmount.amount().toNumber() <= 1 ? 1 : txOutDelayRate;
-            // calculate the minimum number of blocks in the future the txn has to be
+            // Calculate the minimum number of blocks required for the transaction to be confirmed
             let minBlocks = runeValue.assetAmount.amount().toNumber() / txOutDelayRate;
             minBlocks = minBlocks > maxTxOutOffset ? maxTxOutOffset : minBlocks;
+            // Return the required delay in seconds
             return minBlocks * thorChainblocktime;
         });
     }
     /**
      * Convenience method to convert TotalFees to a different CryptoAmount
-     *
      * TotalFees are always calculated and returned in RUNE, this method can
      * be used to show the equivalent fees in another Asset Type
-     *
      * @param fees: TotalFees - the fees you want to convert
      * @param asset: Asset - the asset you want the fees converted to
      * @returns TotalFees in asset
      */
     getFeesIn(fees, asset) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Return the fees converted to the specified asset
             return {
                 asset: fees.asset,
                 // swapFee: await this.convert(fees.swapFee, asset),
@@ -1231,73 +1251,78 @@ class ThorchainQuery {
     }
     /**
      * Returns the exchange of a CryptoAmount to a different Asset
-     *
      * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
-     *
      * @param input - amount/asset to convert to outAsset
      * @param ouAsset - the Asset you want to convert to
      * @returns CryptoAmount of input
      */
     convert(input, outAsset) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Convert the input amount to the specified asset
             return yield this.thorchainCache.convert(input, outAsset);
         });
     }
     /**
      * Finds the required confCount required for an inbound or outbound Tx to THORChain. Estimate based on Midgard data only.
-     *
      * Finds the gas asset of the given asset (e.g. BUSD is on BNB), finds the value of asset in Gas Asset then finds the required confirmation count.
      * ConfCount is then times by 6 seconds.
-     *
      * @param inbound: CryptoAmount - amount/asset of the outbound amount.
      * @returns time in seconds before a Tx is confirmed by THORChain
      * @see https://docs.thorchain.org/chain-clients/overview
      */
     confCounting(inbound) {
         return __awaiter(this, void 0, void 0, function* () {
-            // RUNE, BNB and Synths have near instant finality, so no conf counting required. - need to make a BFT only case.
+            // Check for instant finality assets or synths
             if (isAssetRuneNative(inbound.asset) ||
                 inbound.asset.chain == BNBChain ||
                 inbound.asset.chain == GAIAChain ||
                 inbound.asset.synth) {
+                // Return the average block time for THORChain
                 return this.chainAttributes[THORChain].avgBlockTimeInSecs;
             }
-            // Get the gas asset for the inbound.asset.chain
+            // Get the gas asset for the inbound asset's chain
             const chainGasAsset = getChainAsset(inbound.asset.chain);
-            // check for chain asset, else need to convert asset value to chain asset.
+            // Convert the inbound amount to the gas asset
             const amountInGasAsset = yield this.thorchainCache.convert(inbound, chainGasAsset);
-            // Convert to Asset Amount
+            // Get the number of confirmations required based on the asset's value in the gas asset
             const amountInGasAssetInAsset = amountInGasAsset.assetAmount;
             const confConfig = this.chainAttributes[inbound.asset.chain];
-            // find the required confs
             const requiredConfs = Math.ceil(amountInGasAssetInAsset.amount().div(confConfig.blockReward).toNumber());
-            // convert that into seconds
+            // Convert the number of confirmations to seconds
             return requiredConfs * confConfig.avgBlockTimeInSecs;
         });
     }
     /**
-     * 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
+     * Estimates a liquidity position for given crypto amount value, both asymmetrical and symmetrical
+     * @param params - parameters needed for an estimated liquidity position
+     * @returns - object of type EstimateLP
      */
     estimateAddLP(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
+            // Check if either of the assets are synths or if the rune is not THOR.RUNE
             if (params.asset.asset.synth || params.rune.asset.synth)
                 errors.push('you cannot add liquidity with a synth');
             if (!isAssetRuneNative(params.rune.asset))
                 errors.push('params.rune must be THOR.RUNE');
+            // Get the pool for the asset
             const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset.asset);
+            // Calculate liquidity units
             const lpUnits = getLiquidityUnits({ asset: params.asset, rune: params.rune }, assetPool);
+            // Get inbound details
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
+            // Create unit data
             const unitData = {
                 liquidityUnits: lpUnits,
                 totalUnits: new BigNumber(assetPool.thornodeDetails.LP_units),
             };
+            // Calculate pool share
             const poolShare = getPoolShare(unitData, assetPool);
+            // Calculate wait time
             const assetWaitTimeSeconds = yield this.confCounting(params.asset);
             const runeWaitTimeSeconds = yield this.confCounting(params.rune);
             const waitTimeSeconds = assetWaitTimeSeconds > runeWaitTimeSeconds ? assetWaitTimeSeconds : runeWaitTimeSeconds;
+            // Calculate inbound fees
             let assetInboundFee = new CryptoAmount(baseAmount(0), params.asset.asset);
             let runeInboundFee = new CryptoAmount(baseAmount(0), AssetRuneNative);
             if (!params.asset.assetAmount.eq(0)) {
@@ -1310,8 +1335,11 @@ class ThorchainQuery {
                 if (runeInboundFee.assetAmount.amount().times(3).gt(params.rune.assetAmount.amount()))
                     errors.push(`Rune amount is less than fees`);
             }
+            // Calculate total fees
             const totalFees = (yield this.convert(assetInboundFee, AssetRuneNative)).plus(runeInboundFee);
+            // Calculate slip
             const slip = getSlipOnLiquidity({ asset: params.asset, rune: params.rune }, assetPool);
+            // Create estimate LP object
             const estimateLP = {
                 assetPool: assetPool.thornodeDetails.asset,
                 slipPercent: slip.times(100),
@@ -1333,9 +1361,9 @@ class ThorchainQuery {
         });
     }
     /**
-     * @param - Asset for lp
-     * @param address - address used for Lp
-     * @returns - Type Object liquidityPosition
+     * @param - Asset for LP
+     * @param address - address used for LP
+     * @returns - Object of type LiquidityPosition
      */
     checkLiquidityPosition(asset, assetOrRuneAddress) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1344,6 +1372,7 @@ class ThorchainQuery {
                 throw Error(`Could not find pool for ${asset}`);
             if (!assetOrRuneAddress)
                 throw Error(`No address provided ${assetOrRuneAddress}`);
+            // Get the current block number for that chain
             const liquidityProvider = yield this.thorchainCache.thornode.getLiquidityProvider(poolAsset.assetString, assetOrRuneAddress);
             if (!liquidityProvider)
                 throw Error(`Could not find LP for ${assetOrRuneAddress}`);
@@ -1357,28 +1386,35 @@ class ThorchainQuery {
                 liquidityUnits: new BigNumber(liquidityProvider.units),
             };
             const networkValues = yield this.thorchainCache.thornode.getNetworkValues();
+            // Create block object
             const block = {
                 current: blockData.thorchain,
                 lastAdded: liquidityProvider.last_add_height,
                 fullProtection: networkValues['FULLIMPLOSSPROTECTIONBLOCKS'],
             };
             const assetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(asset);
+            // Get the current LP
             const currentLP = {
                 asset: baseAmount(liquidityProvider.asset_deposit_value, assetDecimals),
                 rune: baseAmount(liquidityProvider.rune_deposit_value),
             };
+            // Calculate pool share
             const poolShare = getPoolShare(unitData, poolAsset);
             // Liquidity Unit Value Index = sprt(assetdepth * runeDepth) / Poolunits
             // Using this formula we can work out an individual position to find LUVI and then the growth rate
+            // Calculate deposit and redeem Liquidity Unit Value Index (LUVI)
             const depositLuvi = Math.sqrt(currentLP.asset.times(currentLP.rune).div(unitData.liquidityUnits).amount().toNumber());
             const redeemLuvi = Math.sqrt(poolShare.assetShare.baseAmount
                 .times(poolShare.runeShare.baseAmount)
                 .div(unitData.liquidityUnits)
                 .amount()
                 .toNumber());
+            // Calculate LP growth
             const lpGrowth = redeemLuvi - depositLuvi;
             const currentLpGrowth = lpGrowth > 0 ? lpGrowth / depositLuvi : 0;
+            // Get impermanent loss protection data
             const impermanentLossProtection = getLiquidityProtectionData(currentLP, poolShare, block);
+            // Create Liquidity Position object
             const lpPosition = {
                 poolShare,
                 lpGrowth: `${(currentLpGrowth * 100).toFixed(2)} %`,
@@ -1395,7 +1431,9 @@ class ThorchainQuery {
      */
     getPoolRatios(asset) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Get pool data for the asset
             const assetPool = yield this.thorchainCache.getPoolForAsset(asset);
+            // Create pool ratios object
             const poolRatio = {
                 assetToRune: assetPool.assetToRuneRatio,
                 runeToAsset: assetPool.runeToAssetRatio,
@@ -1404,27 +1442,31 @@ class ThorchainQuery {
         });
     }
     /**
-     *
-     * @param params
+     * Estimates the result of withdrawing liquidity from a pool
+     * @param params - parameters needed for estimating withdrawal of liquidity
+     * @returns - object of type EstimateWithdrawLP
      */
     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.
             const assetOrRuneAddress = params.assetAddress ? params.assetAddress : params.runeAddress;
+            // Check liquidity position for the provided asset
             const memberDetail = yield this.checkLiquidityPosition(params.asset, assetOrRuneAddress);
+            // Get dust values
             const dustValues = yield this.getDustValues(params.asset); // returns asset and rune dust values
+            // Get asset pool
             const assetPool = yield this.thorchainCache.getPoolForAsset(params.asset);
-            // get pool share from unit data
+            // Calculate pool share
             const poolShare = getPoolShare({
                 liquidityUnits: new BigNumber(memberDetail.position.units),
                 totalUnits: new BigNumber(assetPool.thornodeDetails.LP_units),
             }, assetPool);
-            // get slip on liquidity removal
+            // Calculate slip on liquidity removal
             const slip = getSlipOnLiquidity({
                 asset: poolShare.assetShare,
                 rune: poolShare.runeShare,
             }, assetPool);
-            // TODO make sure we compare wait times for withdrawing both rune and asset OR just rune OR just asset
+            // Calculate wait time
             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;
@@ -1438,51 +1480,59 @@ class ThorchainQuery {
             else {
                 waitTimeSeconds = waitTimeSecondsForRune;
             }
+            // Get inbound and outbound fees
             const allInboundDetails = yield this.thorchainCache.getInboundDetails();
             const inboundDetails = allInboundDetails[params.asset.chain];
             const runeInbound = calcNetworkFee(AssetRuneNative, inboundDetails);
             const assetInbound = calcNetworkFee(params.asset, inboundDetails);
             const runeOutbound = calcOutboundFee(AssetRuneNative, inboundDetails);
             const assetOutbound = calcOutboundFee(params.asset, inboundDetails);
+            // Create an EstimateWithdrawLP object
             const estimateLP = {
                 assetAddress: memberDetail.position.asset_address,
                 runeAddress: memberDetail.position.rune_address,
                 slipPercent: slip.times(100),
                 inbound: {
                     minToSend: {
+                        // Minimum amount to send
                         rune: dustValues.rune,
                         asset: dustValues.asset,
-                        total: (yield this.convert(dustValues.asset, AssetRuneNative)).plus(dustValues.rune),
+                        total: (yield this.convert(dustValues.asset, AssetRuneNative)).plus(dustValues.rune), // Total amount
                     },
                     fees: {
+                        // Inbound fees
                         rune: runeInbound,
                         asset: assetInbound,
-                        total: (yield this.convert(assetInbound, AssetRuneNative)).plus(runeInbound),
+                        total: (yield this.convert(assetInbound, AssetRuneNative)).plus(runeInbound), // Total fees
                     },
                 },
                 outboundFee: {
+                    // Outbound fees
                     asset: assetOutbound,
                     rune: runeOutbound,
-                    total: (yield this.convert(assetOutbound, AssetRuneNative)).plus(runeOutbound),
+                    total: (yield this.convert(assetOutbound, AssetRuneNative)).plus(runeOutbound), // Total fees
                 },
                 assetAmount: poolShare.assetShare,
                 runeAmount: poolShare.runeShare,
                 lpGrowth: memberDetail.lpGrowth,
                 estimatedWaitSeconds: waitTimeSeconds,
                 impermanentLossProtection: memberDetail.impermanentLossProtection,
-                assetPool: assetPool.thornodeDetails.asset,
+                assetPool: assetPool.thornodeDetails.asset, // Asset pool
             };
-            return estimateLP;
+            return estimateLP; // Return the EstimateWithdrawLP object
         });
     }
     /**
-     * // 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
+     * Can this become a queried constant? added to inbound_addresses or something
+     * Retrieves dust values for the given asset
+     * @param asset - The asset for which to retrieve dust values
+     * @returns - Object containing dust values
      */
     getDustValues(asset) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Get the number of decimals for the asset
             const assetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(asset);
+            // Determine the dust values based on the asset's chain
             switch (asset.chain) {
                 case 'BNB':
                     return {
@@ -1492,80 +1542,88 @@ class ThorchainQuery {
                 case 'BTC':
                 case `BCH`:
                 case `LTC`:
-                    // 10k sats
+                    // Dust value: 10k sats
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0.0001, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'ETH':
-                    // 0 wei
+                    // Dust value: 0 wei
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'THOR':
-                    // 0 Rune
+                    // Dust value: 0 Rune
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'GAIA':
-                    // 0 GAIA
+                    // Dust value: 0 GAIA
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'DOGE':
-                    // 1 million sats
+                    // Dust value: 1 million sats
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0.01, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'AVAX':
-                    // 0 AVAX
+                    // Dust value: 0 AVAX
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'BSC':
-                    // 0 BSC
+                    // Dust value: 0 BSC
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 case 'MAYA':
-                    // 0 MAYA
+                    // Dust value: 0 MAYA
                     return {
                         asset: new CryptoAmount(assetToBase(assetAmount(0, assetDecimals)), asset),
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                 default:
-                    throw Error('Unknown chain');
+                    throw Error('Unknown chain'); // Throw error for unknown chain
             }
         });
     }
     // Savers Queries
     // Derrived from https://dev.thorchain.org/thorchain-dev/connection-guide/savers-guide
+    /**
+     * Estimates the result of adding to a saver
+     * @param addAmount - The amount to be added to the saver
+     * @returns - Object of type EstimateAddSaver
+     */
     estimateAddSaver(addAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            let errors = [];
-            // check for errors before sending quote
+            let errors = []; // Initialize errors array
+            // 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
+            // Request parameter amount should always be in 1e8
+            // Adjust 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 depositQuote = yield this.thorchainCache.thornode.getSaversDepositQuote(assetToString(addAmount.asset), // Convert asset to string
+            newAddAmount.toNumber());
+            // Error handling
             const response = JSON.parse(JSON.stringify(depositQuote));
             if (response.error)
-                errors.push(`Thornode request quote failed: ${response.error}`);
-            //The recommended minimum inbound amount for this transaction type & inbound asset.
+                errors.push(`Thornode request quote failed: ${response.error}`); // Push error to array if exists
+            // The recommended minimum inbound amount for this transaction type & inbound asset.
             // Sending less than this amount could result in failed refunds
             if (depositQuote.recommended_min_amount_in &&
                 addAmount.baseAmount.amount().toNumber() < Number(depositQuote.recommended_min_amount_in))
-                errors.push(`Error amount in: ${addAmount.baseAmount.amount().toNumber()} is less than reccommended Min Amount: ${depositQuote.recommended_min_amount_in}`);
+                errors.push(`Error amount in: ${addAmount.baseAmount.amount().toNumber()} is less than recommended Min Amount: ${depositQuote.recommended_min_amount_in}`);
             // Return errors if there is any
             if (errors.length > 0) {
+                // Return an object with default values and errors
                 return {
                     assetAmount: addAmount,
                     estimatedDepositValue: new CryptoAmount(baseAmount(0), addAmount.asset),
@@ -1584,26 +1642,44 @@ class ThorchainQuery {
                     slipBasisPoints: -1,
                     recommendedMinAmountIn: depositQuote.recommended_min_amount_in,
                     canAddSaver: false,
-                    errors,
+                    errors, // Errors
                 };
             }
+            // Get pool details
             const pool = (yield this.thorchainCache.getPoolForAsset(addAmount.asset)).thornodeDetails;
+            // Get asset decimals
             const assetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(addAmount.asset);
+            // Get fee asset decimals
             const feeAssetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(addAmount.asset);
-            // Organise fees
+            // Organize fees
             const saverFees = {
-                affiliate: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(depositQuote.fees.affiliate), addAmount.asset), assetDecimals),
+                affiliate: getCryptoAmountWithNotation(
+                // Affiliate fee
+                new CryptoAmount(baseAmount(depositQuote.fees.affiliate), addAmount.asset), // Convert to base amount
+                assetDecimals),
                 asset: assetFromStringEx(depositQuote.fees.asset),
-                outbound: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(depositQuote.fees.outbound), assetFromStringEx(depositQuote.fees.asset)), feeAssetDecimals),
-                liquidity: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(depositQuote.fees.liquidity), assetFromStringEx(depositQuote.fees.asset)), feeAssetDecimals),
-                totalBps: depositQuote.fees.total_bps || 0,
+                outbound: getCryptoAmountWithNotation(
+                // Outbound fee
+                new CryptoAmount(baseAmount(depositQuote.fees.outbound), assetFromStringEx(depositQuote.fees.asset)), // Convert to base amount
+                feeAssetDecimals),
+                liquidity: getCryptoAmountWithNotation(
+                // Liquidity fee
+                new CryptoAmount(baseAmount(depositQuote.fees.liquidity), assetFromStringEx(depositQuote.fees.asset)), // Convert to base amount
+                feeAssetDecimals),
+                totalBps: depositQuote.fees.total_bps || 0, // Total basis points
             };
-            // define savers filled capacity
+            // Define saver filled capacity
             const saverCapFilledPercent = (Number(pool.synth_supply) / Number(pool.balance_asset)) * 100;
-            // return object
+            // Return object
             const estimateAddSaver = {
-                assetAmount: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(depositQuote.expected_amount_out), addAmount.asset), assetDecimals),
-                estimatedDepositValue: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(depositQuote.expected_amount_deposit), addAmount.asset), assetDecimals),
+                assetAmount: getCryptoAmountWithNotation(
+                // Asset amount
+                new CryptoAmount(baseAmount(depositQuote.expected_amount_out), addAmount.asset), // Convert to base amount
+                assetDecimals),
+                estimatedDepositValue: getCryptoAmountWithNotation(
+                // Estimated deposit value
+                new CryptoAmount(baseAmount(depositQuote.expected_amount_deposit), addAmount.asset), // Convert to base amount
+                assetDecimals),
                 fee: saverFees,
                 expiry: new Date(depositQuote.expiry),
                 toAddress: depositQuote.inbound_address,
@@ -1613,25 +1689,27 @@ class ThorchainQuery {
                 slipBasisPoints: depositQuote.slippage_bps,
                 saverCapFilledPercent,
                 recommendedMinAmountIn: depositQuote.recommended_min_amount_in,
-                errors,
+                errors, // Errors
             };
-            return estimateAddSaver;
+            return estimateAddSaver; // Return the EstimateAddSaver object
         });
     }
     /**
-     *
-     * @param withdrawParams - height?, asset, address, withdrawalBasisPoints
-     * @returns - savers withdrawal quote with extras
+     * Estimates the result of withdrawing from a saver
+     * @param withdrawParams - Withdrawal parameters including height, asset, address, and withdrawal basis points
+     * @returns - Object of type EstimateWithdrawSaver
      */
     estimateWithdrawSaver(withdrawParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const errors = [];
-            // return error if Asset in is incorrect
+            const errors = []; // Initialize errors array
+            // Return error if asset in is incorrect
             if (isAssetRuneNative(withdrawParams.asset) || withdrawParams.asset.synth)
                 errors.push(`Native Rune and synth assets are not supported only L1's`);
+            // Get inbound details
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
-            // Check to see if there is a position before calling withdraw quote
+            // Check if there is a position before calling withdraw quote
             const checkPositon = yield this.getSaverPosition(withdrawParams);
+            // If there are errors in the position, return those errors
             if (checkPositon.errors.length > 0) {
                 for (let i = 0; i < checkPositon.errors.length; i++) {
                     errors.push(checkPositon.errors[i]);
@@ -1639,13 +1717,16 @@ class ThorchainQuery {
                 return {
                     dustAmount: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
                     dustThreshold: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
-                    expectedAssetAmount: new CryptoAmount(assetToBase(assetAmount(checkPositon.redeemableValue.assetAmount.amount())), withdrawParams.asset),
+                    expectedAssetAmount: new CryptoAmount(// Expected asset amount
+                    assetToBase(assetAmount(checkPositon.redeemableValue.assetAmount.amount())), // Convert to base amount
+                    withdrawParams.asset),
                     fee: {
                         affiliate: new CryptoAmount(assetToBase(assetAmount(0)), withdrawParams.asset),
                         asset: withdrawParams.asset,
                         liquidity: new CryptoAmount(baseAmount(0), withdrawParams.asset),
-                        outbound: new CryptoAmount(assetToBase(assetAmount(calcOutboundFee(withdrawParams.asset, inboundDetails[withdrawParams.asset.chain]).assetAmount.amount())), withdrawParams.asset),
-                        totalBps: 0,
+                        outbound: new CryptoAmount(// Outbound fee
+                        assetToBase(assetAmount(calcOutboundFee(withdrawParams.asset, inboundDetails[withdrawParams.asset.chain]).assetAmount.amount())), withdrawParams.asset),
+                        totalBps: 0, // Total basis points
                     },
                     expiry: new Date(0),
                     toAddress: '',
@@ -1655,7 +1736,7 @@ class ThorchainQuery {
                     outBoundDelayBlocks: 0,
                     outBoundDelaySeconds: 0,
                     slipBasisPoints: -1,
-                    errors,
+                    errors, // Errors array
                 };
             }
             // Request withdraw quote
@@ -1665,6 +1746,7 @@ class ThorchainQuery {
             if (response.error)
                 errors.push(`Thornode request quote failed: ${response.error}`);
             if (errors.length > 0) {
+                // Return default values and errors if there are any errors
                 return {
                     dustAmount: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
                     dustThreshold: new CryptoAmount(baseAmount(0), getChainAsset(withdrawParams.asset.chain)),
@@ -1687,14 +1769,21 @@ class ThorchainQuery {
                     errors,
                 };
             }
+            // Extract the withdraw asset and chain asset from the withdraw quote
             const withdrawAsset = assetFromStringEx(withdrawQuote.fees.asset);
             const chainAsset = getChainAsset(withdrawParams.asset.chain);
+            // Get the decimals for the withdraw asset and chain asset
             const withdrawAssetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(withdrawAsset);
             const chainAssetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(chainAsset);
+            // Create an EstimateWithdrawSaver object with the necessary data
             const estimateWithdrawSaver = {
+                // Format the dust amount with appropriate notation and decimals
                 dustAmount: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.dust_amount), chainAsset), chainAssetDecimals),
+                // Format the dust threshold with appropriate notation and decimals
                 dustThreshold: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.dust_threshold), chainAsset), chainAssetDecimals),
+                // Format the expected asset amount with appropriate notation and decimals
                 expectedAssetAmount: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.expected_amount_out), withdrawParams.asset), withdrawAssetDecimals),
+                // Format the withdrawal fees with appropriate notation and decimals
                 fee: {
                     affiliate: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.fees.affiliate), withdrawAsset), withdrawAssetDecimals),
                     asset: withdrawAsset,
@@ -1702,53 +1791,77 @@ class ThorchainQuery {
                     outbound: getCryptoAmountWithNotation(new CryptoAmount(baseAmount(withdrawQuote.fees.outbound), withdrawAsset), withdrawAssetDecimals),
                     totalBps: withdrawQuote.fees.total_bps || 0,
                 },
+                // Set the expiry date
                 expiry: new Date(withdrawQuote.expiry),
+                // Set the recipient address
                 toAddress: withdrawQuote.inbound_address,
+                // Set the memo
                 memo: withdrawQuote.memo,
+                // Set the inbound delay blocks
                 inboundDelayBlocks: withdrawQuote.inbound_confirmation_blocks || 0,
+                // Set the inbound delay seconds
                 inboundDelaySeconds: withdrawQuote.inbound_confirmation_seconds || 0,
+                // Set the outbound delay blocks
                 outBoundDelayBlocks: withdrawQuote.outbound_delay_blocks || 0,
+                // Set the outbound delay seconds
                 outBoundDelaySeconds: withdrawQuote.outbound_delay_seconds || 0,
+                // Set the slip basis points
                 slipBasisPoints: withdrawQuote.slippage_bps,
+                // Set the errors
                 errors,
             };
+            // Return the withdrawal estimation object
             return estimateWithdrawSaver;
         });
     }
     /**
-     *
-     * @param params - getSaver object > asset, addresss, height?
-     * @returns - Savers position object
+     * Retrieve the position of a saver given the asset, address, and height.
+     * @param params - Object containing the asset, address, and height.
+     * @returns - Object representing the saver's position.
      */
     getSaverPosition(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Initialize errors array
             const errors = [];
+            // Retrieve inbound details
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
+            // Get the decimals for the asset
             const assetDecimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(params.asset);
+            // Retrieve block data for the specified asset chain
             const blockData = (yield this.thorchainCache.thornode.getLastBlock()).find((item) => item.chain === params.asset.chain);
-            // address comparison is done after conversion to lower case
+            // Retrieve the saver from the Thorchain node API
             const savers = (yield this.thorchainCache.thornode.getSavers(`${params.asset.chain}.${params.asset.symbol}`)).find((item) => item.asset_address.toLowerCase() === params.address.toLowerCase());
+            // Retrieve pool details for the specified asset
             const pool = (yield this.thorchainCache.getPoolForAsset(params.asset)).thornodeDetails;
+            // Push errors if necessary data is not found
             if (!savers)
                 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))
                 errors.push(`Could not get thorchain block height`);
+            // Calculate the outbound fee
             const outboundFee = calcOutboundFee(params.asset, inboundDetails[params.asset.chain]);
             const convertToBaseEight = getBaseAmountWithDiffDecimals(outboundFee, 8);
-            // For comparison use 1e8 since asset_redeem_value is returned in 1e8
+            // Push an error if the redeemable value is less than the outbound fee
             if (Number(savers === null || savers === void 0 ? void 0 : savers.asset_redeem_value) < convertToBaseEight.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.savers_units);
-            const assetDepth = Number(pool.savers_depth);
+            // Calculate the redeemable value
+            // Extract necessary data for calculation
+            const ownerUnits = Number(savers === null || savers === void 0 ? void 0 : savers.units); // Number of units owned by the saver
+            const lastAdded = Number(savers === null || savers === void 0 ? void 0 : savers.last_add_height); // Height at which the last addition was made to the pool
+            const saverUnits = Number(pool.savers_units); // Total units in the pool
+            const assetDepth = Number(pool.savers_depth); // Total asset depth in the pool
+            // Calculate the redeemable value of the saver's position based on their ownership in the pool
             const redeemableValue = (ownerUnits / saverUnits) * assetDepth;
+            // Format the deposit amount and redeemable asset amount with appropriate notation and decimals
             const depositAmount = getCryptoAmountWithNotation(new CryptoAmount(baseAmount(savers === null || savers === void 0 ? void 0 : savers.asset_deposit_value), params.asset), assetDecimals);
             const redeemableAssetAmount = getCryptoAmountWithNotation(new CryptoAmount(baseAmount(redeemableValue), params.asset), assetDecimals);
+            // Calculate the age of the saver's position in years and days
             const saversAge = (Number(blockData === null || blockData === void 0 ? void 0 : blockData.thorchain) - lastAdded) / ((365 * 86400) / 6);
+            // Calculate the growth percentage of the saver's position
             const saverGrowth = redeemableAssetAmount.minus(depositAmount).div(depositAmount).times(100);
+            // Create and populate a SaversPosition object with the calculated values
             const saversPos = {
                 depositValue: depositAmount,
                 redeemableValue: redeemableAssetAmount,
@@ -1757,29 +1870,47 @@ class ThorchainQuery {
                 ageInYears: saversAge,
                 ageInDays: saversAge * 365,
                 asset: params.asset,
-                errors,
+                errors, // Array of any errors encountered during the calculation
             };
+            // Return the SaversPosition object representing the saver's position
             return saversPos;
         });
     }
+    /**
+     * Get errors related to estimating the addition of funds to a saver's pool.
+     * @param addAmount - Amount of funds to be added to the saver's pool.
+     * @returns An array of strings representing any errors encountered during the estimation process.
+     */
     getAddSaversEstimateErrors(addAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
+            // Retrieve all pools
             const pools = yield this.thorchainCache.getPools();
+            // Filter out saver's pools with non-zero depth
             const saversPools = Object.values(pools).filter((i) => i.thornodeDetails.savers_depth !== '0');
+            // Retrieve inbound details
             const inboundDetails = yield this.thorchainCache.getInboundDetails();
+            // Find the saver's pool corresponding to the provided asset
             const saverPool = saversPools.find((i) => assetToString(i.asset) === assetToString(addAmount.asset));
+            // Check if a saver's pool exists for the provided asset
             if (!saverPool)
                 errors.push(` ${assetToString(addAmount.asset)} does not have a saver's pool`);
+            // Check if the chain for the provided asset is halted
             if (inboundDetails[addAmount.asset.chain].haltedChain)
                 errors.push(`${addAmount.asset.chain} is halted, cannot add`);
+            // Get details of the pool for the provided asset
             const pool = (yield this.thorchainCache.getPoolForAsset(addAmount.asset)).thornodeDetails;
+            // Check if the pool for the provided asset is available
             if (pool.status.toLowerCase() !== 'available')
                 errors.push(`Pool is not available for this asset ${assetToString(addAmount.asset)}`);
-            const inboundFee = new CryptoAmount(baseAmount(inboundDetails[addAmount.asset.chain].gasRate), addAmount.asset); // only needs to check against inbound fee, not network fee.
-            const inboundFeeInAddAmountAsset = yield this.convert(inboundFee, addAmount.asset); // to make sure maths is being done on same assets
+            // Calculate inbound fee for the provided asset
+            const inboundFee = new CryptoAmount(baseAmount(inboundDetails[addAmount.asset.chain].gasRate), addAmount.asset);
+            // Convert inbound fee to the same asset as the addAmount to ensure consistency in calculations
+            const inboundFeeInAddAmountAsset = yield this.convert(inboundFee, addAmount.asset);
+            // Check if the addAmount covers the inbound fees
             if (addAmount.lte(inboundFeeInAddAmountAsset))
                 errors.push(`Add amount does not cover fees`);
+            // Return array of errors encountered during estimation
             return errors;
         });
     }
@@ -1856,17 +1987,21 @@ class ThorchainQuery {
         });
     }
     /**
-     *
-     * @param loanOpenParams - params needed for the end Point
-     * @returns
+     * Get a quote for opening a loan.
+     * @param loanOpenParams - Parameters needed for the endpoint.
+     * @returns A Promise resolving to a LoanOpenQuote.
      */
     getLoanQuoteClose({ asset, amount, loanAsset, loanOwner, minOut, height, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
+            // Retrieve loan open response from ThorNode API
             const loanCloseResp = yield this.thorchainCache.thornode.getLoanQuoteClose(`${asset.chain}.${asset.symbol}`, amount.baseAmount.amount().toNumber(), `${loanAsset.chain}.${loanAsset.symbol}`, loanOwner, minOut, height);
+            // Parse loan open response
             const response = JSON.parse(JSON.stringify(loanCloseResp));
+            // Check for errors in response
             if (response.error)
                 errors.push(`Thornode request quote failed: ${response.error}`);
+            // If errors exist, return an object with error details
             if (errors.length > 0) {
                 return {
                     inboundAddress: '',
@@ -1894,6 +2029,7 @@ class ThorchainQuery {
                     errors: errors,
                 };
             }
+            // Construct loan open quote object
             const loanCloseQuote = {
                 inboundAddress: loanCloseResp.inbound_address,
                 expectedWaitTime: {
@@ -1923,19 +2059,23 @@ class ThorchainQuery {
         });
     }
     /**
-     *
-     * @param thorname - input param
-     * @returns retrieves details for a thorname
+     * Retrieve details for a THORName.
+     * @param thorname - The THORName to get details for.
+     * @param height - Optional parameter specifying the block height.
+     * @returns A Promise resolving to ThornameDetails.
      */
     getThornameDetails(thorname, height) {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
             try {
+                // Retrieve THORName details from ThorNode API
                 const thornameResp = yield this.thorchainCache.thornode.getThornameDetails(thorname, height);
                 const response = JSON.parse(JSON.stringify(thornameResp));
+                // Check for errors in response
                 if (response.error)
                     errors.push(`Thornode request quote failed: ${response.error}`);
                 if (errors.length > 0) {
+                    // If errors exist, return an object with error details
                     const errorResp = {
                         name: '',
                         expireBlockHeight: 0,
@@ -1947,10 +2087,12 @@ class ThorchainQuery {
                     };
                     return errorResp;
                 }
+                // Map aliases to ThornameAlias objects
                 const thornameAliases = thornameResp.aliases.map((alias) => ({
                     chain: alias.chain,
                     address: alias.address,
                 }));
+                // Construct ThornameDetails object
                 const thornameDetails = {
                     name: thornameResp.name || '',
                     expireBlockHeight: thornameResp.expire_block_height || 0,
@@ -1962,6 +2104,7 @@ class ThorchainQuery {
                 return thornameDetails;
             }
             catch (e) {
+                // If an error occurs during the process, return an object with error details
                 const errorResp = {
                     name: '',
                     expireBlockHeight: 0,
@@ -1976,31 +2119,32 @@ class ThorchainQuery {
         });
     }
     /**
-     * Generate the memo and estimate the cost of register or update a THORName
-     * @param thorname - Name to register
-     * @param chain - Chain to update / register
-     * @param chainAddress - Address to add to chain alias
-     * @param owner - Owner address (rune address)
-     * @param preferredAsset - referred asset
-     * @param expirity - expirity of the domain in MILLISECONDS
-     * @param isUpdate - true only if the domain is already register and you want to update its data
-     * @returns memo and value of deposit
+     * Generate the memo and estimate the cost of registering or updating a THORName.
+     * @param thorname - The name to register or update.
+     * @param chain - The chain to update/register.
+     * @param chainAddress - The address to add to chain alias.
+     * @param owner - The owner address (rune address).
+     * @param preferredAsset - The preferred asset.
+     * @param expirity - The expiry of the domain in MILLISECONDS.
+     * @param isUpdate - True only if the domain is already registered and you want to update its data.
+     * @returns Memo and value of deposit.
      */
     estimateThorname(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // CHECK IF ALREADY EXISTS
+            // Check if THORName already exists
             const thornameDetails = yield this.getThornameDetails(params.thorname);
             if (thornameDetails.owner !== '' && !params.isUpdate) {
                 throw Error('Thorname already registered');
             }
+            // Retrieve block data
             const blockData = yield this.thorchainCache.thornode.getLastBlock();
             const currentThorchainHeight = blockData[0].thorchain;
             const currentHeightForExpirity = params.isUpdate
                 ? thornameDetails === null || thornameDetails === void 0 ? void 0 : thornameDetails.expireBlockHeight
                 : currentThorchainHeight;
-            // DEFAULT EXPIRITY
+            // Default expiry
             let numberOfBlocksToAddToExpirity = params.isUpdate ? 0 : 5259600; // One year by default
-            // COMPUTE EXPIRITY HEIGHT
+            // Compute expiry height
             if (params.expirity) {
                 const currentTimestamp = Math.floor(Date.now() / 1000);
                 const expirityTimestamp = Math.floor(params.expirity.getTime() / 1000);
@@ -2011,7 +2155,7 @@ class ThorchainQuery {
                     ? newHeightExpirity - (thornameDetails === null || thornameDetails === void 0 ? void 0 : thornameDetails.expireBlockHeight)
                     : numberOfBlocks;
             }
-            // COMPUTE VALUE
+            // Compute value
             const constantsDetails = yield this.thorchainCache.thornode.getTcConstants();
             const oneTimeFee = params.isUpdate ? baseAmount(0) : baseAmount(constantsDetails['TNSRegisterFee']);
             const totalFeePerBlock = baseAmount(constantsDetails['TNSFeePerBlock']).times(numberOfBlocksToAddToExpirity > 0 ? numberOfBlocksToAddToExpirity : 0);
@@ -2023,8 +2167,32 @@ class ThorchainQuery {
             };
         });
     }
+    /**
+     * Get inbound addresses details
+     * @returns Inbound details
+     */
+    getInboundDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.thorchainCache.getInboundDetails();
+        });
+    }
+    /**
+     * Get chain inbound address details
+     * @returns Inbound details
+     */
+    getChainInboundDetails(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundDetails = yield this.getInboundDetails();
+            if (!inboundDetails[chain])
+                throw Error(`No inbound details known for ${chain} chain`);
+            return inboundDetails[chain];
+        });
+    }
 }
 
+/**
+ * Enum representing different types of transactions.
+ */
 var TxType;
 (function (TxType) {
     TxType["Swap"] = "Swap";
@@ -2036,12 +2204,18 @@ var TxType;
     TxType["Other"] = "Other";
     TxType["Unknown"] = "Unknown";
 })(TxType || (TxType = {}));
+/**
+ * Enum representing inbound transaction status.
+ */
 var InboundStatus;
 (function (InboundStatus) {
     InboundStatus["Observed_Consensus"] = "Observed_Consensus";
     InboundStatus["Observed_Incomplete"] = "Observed_Incomplete";
     InboundStatus["Unknown"] = "Unknown";
 })(InboundStatus || (InboundStatus = {}));
+/**
+ * Enum representing swap transaction status.
+ */
 var SwapStatus;
 (function (SwapStatus) {
     SwapStatus["Complete"] = "Complete";
@@ -2049,6 +2223,9 @@ var SwapStatus;
     SwapStatus["Complete_Below_Dust"] = "Complete_Below_Dust";
     SwapStatus["Incomplete"] = "Incomplete";
 })(SwapStatus || (SwapStatus = {}));
+/**
+ * Enum representing add liquidity pool transaction status.
+ */
 var AddLpStatus;
 (function (AddLpStatus) {
     AddLpStatus["Complete"] = "Complete";
@@ -2056,18 +2233,27 @@ var AddLpStatus;
     AddLpStatus["Complete_Below_Dust"] = "Complete_Below_Dust";
     AddLpStatus["Incomplete"] = "Incomplete";
 })(AddLpStatus || (AddLpStatus = {}));
+/**
+ * Enum representing withdraw transaction status.
+ */
 var WithdrawStatus;
 (function (WithdrawStatus) {
     WithdrawStatus["Complete"] = "Complete";
     WithdrawStatus["Incomplete"] = "Incomplete";
     WithdrawStatus["Complete_Refunded"] = "Complete_Refunded";
 })(WithdrawStatus || (WithdrawStatus = {}));
+/**
+ * Enum representing refund transaction status.
+ */
 var RefundStatus;
 (function (RefundStatus) {
     RefundStatus["Complete"] = "Complete";
     RefundStatus["Incomplete"] = "Incomplete";
     RefundStatus["Complete_Refunded"] = "Complete_Refunded";
 })(RefundStatus || (RefundStatus = {}));
+/**
+ * Enum representing add saver transaction status.
+ */
 var AddSaverStatus;
 (function (AddSaverStatus) {
     AddSaverStatus["Complete"] = "Complete";
@@ -2075,11 +2261,24 @@ var AddSaverStatus;
     AddSaverStatus["Complete_Below_Dust"] = "Complete_Below_Dust";
     AddSaverStatus["Incomplete"] = "Incomplete";
 })(AddSaverStatus || (AddSaverStatus = {}));
+/**
+ * Class for managing transaction stages.
+ */
 class TransactionStage {
+    /**
+     * Constructor to create a TransactionStage instance.
+     * @param thorchainCache - ThorchainCache instance.
+     * @param chainAttributes - ChainAttributes object representing default chain attributes.
+     */
     constructor(thorchainCache, chainAttributes = DefaultChainAttributes) {
         this.thorchainCache = thorchainCache;
         this.chainAttributes = chainAttributes;
     }
+    /**
+     * Checks transaction progress.
+     * @param inboundTxHash - Inbound transaction hash.
+     * @returns Promise<TXProgress> - Transaction progress object.
+     */
     checkTxProgress(inboundTxHash) {
         return __awaiter(this, void 0, void 0, function* () {
             let txData;
@@ -2121,29 +2320,37 @@ class TransactionStage {
             return progress;
         });
     }
+    /**
+     * Checks the progress of a swap transaction.
+     * @param txData - Transaction details response.
+     * @param progress - Transaction progress object.
+     */
     checkSwapProgress(txData, progress) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
+                // Extract memo fields
                 const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
                 const memoFields = this.parseSwapMemo(memo);
                 const assetOut = assetFromStringEx(memoFields.asset.toUpperCase());
-                //const assetIn = assetFromStringEx(txData.tx.tx.coins?.[0].asset)
+                // Determine swap status
                 const swapStatus = ((_b = txData.out_txs[0].memo) === null || _b === void 0 ? void 0 : _b.match('OUT')) ? SwapStatus.Complete : SwapStatus.Complete_Refunded;
-                // current height of thorchain, neeed for confirmations
+                // Get current chain height for confirmations
                 const chainHeight = yield this.blockHeight(AssetRuneNative);
-                // expected outbound height
+                // Expected outbound height and date
                 const outboundHeight = Number((_c = txData.outbound_height) !== null && _c !== void 0 ? _c : txData.finalised_height);
                 const expectedOutBlock = Number((_d = txData.outbound_height) !== null && _d !== void 0 ? _d : txData.finalised_height);
                 const expectedOutDate = yield this.blockToDate(THORChain, txData, outboundHeight); // height held in the scheduled queue
+                // Calculate confirmations
                 const confirmations = chainHeight > outboundHeight ? chainHeight - outboundHeight : 0;
+                // Calculate minimum amount out and affiliate fee
                 const minimumAmountOut = memoFields.limit
                     ? yield this.getCryptoAmount(memoFields.limit, assetOut)
                     : yield this.getCryptoAmount('0', assetOut);
                 const affliateFee = memoFields.affiliateFee
                     ? yield this.getCryptoAmount(memoFields.affiliateFee, assetOut)
                     : yield this.getCryptoAmount('0', assetOut);
-                // TODO get out tx
+                // Construct swap info object
                 const swapInfo = {
                     status: swapStatus,
                     expectedOutBlock,
@@ -2154,10 +2361,16 @@ class TransactionStage {
                     affliateFee,
                     toAddress: memoFields.destAddress,
                 };
+                // Assign swap info to progress object
                 progress.swapInfo = swapInfo;
             }
         });
     }
+    /**
+     * Parses swap memo to extract relevant fields.
+     * @param memo - Transaction memo.
+     * @returns Parsed swap memo fields.
+     */
     parseSwapMemo(memo) {
         //SWAP:ASSET:DESTADDR:LIM:AFFILIATE:FEE
         const parts = memo.split(`:`);
@@ -2169,12 +2382,23 @@ class TransactionStage {
         const affiliateFee = parts.length > 5 && parts[5].length > 0 ? parts[5] : undefined;
         return { action, asset, destAddress, limit, affiliateAddress, affiliateFee };
     }
+    /**
+     * Retrieves a CryptoAmount object.
+     * @param baseAmt - Base amount.
+     * @param asset - Asset object.
+     * @returns Promise<CryptoAmount> - CryptoAmount object.
+     */
     getCryptoAmount(baseAmt, asset) {
         return __awaiter(this, void 0, void 0, function* () {
             const decimals = THORChain === asset.chain ? 8 : Number(yield this.thorchainCache.midgardQuery.getDecimalForAsset(asset));
             return new CryptoAmount(baseAmount(baseAmt, decimals), asset);
         });
     }
+    /**
+     * Determines the observed status of a transaction.
+     * @param txData - Transaction signers response.
+     * @returns Promise<TXProgress> - Transaction progress object.
+     */
     determineObserved(txData) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
@@ -2225,14 +2449,21 @@ class TransactionStage {
             return progress;
         });
     }
+    /**
+     * Checks the progress of an add liquidity pool transaction.
+     * @param txData - Transaction details response.
+     * @param progress - Transaction progress object.
+     */
     checkAddLpProgress(txData, progress) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
+                // Extract memo fields
                 const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
                 const memoFields = this.parseAddLpMemo(memo);
                 const asset = assetFromStringEx(memoFields.asset);
                 const isSymmetric = memoFields.pairedAddress ? true : false;
+                // Determine if assetTx or runeTx
                 const assetTx = !isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
                 const runeTx = isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
                 const pairedAssetExpectedConfirmationDate = assetTx ? yield this.blockToDate(asset.chain, txData) : undefined;
@@ -2250,27 +2481,38 @@ class TransactionStage {
             }
         });
     }
+    /**
+     * Checks the progress of a withdraw liquidity pool transaction.
+     * @param txData - Transaction details response.
+     * @param progress - Transaction progress object.
+     */
     checkWithdrawLpProgress(txData, progress) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
+                // Extract memo fields
                 const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
                 const memoFields = this.parseWithdrawLpMemo(memo);
                 const asset = assetFromStringEx(memoFields.asset);
+                // Get the last block object
                 const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
                 const currentHeight = lastBlockObj.find((obj) => obj);
-                // find the date in which the asset should be seen in the wallet
+                // Calculate expected confirmation date
                 const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
                 const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
-                // if the TC has process the block that the outbound tx was assigned to then its completed.
+                // Determine transaction status
                 const status = txData.tx.status === 'done' ? WithdrawStatus.Complete : WithdrawStatus.Incomplete;
+                // Extract output amount
                 const outAmount = status === WithdrawStatus.Complete ? JSON.stringify(txData.out_txs).split(`"amount":"`)[1].split(`"`) : '';
+                // Extract relevant block heights and calculate estimated wait time
                 const outboundBlock = Number((_b = txData.outbound_height) !== null && _b !== void 0 ? _b : txData.finalised_height);
                 const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
                 const estimatedWaitTime = outboundBlock > currentTCHeight
                     ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs
                     : 0;
+                // Get withdrawal amount
                 const withdrawalAmount = yield this.getCryptoAmount(outAmount[0], asset);
+                // Construct withdraw liquidity pool info object
                 const withdrawLpInfo = {
                     status,
                     withdrawalAmount,
@@ -2279,38 +2521,58 @@ class TransactionStage {
                     outboundHeight: outboundBlock,
                     estimatedWaitTime,
                 };
+                // Assign withdraw liquidity pool info to progress object
                 progress.withdrawLpInfo = withdrawLpInfo;
             }
         });
     }
+    /**
+     * Checks the progress of an add saver transaction.
+     * @param txData - Transaction details response.
+     * @param progress - Transaction progress object.
+     */
     checkAddSaverProgress(txData, progress) {
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
+                // Determine if it's an asset transaction
                 const assetTx = !isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                // Check saver vaults
                 const checkSaverVaults = yield this.thorchainCache.thornode.getSaver(txData.tx.tx.coins[0].asset, `${assetTx === null || assetTx === void 0 ? void 0 : assetTx.fromAddress}`);
+                // Determine transaction status
                 const status = checkSaverVaults ? AddSaverStatus.Complete : AddSaverStatus.Incomplete;
+                // Construct add saver info object
                 const addSaverInfo = {
                     status: status,
                     assetTx,
                     saverPos: checkSaverVaults,
                 };
+                // Assign add saver info to progress object
                 progress.addSaverInfo = addSaverInfo;
             }
         });
     }
+    /**
+     * Checks the progress of a withdraw saver transaction.
+     * @param txData - Transaction details response.
+     * @param progress - Transaction progress object.
+     */
     checkWithdrawSaverProgress(txData, progress) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
+                // Extract memo fields
                 const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
                 const memoFields = this.parseWithdrawLpMemo(memo);
                 const asset = assetFromStringEx(memoFields.asset);
+                // Get the last block object
                 const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
                 const currentHeight = lastBlockObj.find((obj) => obj);
-                // find the date in which the asset should be seen in the wallet
+                // Calculate expected confirmation date
                 const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
                 const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
+                // Extract output amount
                 const outAmount = txData.out_txs ? JSON.stringify(txData.out_txs).split(`"amount":"`)[1].split(`"`) : '';
+                // Extract relevant block heights and calculate estimated wait time
                 const outboundBlock = Number(txData.outbound_height);
                 const finalisedHeight = Number(txData.finalised_height);
                 const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
@@ -2318,9 +2580,11 @@ class TransactionStage {
                     ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs +
                         this.chainAttributes[asset.chain].avgBlockTimeInSecs
                     : 0;
-                // if the TC has process the block that the outbound tx was assigned to then its completed.
+                // Determine transaction status
                 const status = txData.out_txs ? WithdrawStatus.Complete : WithdrawStatus.Incomplete;
+                // Get withdrawal amount
                 const withdrawalAmount = yield this.getCryptoAmount(outAmount[0], asset);
+                // Construct withdraw saver info object
                 const withdrawSaverInfo = {
                     status,
                     withdrawalAmount,
@@ -2330,22 +2594,31 @@ class TransactionStage {
                     outboundBlock,
                     estimatedWaitTime,
                 };
+                // Assign withdraw saver info to progress object
                 progress.withdrawSaverInfo = withdrawSaverInfo;
             }
         });
     }
+    /**
+     * Checks the progress of a refund transaction.
+     * @param txData - Transaction details response.
+     * @param progress - Transaction progress object.
+     */
     checkRefund(txData, progress) {
         return __awaiter(this, void 0, void 0, function* () {
             if (progress.inboundObserved) {
+                // Get the last block object
                 const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
-                // find the date in which the asset should be seen in the wallet
+                // Calculate expected confirmation date
                 const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
                 const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
+                // Extract amount and asset
                 const amount = txData.tx.tx.coins[0].amount;
                 const asset = assetFromStringEx(txData.tx.tx.coins[0].asset);
                 const toAddress = `${txData.tx.tx.to_address}`;
                 const currentHeight = lastBlockObj.find((obj) => obj.chain === asset.chain);
                 console.log(currentHeight);
+                // Extract relevant block heights and calculate estimated wait time
                 const outboundBlock = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.last_observed_in}`);
                 const finalisedHeight = Number(txData.finalised_height);
                 const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
@@ -2370,33 +2643,43 @@ class TransactionStage {
             }
         });
     }
+    /**
+     * Parses the memo of an add liquidity pool transaction.
+     * @param memo - Memo string of the transaction.
+     * @returns Parsed memo fields.
+     */
     parseAddLpMemo(memo) {
-        //ADD:POOL:PAIREDADDR:AFFILIATE:FEE
+        // Memo format: ADD:POOL:PAIREDADDR:AFFILIATE:FEE
         const parts = memo.split(`:`);
         const action = parts[0];
         const asset = parts[1];
-        //optional fields
+        // Optional fields
         const pairedAddress = parts.length > 2 && parts[2].length > 0 ? parts[2] : undefined;
         const affiliateAddress = parts.length > 3 && parts[3].length > 0 ? parts[3] : undefined;
         const affiliateFee = parts.length > 4 && parts[4].length > 0 ? parts[4] : undefined;
         return { action, asset, pairedAddress, affiliateAddress, affiliateFee };
     }
+    /**
+     * Parses the memo of a withdraw liquidity pool transaction.
+     * @param memo - Memo string of the transaction.
+     * @returns Parsed memo fields.
+     */
     parseWithdrawLpMemo(memo) {
-        //ADD:POOL:PAIREDADDR:AFFILIATE:FEE
+        // Memo format: ADD:POOL:PAIREDADDR:AFFILIATE:FEE
         const parts = memo.split(`:`);
         const action = parts[0];
         const asset = parts[1];
-        //optional fields
+        // Optional fields
         const pairedAddress = parts.length > 2 && parts[2].length > 0 ? parts[2] : undefined;
         const affiliateAddress = parts.length > 3 && parts[3].length > 0 ? parts[3] : undefined;
         const affiliateFee = parts.length > 4 && parts[4].length > 0 ? parts[4] : undefined;
         return { action, asset, pairedAddress, affiliateAddress, affiliateFee };
     }
     /**
-     * Private function to return the date stamp from block height and chain
-     * @param chain - input chain
-     * @param txData - txResponse
-     * @returns date()
+     * Converts block height to date.
+     * @param chain - Input chain.
+     * @param txData - Transaction response data.
+     * @returns Date object.
      */
     blockToDate(chain, txData, outboundBlock) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2421,7 +2704,7 @@ class TransactionStage {
                     return time;
                 }
             }
-            // find out how long ago it was processed for all chains
+            // Find out how long ago it was processed for all chains
             if (chain == THORChain) {
                 const currentHeight = lastBlockObj.find((obj) => obj);
                 const thorchainHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`); // current height of the TC
@@ -2438,9 +2721,9 @@ class TransactionStage {
         });
     }
     /**
-     * Returns current block height of an asset's native chain
-     * @param chain
-     * @returns
+     * Returns the current block height of an asset's native chain.
+     * @param asset - Asset for which block height is needed.
+     * @returns Block height.
      */
     blockHeight(asset) {
         return __awaiter(this, void 0, void 0, function* () {