[SERVICES-2427] Search by token (ID/ticker/name) for pairs and tokens queries

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

@@ -0,0 +1,17 @@
+import { EsdtToken } from 'src/modules/tokens/models/esdtToken.model';
+import { PairsData } from './pair.constants';
+import { PairService } from '../services/pair.service';
+
+export class PairServiceMock {
+    async getFirstToken(pairAddress: string): Promise<EsdtToken> {
+        return PairsData(pairAddress).firstToken;
+    }
+    async getSecondToken(pairAddress: string): Promise<EsdtToken> {
+        return PairsData(pairAddress).secondToken;
+    }
+}
+
+export const PairServiceProvider = {
+    provide: PairService,
+    useClass: PairServiceMock,
+};

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

@@ -7,12 +7,14 @@ import {
     PairsFilter,
 } from 'src/modules/router/models/filter.args';
 import BigNumber from 'bignumber.js';
+import { PairService } from './pair.service';
 
 @Injectable()
 export class PairFilteringService {
     constructor(
         private readonly pairAbi: PairAbiService,
         private readonly pairCompute: PairComputeService,
+        private readonly pairService: PairService,
     ) {}
 
     async pairsByIssuedLpToken(
@@ -82,6 +84,47 @@ export class PairFilteringService {
         return await Promise.resolve(pairsMetadata);
     }
 
+    async pairsByWildcardToken(
+        pairFilter: PairsFilter,
+        pairsMetadata: PairMetadata[],
+    ): Promise<PairMetadata[]> {
+        if (!pairFilter.searchToken || pairFilter.searchToken.trim() === '') {
+            return pairsMetadata;
+        }
+
+        const searchTerm = pairFilter.searchToken.toUpperCase().trim();
+
+        const pairsFirstToken = await Promise.all(
+            pairsMetadata.map((pairMetadata) =>
+                this.pairService.getFirstToken(pairMetadata.address),
+            ),
+        );
+        const pairsSecondToken = await Promise.all(
+            pairsMetadata.map((pairMetadata) =>
+                this.pairService.getSecondToken(pairMetadata.address),
+            ),
+        );
+
+        const filteredPairs: PairMetadata[] = [];
+        for (const [index, pair] of pairsMetadata.entries()) {
+            const firstToken = pairsFirstToken[index];
+            const secondToken = pairsSecondToken[index];
+
+            if (
+                firstToken.name.toUpperCase().includes(searchTerm) ||
+                firstToken.identifier.toUpperCase().includes(searchTerm) ||
+                firstToken.ticker.toUpperCase().includes(searchTerm) ||
+                secondToken.name.toUpperCase().includes(searchTerm) ||
+                secondToken.identifier.toUpperCase().includes(searchTerm) ||
+                secondToken.ticker.toUpperCase().includes(searchTerm)
+            ) {
+                filteredPairs.push(pair);
+            }
+        }
+
+        return filteredPairs;
+    }
+
     async pairsByState(
         pairFilter: PairFilterArgs | PairsFilter,
         pairsMetadata: PairMetadata[],

src/modules/pair/services/pair.metadata.builder.ts

@@ -52,6 +52,14 @@ export class PairsMetadataBuilder {
     }
 
     async filterByTokens(): Promise<PairsMetadataBuilder> {
+        if (this.filters.searchToken) {
+            this.pairsMetadata =
+                await this.filteringService.pairsByWildcardToken(
+                    this.filters,
+                    this.pairsMetadata,
+                );
+        }
+
         this.pairsMetadata = await this.filteringService.pairsByTokens(
             this.filters,
             this.pairsMetadata,

src/modules/router/models/filter.args.ts

@@ -57,6 +57,8 @@ export class PairsFilter {
     hasDualFarms: boolean;
     @Field({ nullable: true })
     minDeployedAt: number;
+    @Field({ nullable: true })
+    searchToken: string;
 }
 
 @InputType()

src/modules/router/specs/router.service.spec.ts

@@ -12,6 +12,7 @@ import winston from 'winston';
 import { DynamicModuleUtils } from 'src/utils/dynamic.module.utils';
 import { PairComputeServiceProvider } from 'src/modules/pair/mocks/pair.compute.service.mock';
 import { PairFilteringService } from 'src/modules/pair/services/pair.filtering.service';
+import { PairServiceProvider } from 'src/modules/pair/mocks/pair.service.mock';
 
 describe('RouterService', () => {
     let module: TestingModule;
@@ -32,6 +33,7 @@ describe('RouterService', () => {
                 RouterService,
                 ApiConfigService,
                 PairFilteringService,
+                PairServiceProvider,
             ],
         }).compile();
     });

src/modules/tokens/models/tokens.filter.args.ts

@@ -30,6 +30,8 @@ export class TokensFilter {
     type?: string;
     @Field(() => Boolean, { defaultValue: false })
     enabledSwaps: boolean;
+    @Field({ nullable: true })
+    searchToken?: string;
 }
 
 @InputType()

src/modules/tokens/services/token.filtering.service.ts

@@ -1,6 +1,7 @@
 import { Inject, Injectable, forwardRef } from '@nestjs/common';
 import { TokenService } from './token.service';
 import { TokensFilter } from '../models/tokens.filter.args';
+import { EsdtToken } from '../models/esdtToken.model';
 
 @Injectable()
 export class TokenFilteringService {
@@ -43,4 +44,31 @@ export class TokenFilteringService {
         }
         return filteredIDs;
     }
+
+    async tokensBySearchTerm(
+        tokensFilter: TokensFilter,
+        tokens: EsdtToken[],
+    ): Promise<EsdtToken[]> {
+        if (
+            !tokensFilter.searchToken ||
+            tokensFilter.searchToken.trim() === ''
+        ) {
+            return tokens;
+        }
+
+        const searchTerm = tokensFilter.searchToken.toUpperCase().trim();
+
+        const filteredTokens: EsdtToken[] = [];
+        for (const token of tokens) {
+            if (
+                token.name.toUpperCase().includes(searchTerm) ||
+                token.identifier.toUpperCase().includes(searchTerm) ||
+                token.ticker.toUpperCase().includes(searchTerm)
+            ) {
+                filteredTokens.push(token);
+            }
+        }
+
+        return filteredTokens;
+    }
 }

src/modules/tokens/services/token.service.ts

@@ -76,14 +76,19 @@ export class TokenService {
             tokenIDs,
         );
 
+        let tokens = await Promise.all(
+            tokenIDs.map((tokenID) => this.getTokenMetadata(tokenID)),
+        );
+
+        tokens = await this.tokenFilteringService.tokensBySearchTerm(
+            filters,
+            tokens,
+        );
+
         if (sorting) {
             tokenIDs = await this.sortTokens(tokenIDs, sorting);
         }
 
-        const tokens = await Promise.all(
-            tokenIDs.map((tokenID) => this.getTokenMetadata(tokenID)),
-        );
-
         return new CollectionType({
             count: tokens.length,
             items: tokens.slice(