[SERVICES-2592] Portfolio queries cache improvements

src/modules/farm/base-module/services/farm.abi.service.ts

@@ -15,6 +15,7 @@ import { Constants } from '@multiversx/sdk-nestjs-common';
 import { MXApiService } from 'src/services/multiversx-communication/mx.api.service';
 import { IFarmAbiService } from './interfaces';
 import { CacheService } from '@multiversx/sdk-nestjs-cache';
+import { getAllKeys } from 'src/utils/get.many.utils';
 
 export class FarmAbiService
     extends GenericAbiService
@@ -69,6 +70,16 @@ export class FarmAbiService
         return response.firstValue.valueOf().toString();
     }
 
+    async getAllFarmTokenIds(farmAddresses: string[]): Promise<string[]> {
+        return await getAllKeys<string>(
+            this.cacheService,
+            farmAddresses,
+            'farm.farmTokenID',
+            this.farmTokenID.bind(this),
+            CacheTtlInfo.Token,
+        );
+    }
+
     @ErrorLoggerAsync({
         logArgs: true,
     })

src/modules/farm/base-module/services/farm.base.service.ts

@@ -51,12 +51,8 @@ export abstract class FarmServiceBase {
     }
 
     async getAllFarmTokens(farmAddresses: string[]): Promise<NftCollection[]> {
-        const farmTokenIDs = await getAllKeys<string>(
-            this.cachingService,
+        const farmTokenIDs = await this.farmAbi.getAllFarmTokenIds(
             farmAddresses,
-            'farm.farmTokenID',
-            this.farmAbi.farmTokenID.bind(this.farmAbi),
-            CacheTtlInfo.Token,
         );
         return this.tokenService.getAllNftsCollectionMetadata(farmTokenIDs);
     }

src/modules/farm/farm.abi.factory.ts

@@ -28,6 +28,10 @@ export class FarmAbiFactory {
         }
     }
 
