remove unused graphql fields

src/common/graphql/graphql.service.ts

@@ -16,6 +16,9 @@ export class GraphQlService {
     const exchangeServiceUrl = this.apiConfigService.getExchangeServiceUrlMandatory();
     const graphqlClient = new GraphQLClient(exchangeServiceUrl, {
       fetch: this.createFetchWithTimeout(60_000),
+      headers: {
+        'origin': this.apiConfigService.getSelfUrl(),
+      },
     });
 
     try {

src/endpoints/mex/entities/mex.pair.ts

@@ -68,12 +68,6 @@ export class MexPair {
   @ApiProperty({ type: String, example: 'jungledex' })
   exchange: MexPairExchange | undefined;
 
-  @ApiProperty({ type: Boolean, nullable: true })
-  hasFarms: boolean | undefined = undefined;
-
-  @ApiProperty({ type: Boolean, nullable: true })
-  hasDualFarms: boolean | undefined = undefined;
-
   @ApiProperty({ type: Number, nullable: true })
   tradesCount: number | undefined = undefined;
 
@@ -82,4 +76,10 @@ export class MexPair {
 
   @ApiProperty({ type: Number, nullable: true })
   deployedAt: number | undefined = undefined;
+
+  @ApiProperty({ type: Boolean, nullable: true })
+  hasFarms?: boolean;
+
+  @ApiProperty({ type: Boolean, nullable: true })
+  hasDualFarms?: boolean;
 }

src/endpoints/mex/entities/mex.pairs..filter.ts

@@ -5,4 +5,5 @@ export class MexPairsFilter {
     Object.assign(this, init);
   }
   exchange?: MexPairExchange;
+  includeFarms?: boolean;
 }

src/endpoints/mex/entities/mex.settings.ts

@@ -23,7 +23,7 @@ export class MexSettings {
       ...response.proxy.map((x: any) => x.address),
     ];
     settings.pairContracts = [
-      ...response.pairs.filter((x: any) => x.state === 'Active').map((x: any) => x.address),
+      ...response.pairs.map((x: any) => x.address),
       ...response.proxy.map((x: any) => x.address),
     ];
     settings.wrapContracts = response.wrappingInfo.map((x: any) => x.address);
@@ -39,11 +39,11 @@ export class MexSettings {
     settings.lockedAssetIdentifier = lockedAssetIdentifiers.find((identifier: string) => identifier.startsWith('LKMEX'));
     settings.lockedAssetIdentifierV2 = lockedAssetIdentifiers.find((identifier: string) => identifier.startsWith('XMEX'));
 
-    const mexEgldPairs = response.pairs.filter((x: any) => x.firstToken.name === 'WrappedEGLD' && x.secondToken.name === 'MEX');
-    if (mexEgldPairs.length > 0) {
-      settings.wegldId = mexEgldPairs[0].firstToken.identifier;
-      settings.mexId = mexEgldPairs[0].secondToken.identifier;
-    }
+    const wrappedToken = response.wrappingInfo[0].wrappedToken.identifier;
+    const mexToken = response.simpleLockEnergy.baseAssetToken.identifier;
+
+    settings.wegldId = wrappedToken;
+    settings.mexId = mexToken;
 
     return settings;
   }

src/endpoints/mex/mex.controller.ts

@@ -11,7 +11,7 @@ import { MexTokenService } from "./mex.token.service";
 import { MexFarmService } from './mex.farm.service';
 import { MexFarm } from './entities/mex.farm';
 import { QueryPagination } from 'src/common/entities/query.pagination';
-import { ParseIntPipe, ParseTokenPipe, ParseEnumPipe } from '@multiversx/sdk-nestjs-common';
+import { ParseIntPipe, ParseTokenPipe, ParseEnumPipe, ParseBoolPipe } from '@multiversx/sdk-nestjs-common';
 import { MexPairExchange } from './entities/mex.pair.exchange';
 import { MexPairsFilter } from './entities/mex.pairs..filter';
 import { MexTokenChartsService } from './mex.token.charts.service';
@@ -56,12 +56,14 @@ export class MexController {
   @ApiQuery({ name: 'from', description: 'Number of items to skip for the result set', required: false })
   @ApiQuery({ name: 'size', description: 'Number of items to retrieve', required: false })
   @ApiQuery({ name: 'exchange', description: 'Filter by exchange', required: false, enum: MexPairExchange })
+  @ApiQuery({ name: 'includeFarms', description: 'Include farms information in response', required: false, type: Boolean })
   async getMexPairs(
     @Query('from', new DefaultValuePipe(0), ParseIntPipe) from: number,
     @Query("size", new DefaultValuePipe(25), ParseIntPipe) size: number,
     @Query('exchange', new ParseEnumPipe(MexPairExchange)) exchange?: MexPairExchange,
+    @Query('includeFarms', new DefaultValuePipe(false), ParseBoolPipe) includeFarms?: boolean,
   ): Promise<MexPair[]> {
-    const filter = new MexPairsFilter({ exchange });
+    const filter = new MexPairsFilter({ exchange, includeFarms });
     return await this.mexPairsService.getMexPairs(from, size, filter);
   }
 
@@ -83,10 +85,12 @@ export class MexController {
   @Get("/mex/pairs/count")
   @ApiOperation({ summary: 'Maiar Exchange pairs count', description: 'Returns active liquidity pools count available on Maiar Exchange' })
   @ApiQuery({ name: 'exchange', description: 'Filter by exchange', required: false, enum: MexPairExchange })
+  @ApiQuery({ name: 'includeFarms', description: 'Include farms information in response', required: false, type: Boolean })
   async getMexPairsCount(
     @Query('exchange', new ParseEnumPipe(MexPairExchange)) exchange?: MexPairExchange,
+    @Query('includeFarms', new DefaultValuePipe(false), ParseBoolPipe) includeFarms?: boolean,
   ): Promise<number> {
-    const filter = new MexPairsFilter({ exchange });
+    const filter = new MexPairsFilter({ exchange, includeFarms });
     return await this.mexPairsService.getMexPairsCount(filter);
   }
 
@@ -146,11 +150,13 @@ export class MexController {
   @Get("/mex/pairs/:baseId/:quoteId")
   @ApiOperation({ summary: 'xExchange pairs details', description: 'Returns liquidity pool details by providing a combination of two tokens' })
   @ApiOkResponse({ type: MexPair })
+  @ApiQuery({ name: 'includeFarms', description: 'Include farms information in response', required: false, type: Boolean })
   async getMexPair(
     @Param('baseId') baseId: string,
     @Param('quoteId') quoteId: string,
+    @Query('includeFarms', new DefaultValuePipe(false), ParseBoolPipe) includeFarms?: boolean,
   ): Promise<MexPair> {
-    const pair = await this.mexPairsService.getMexPair(baseId, quoteId);
+    const pair = await this.mexPairsService.getMexPair(baseId, quoteId, includeFarms);
     if (!pair) {
       throw new NotFoundException();
     }

src/endpoints/mex/mex.pair.service.ts

@@ -26,65 +26,60 @@ export class MexPairService {
   ) { }
 
   async refreshMexPairs(): Promise<void> {
-    const pairs = await this.getAllMexPairsRaw();
+    const pairs = await this.getAllMexPairsRaw(false);
     await this.cachingService.setRemote(CacheInfo.MexPairs.key, pairs, CacheInfo.MexPairs.ttl);
     await this.cachingService.setLocal(CacheInfo.MexPairs.key, pairs, Constants.oneSecond() * 30);
   }
 
   async getMexPairs(from: number, size: number, filter?: MexPairsFilter): Promise<any> {
-    let allMexPairs = await this.getAllMexPairs();
+    let allMexPairs = await this.getAllMexPairs(filter?.includeFarms ?? false);
     allMexPairs = this.applyFilters(allMexPairs, filter);
 
     return allMexPairs.slice(from, from + size);
   }
 
-
-  async getMexPair(baseId: string, quoteId: string): Promise<MexPair | undefined> {
-    const allMexPairs = await this.getAllMexPairs();
+  async getMexPair(baseId: string, quoteId: string, includeFarms: boolean = false): Promise<MexPair | undefined> {
+    const allMexPairs = await this.getAllMexPairs(includeFarms);
     return allMexPairs.find(pair => pair.baseId === baseId && pair.quoteId === quoteId);
   }
 
-  async getAllMexPairs(): Promise<MexPair[]> {
+  async getAllMexPairs(includeFarms: boolean = false): Promise<MexPair[]> {
     if (!this.apiConfigService.isExchangeEnabled()) {
       return [];
     }
 
+    const cacheKey = includeFarms ? CacheInfo.MexPairsWithFarms.key : CacheInfo.MexPairs.key;
+    const ttl = includeFarms ? CacheInfo.MexPairsWithFarms.ttl : CacheInfo.MexPairs.ttl;
+
     return await this.cachingService.getOrSet(
-      CacheInfo.MexPairs.key,
-      async () => await this.getAllMexPairsRaw(),
-      CacheInfo.MexPairs.ttl,
+      cacheKey,
+      async () => await this.getAllMexPairsRaw(includeFarms),
+      ttl,
       Constants.oneSecond() * 30,
     );
   }
 
   async getMexPairsCount(filter?: MexPairsFilter): Promise<number> {
-    const mexPairs = await this.getAllMexPairs();
+    const mexPairs = await this.getAllMexPairs(filter?.includeFarms ?? false);
     const filteredPairs = this.applyFilters(mexPairs, filter);
 
     return filteredPairs.length;
   }
 
-  async getAllMexPairsRaw(): Promise<MexPair[]> {
+  async getAllMexPairsRaw(includeFarms: boolean = false): Promise<MexPair[]> {
     try {
       const settings = await this.mexSettingService.getSettings();
       if (!settings) {
         throw new BadRequestException('Could not fetch MEX settings');
       }
 
-      const pairsLimit = gql`
-        query PairCount {
-          factory {
-            pairCount
-          }
-        }`;
-
-      const pairsLimitResult: any = await this.graphQlService.getExchangeServiceData(pairsLimit);
-      const totalPairs = pairsLimitResult?.factory?.pairCount;
+      const allPairs: MexPair[] = [];
+      let cursor: string | null = null;
+      let hasNextPage = true;
 
-      const variables = {
-        pagination: { first: totalPairs },
-        filters: { state: MexPairStatus.active },
-      };
+      const farmFields = includeFarms ? `
+        hasFarms
+        hasDualFarms` : '';
 
       const query = gql`
         query filteredPairs($pagination: ConnectionArgs!, $filters: PairsFilter!) {
@@ -102,58 +97,62 @@ export class MexPairService {
                 firstToken {
                   name
                   identifier
-                  decimals
                   previous24hPrice
                   __typename
                 }
                 secondToken {
                   name
                   identifier
-                  decimals
                   previous24hPrice
                   __typename
                 }
-                firstTokenPrice
                 firstTokenPriceUSD
-                secondTokenPrice
                 secondTokenPriceUSD
-                info {
-                  reserves0
-                  reserves1
-                  totalSupply
-                  __typename
-                }
                 state
                 type
                 lockedValueUSD
                 volumeUSD24h
-                hasFarms
-                hasDualFarms
                 tradesCount
                 tradesCount24h
                 deployedAt
-                __typename
+                ${farmFields}
               }
             }
+            pageInfo {
+              hasNextPage
+            }
           }
         }
       `;
 
-      const result: any = await this.graphQlService.getExchangeServiceData(query, variables);
-      if (!result) {
-        return [];
+      while (hasNextPage) {
+        const variables = {
+          pagination: { first: 25, after: cursor },
+          filters: { state: [MexPairStatus.active] },
+        };
+
+        const result: any = await this.graphQlService.getExchangeServiceData(query, variables);
+        if (!result) {
+          break;
+        }
+
+        const pairs = result.filteredPairs.edges.map((edge: any) => this.getPairInfo(edge.node, includeFarms));
+        allPairs.push(...pairs.filter((pair: MexPair | undefined) => pair !== undefined));
+
+        hasNextPage = result.filteredPairs.pageInfo.hasNextPage;
+        cursor = result.filteredPairs.edges.length > 0 ? result.filteredPairs.edges[result.filteredPairs.edges.length - 1].cursor : null;
       }
 
-      return result.filteredPairs.edges
-        .map((edge: any) => this.getPairInfo(edge.node));
+      return allPairs;
     } catch (error) {
       this.logger.error('An error occurred while getting all mex pairs');
       this.logger.error(error);
       return [];
     }
   }
 
-  private getPairInfo(pair: any): MexPair | undefined {
+
+  private getPairInfo(pair: any, includeFarms: boolean = false): MexPair | undefined {
     const firstTokenSymbol = pair.firstToken.identifier.split('-')[0];
     const secondTokenSymbol = pair.secondToken.identifier.split('-')[0];
     const state = this.getPairState(pair.state);
@@ -178,13 +177,29 @@ export class MexPairService {
       exchange = MexPairExchange.unknown;
     }
 
+    const baseInfo = {
+      address: pair.address,
+      id: pair.liquidityPoolToken.identifier,
+      symbol: pair.liquidityPoolToken.identifier.split('-')[0],
+      name: pair.liquidityPoolToken.name,
+      price: Number(pair.liquidityPoolTokenPriceUSD),
+      totalValue: Number(pair.lockedValueUSD),
+      volume24h: Number(pair.volumeUSD24h),
+      tradesCount: Number(pair.tradesCount),
+      tradesCount24h: Number(pair.tradesCount24h),
+      deployedAt: Number(pair.deployedAt),
+      state,
+      type,
+      exchange,
+      ...(includeFarms && {
+        hasFarms: pair.hasFarms ?? false,
+        hasDualFarms: pair.hasDualFarms ?? false,
+      }),
+    };
+
     if ((firstTokenSymbol === 'WEGLD' && secondTokenSymbol === 'USDC') || secondTokenSymbol === 'WEGLD') {
       return {
-        address: pair.address,
-        id: pair.liquidityPoolToken.identifier,
-        symbol: pair.liquidityPoolToken.identifier.split('-')[0],
-        name: pair.liquidityPoolToken.name,
-        price: Number(pair.liquidityPoolTokenPriceUSD),
+        ...baseInfo,
         basePrevious24hPrice: Number(pair.firstToken.previous24hPrice),
         quotePrevious24hPrice: Number(pair.secondToken.previous24hPrice),
         baseId: pair.firstToken.identifier,
@@ -195,25 +210,11 @@ export class MexPairService {
         quotePrice: Number(pair.secondTokenPriceUSD),
         quoteSymbol: secondTokenSymbol,
         quoteName: pair.secondToken.name,
-        totalValue: Number(pair.lockedValueUSD),
-        volume24h: Number(pair.volumeUSD24h),
-        hasFarms: pair.hasFarms,
-        hasDualFarms: pair.hasDualFarms,
-        tradesCount: Number(pair.tradesCount),
-        tradesCount24h: Number(pair.tradesCount24h),
-        deployedAt: Number(pair.deployedAt),
-        state,
-        type,
-        exchange,
       };
     }
 
     return {
-      address: pair.address,
-      id: pair.liquidityPoolToken.identifier,
-      symbol: pair.liquidityPoolToken.identifier.split('-')[0],
-      name: pair.liquidityPoolToken.name,
-      price: Number(pair.liquidityPoolTokenPriceUSD),
+      ...baseInfo,
       basePrevious24hPrice: Number(pair.secondToken.previous24hPrice),
       quotePrevious24hPrice: Number(pair.firstToken.previous24hPrice),
       baseId: pair.secondToken.identifier,
@@ -224,16 +225,6 @@ export class MexPairService {
       quotePrice: Number(pair.firstTokenPriceUSD),
       quoteSymbol: firstTokenSymbol,
       quoteName: pair.firstToken.name,
-      totalValue: Number(pair.lockedValueUSD),
-      volume24h: Number(pair.volumeUSD24h),
-      hasFarms: pair.hasFarms,
-      hasDualFarms: pair.hasDualFarms,
-      tradesCount: Number(pair.tradesCount),
-      tradesCount24h: Number(pair.tradesCount24h),
-      deployedAt: Number(pair.deployedAt),
-      state,
-      type,
-      exchange,
     };
   }