+    async getAllFarmTokenIds(): Promise<string[]> {
+        return await this.abiServiceV2.getAllFarmTokenIds(farmsAddresses());
+    }
+
     async isFarmToken(tokenID: string): Promise<boolean> {
         for (const farmAddress of farmsAddresses()) {
             const farmTokenID = await this.useAbi(farmAddress).farmTokenID(

src/modules/farm/mocks/farm.abi.service.mock.ts

@@ -13,6 +13,11 @@ export class FarmAbiServiceMock implements IFarmAbiService {
     async farmTokenID(farmAddress: string): Promise<string> {
         return farms.find((f) => f.address === farmAddress).farmTokenID;
     }
+    async getAllFarmTokenIds(farmsAddresses: string[]): Promise<string[]> {
+        return farms
+            .filter((farm) => farmsAddresses.includes(farm.address))
+            .map((farm) => farm.farmTokenID);
+    }
     async farmingTokenID(farmAddress: string): Promise<string> {
         return farms.find((f) => f.address === farmAddress).farmingTokenID;
     }

src/modules/pair/mocks/pair.abi.service.mock.ts

@@ -32,6 +32,11 @@ export class PairAbiServiceMock implements IPairAbiService {
     async pairInfoMetadata(pairAddress: string): Promise<PairInfoModel> {
         return PairsData(pairAddress).info;
     }
+    async getAllPairsInfoMetadata(
+        pairAddresses: string[],
+    ): Promise<PairInfoModel[]> {
+        return pairAddresses.map((pairAddress) => PairsData(pairAddress).info);
+    }
     async totalFeePercent(pairAddress: string): Promise<number> {
         return PairsData(pairAddress).totalFeePercent;
     }

src/modules/pair/mocks/pair.compute.service.mock.ts

@@ -55,6 +55,20 @@ export class PairComputeServiceMock implements IPairComputeService {
     async secondTokenPriceUSD(pairAddress: string): Promise<string> {
         return PairsData(pairAddress).secondTokenPriceUSD;
     }
+    async getAllFirstTokensPriceUSD(
+        pairAddresses: string[],
+    ): Promise<string[]> {
+        return pairAddresses.map(
+            (pairAddress) => PairsData(pairAddress).firstTokenPriceUSD,
+        );
+    }
+    async getAllSecondTokensPricesUSD(
+        pairAddresses: string[],
+    ): Promise<string[]> {
+        return pairAddresses.map(
+            (pairAddress) => PairsData(pairAddress).secondTokenPriceUSD,
+        );
+    }
     async firstTokenLockedValueUSD(pairAddress: string): Promise<string> {
         return PairsData(pairAddress).firstTokenLockedValueUSD;
     }

src/modules/pair/services/pair.abi.loader.ts

@@ -40,13 +40,7 @@ export class PairAbiLoader {
 
     public readonly infoMetadataLoader = new DataLoader<string, PairInfoModel>(
         async (addresses: string[]) => {
-            return getAllKeys<PairInfoModel>(
-                this.cacheService,
-                addresses,
-                'pair.pairInfoMetadata',
-                this.pairAbi.pairInfoMetadata.bind(this.pairAbi),
-                CacheTtlInfo.ContractBalance,
-            );
+            return this.pairAbi.getAllPairsInfoMetadata(addresses);
         },
     );
 

src/modules/pair/services/pair.abi.service.ts

@@ -29,6 +29,7 @@ import { CacheTtlInfo } from 'src/services/caching/cache.ttl.info';
 import { Constants } from '@multiversx/sdk-nestjs-common';
 import { CacheService } from '@multiversx/sdk-nestjs-cache';
 import { IPairAbiService } from '../interfaces';
+import { getAllKeys } from 'src/utils/get.many.utils';
 
 @Injectable()
 export class PairAbiService
@@ -204,6 +205,18 @@ export class PairAbiService
         });
     }
 
+    async getAllPairsInfoMetadata(
+        pairAddresses: string[],
+    ): Promise<PairInfoModel[]> {
+        return await getAllKeys<PairInfoModel>(
+            this.cachingService,
+            pairAddresses,
+            'pair.pairInfoMetadata',
+            this.pairInfoMetadata.bind(this),
+            CacheTtlInfo.ContractBalance,
+        );
+    }
+
     @ErrorLoggerAsync({
         logArgs: true,
     })

src/modules/pair/services/pair.compute.loader.ts

@@ -42,24 +42,14 @@ export class PairComputeLoader {
 
     public readonly firstTokenPriceUSDLoader = new DataLoader<string, string>(
         async (addresses: string[]) => {
-            return await getAllKeys(
-                this.cacheService,
-                addresses,
-                'pair.firstTokenPriceUSD',
-                this.pairCompute.firstTokenPriceUSD.bind(this.pairCompute),
-                CacheTtlInfo.Price,
-            );
+            return await this.pairCompute.getAllFirstTokensPriceUSD(addresses);
         },
     );
 
     public readonly secondTokenPriceUSDLoader = new DataLoader<string, string>(
         async (addresses: string[]) => {
-            return await getAllKeys(
-                this.cacheService,
+            return await this.pairCompute.getAllSecondTokensPricesUSD(
                 addresses,
-                'pair.secondTokenPriceUSD',
-                this.pairCompute.secondTokenPriceUSD.bind(this.pairCompute),
-                CacheTtlInfo.Price,
             );
         },
     );

src/modules/pair/services/pair.compute.service.ts

@@ -25,6 +25,8 @@ import { FarmAbiServiceV2 } from 'src/modules/farm/v2/services/farm.v2.abi.servi
 import { TransactionStatus } from 'src/utils/transaction.utils';
 import { FarmComputeServiceV2 } from 'src/modules/farm/v2/services/farm.v2.compute.service';
 import { StakingComputeService } from 'src/modules/staking/services/staking.compute.service';
+import { CacheService } from '@multiversx/sdk-nestjs-cache';
+import { getAllKeys } from 'src/utils/get.many.utils';
 
 @Injectable()
 export class PairComputeService implements IPairComputeService {
@@ -46,6 +48,7 @@ export class PairComputeService implements IPairComputeService {
         private readonly apiService: MXApiService,
         private readonly farmCompute: FarmComputeServiceV2,
         private readonly stakingCompute: StakingComputeService,
+        private readonly cachingService: CacheService,
     ) {}
 
     async getTokenPrice(pairAddress: string, tokenID: string): Promise<string> {
@@ -218,6 +221,18 @@ export class PairComputeService implements IPairComputeService {
         );
     }
 
+    async getAllFirstTokensPriceUSD(
+        pairAddresses: string[],
+    ): Promise<string[]> {
+        return await getAllKeys<string>(
+            this.cachingService,
+            pairAddresses,
+            'pair.firstTokenPriceUSD',
+            this.firstTokenPriceUSD.bind(this),
+            CacheTtlInfo.Price,
+        );
+    }
+
     @ErrorLoggerAsync({
         logArgs: true,
     })
@@ -254,6 +269,18 @@ export class PairComputeService implements IPairComputeService {
         );
     }
 
+    async getAllSecondTokensPricesUSD(
+        pairAddresses: string[],
+    ): Promise<string[]> {
+        return await getAllKeys<string>(
+            this.cachingService,
+            pairAddresses,
+            'pair.secondTokenPriceUSD',
+            this.secondTokenPriceUSD.bind(this),
+            CacheTtlInfo.Price,
+        );
+    }
+
     @ErrorLoggerAsync({
         logArgs: true,
     })

src/modules/pair/services/pair.service.ts

@@ -21,6 +21,7 @@ import { RouterAbiService } from 'src/modules/router/services/router.abi.service
 import { TokenService } from 'src/modules/tokens/services/token.service';
 import { getAllKeys } from 'src/utils/get.many.utils';
 import { CacheTtlInfo } from 'src/services/caching/cache.ttl.info';
+import { PairInfoModel } from '../models/pair-info.model';
 
 @Injectable()
 export class PairService {
@@ -281,6 +282,13 @@ export class PairService {
     ): Promise<LiquidityPosition> {
         const pairInfo = await this.pairAbi.pairInfoMetadata(pairAddress);
 
+        return this.computeLiquidityPosition(pairInfo, amount);
+    }
+
+    private computeLiquidityPosition(
+        pairInfo: PairInfoModel,
+        amount: string,
+    ): LiquidityPosition {
         const firstTokenAmount = getTokenForGivenPosition(
             amount,
             pairInfo.reserves0,
@@ -298,6 +306,19 @@ export class PairService {
         });
     }
 
+    async getAllLiquidityPositions(
+        pairAddresses: string[],
+        amounts: string[],
+    ): Promise<LiquidityPosition[]> {
+        const allPairsInfo = await this.pairAbi.getAllPairsInfoMetadata(
+            pairAddresses,
+        );
+
+        return allPairsInfo.map((pairInfo, index) =>
+            this.computeLiquidityPosition(pairInfo, amounts[index]),
+        );
+    }
+
     async getLiquidityPositionUSD(
         pairAddress: string,
         amount: string,
@@ -330,6 +351,38 @@ export class PairService {
             .toFixed();
     }
 
+    async getAllLiquidityPositionsUSD(
+        pairAddresses: string[],
+        amounts: string[],
+    ): Promise<string[]> {
+        const allFirstTokens = await this.getAllFirstTokens(pairAddresses);
+        const allSecondTokens = await this.getAllSecondTokens(pairAddresses);
+        const allFirstTokensPriceUSD =
+            await this.pairCompute.getAllFirstTokensPriceUSD(pairAddresses);
+        const allSecondTokensPriceUSD =
+            await this.pairCompute.getAllSecondTokensPricesUSD(pairAddresses);
+        const allLiquidityPositions = await this.getAllLiquidityPositions(
+            pairAddresses,
+            amounts,
+        );
+
+        return pairAddresses.map((_, index) => {
+            return computeValueUSD(
+                allLiquidityPositions[index].firstTokenAmount,
+                allFirstTokens[index].decimals,
+                allFirstTokensPriceUSD[index],
+            )
+                .plus(
+                    computeValueUSD(
+                        allLiquidityPositions[index].secondTokenAmount,
+                        allSecondTokens[index].decimals,
+                        allSecondTokensPriceUSD[index],
+                    ),
+                )
+                .toFixed();
+        });
+    }
+
     async getPairAddressByLpTokenID(tokenID: string): Promise<string | null> {
         const cachedValue: string = await this.cachingService.get(
             `${tokenID}.pairAddress`,
@@ -338,10 +391,8 @@ export class PairService {
             return cachedValue;
         }
         const pairsAddress = await this.routerAbi.pairsAddress();
-        const promises = pairsAddress.map(async (pairAddress) =>
-            this.pairAbi.lpTokenID(pairAddress),
-        );
-        const lpTokenIDs = await Promise.all(promises);
+        const lpTokenIDs = await this.getAllLpTokensIds(pairsAddress);
+
         let returnedData = null;
         for (let index = 0; index < lpTokenIDs.length; index++) {
             if (lpTokenIDs[index] === tokenID) {

src/modules/price-discovery/services/price.discovery.abi.service.ts

@@ -10,13 +10,18 @@ import { ErrorLoggerAsync } from '@multiversx/sdk-nestjs-common';
 import { GetOrSetCache } from 'src/helpers/decorators/caching.decorator';
 import { CacheTtlInfo } from 'src/services/caching/cache.ttl.info';
 import { IPriceDiscoveryAbiService } from './interfaces';
+import { CacheService } from '@multiversx/sdk-nestjs-cache';
+import { getAllKeys } from 'src/utils/get.many.utils';
 
 @Injectable()
 export class PriceDiscoveryAbiService
     extends GenericAbiService
     implements IPriceDiscoveryAbiService
 {
-    constructor(protected readonly mxProxy: MXProxyService) {
+    constructor(
+        protected readonly mxProxy: MXProxyService,
+        private readonly cachingService: CacheService,
+    ) {
         super(mxProxy);
     }
 
@@ -93,6 +98,18 @@ export class PriceDiscoveryAbiService
         return response.firstValue.valueOf().toString();
     }
 
+    async getAllRedeemTokenIds(
+        priceDiscoveryAddresses: string[],
+    ): Promise<string[]> {
+        return await getAllKeys<string>(
+            this.cachingService,
+            priceDiscoveryAddresses,
+            'priceDiscovery.redeemTokenID',
+            this.redeemTokenID.bind(this),
+            CacheTtlInfo.Token,
+        );
+    }
+
     @ErrorLoggerAsync({
         logArgs: true,
     })