feat: restore api search

apps/api/src/app/inversify.config.ts

@@ -4,6 +4,7 @@ import {
   getPushNotificationsRepository,
   getPushSubscriptionsRepository,
   getSimulationRepository,
+  getTokenCacheRepository,
   getTokenHolderRepository,
   getUsdRepository,
 } from '@cowprotocol/services';
@@ -14,13 +15,15 @@ import {
   PushNotificationsRepository,
   PushSubscriptionsRepository,
   SimulationRepository,
+  TokenCacheRepository,
   TokenHolderRepository,
   UsdRepository,
   cacheRepositorySymbol,
   erc20RepositorySymbol,
   pushNotificationsRepositorySymbol,
   pushSubscriptionsRepositorySymbol,
   tenderlyRepositorySymbol,
+  tokenCacheRepositorySymbol,
   tokenHolderRepositorySymbol,
   usdRepositorySymbol,
 } from '@cowprotocol/repositories';
@@ -52,6 +55,7 @@ function getApiContainer(): Container {
   const cacheRepository = getCacheRepository();
   const erc20Repository = getErc20Repository(cacheRepository);
   const simulationRepository = getSimulationRepository();
+  const tokenCacheRepository = getTokenCacheRepository();
   const tokenHolderRepository = getTokenHolderRepository(cacheRepository);
   const usdRepository = getUsdRepository(cacheRepository, erc20Repository);
   const pushNotificationsRepository = getPushNotificationsRepository();
@@ -85,6 +89,10 @@ function getApiContainer(): Container {
     .bind<TokenHolderRepository>(tokenHolderRepositorySymbol)
     .toConstantValue(tokenHolderRepository);
 
+  apiContainer
+    .bind<TokenCacheRepository>(tokenCacheRepositorySymbol)
+    .toConstantValue(tokenCacheRepository);
+
   // Services
   apiContainer
     .bind<SlippageService>(slippageServiceSymbol)

apps/api/src/app/routes/__chainId/tokens/initTokenList/index.ts

@@ -0,0 +1,47 @@
+import { initTokenList } from '@cowprotocol/repositories';
+import { FastifyPluginAsync } from 'fastify';
+import {
+  errorSchema,
+  ErrorSchema,
+  paramsSchema,
+  RouteSchema,
+  successSchema,
+  SuccessSchema,
+} from './schemas';
+
+const root: FastifyPluginAsync = async (fastify): Promise<void> => {
+  // example: http://localhost:3001/1/tokens/initTokenList
+  fastify.get<{
+    Params: RouteSchema;
+    Reply: SuccessSchema | ErrorSchema;
+  }>(
+    '/',
+    {
+      schema: {
+        params: paramsSchema,
+        response: {
+          '2XX': successSchema,
+          '404': errorSchema,
+        },
+      },
+    },
+    async function (request, reply) {
+      const { chainId } = request.params;
+
+      try {
+        await initTokenList(chainId);
+
+        fastify.log.info(`Token list initalized for chain ${chainId}`);
+
+        reply.send(true);
+      } catch (error) {
+        fastify.log.error('Error searching tokens:', error);
+        reply.code(500).send({
+          message: 'Internal server error while searching tokens',
+        });
+      }
+    }
+  );
+};
+
+export default root;

apps/api/src/app/routes/__chainId/tokens/initTokenList/schemas.ts

@@ -0,0 +1,32 @@
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
+import { SupportedChainIdSchema } from '../../../../schemas';
+
+export const paramsSchema = {
+  type: 'object',
+  required: ['chainId'],
+  additionalProperties: false,
+  properties: {
+    chainId: SupportedChainIdSchema,
+  },
+} as const satisfies JSONSchema;
+
+export const successSchema = {
+  type: 'boolean',
+} as const satisfies JSONSchema;
+
+export const errorSchema = {
+  type: 'object',
+  required: ['message'],
+  additionalProperties: false,
+  properties: {
+    message: {
+      title: 'Message',
+      description: 'Message describing the error.',
+      type: 'string',
+    },
+  },
+} as const satisfies JSONSchema;
+
+export type RouteSchema = FromSchema<typeof paramsSchema>;
+export type SuccessSchema = FromSchema<typeof successSchema>;
+export type ErrorSchema = FromSchema<typeof errorSchema>;

apps/api/src/app/routes/__chainId/tokens/search/__searchParam/index.ts

@@ -0,0 +1,49 @@
+import { getTokenListBySearchParam } from '@cowprotocol/repositories';
+import { FastifyPluginAsync } from 'fastify';
+import {
+  errorSchema,
+  ErrorSchema,
+  paramsSchema,
+  RouteSchema,
+  successSchema,
+  SuccessSchema,
+} from './schemas';
+
+const root: FastifyPluginAsync = async (fastify): Promise<void> => {
+  // example: http://localhost:3010/1/tokens/search/USDC
+  fastify.get<{
+    Params: RouteSchema;
+    Reply: SuccessSchema | ErrorSchema;
+  }>(
+    '/',
+    {
+      schema: {
+        params: paramsSchema,
+        response: {
+          '2XX': successSchema,
+          '404': errorSchema,
+        },
+      },
+    },
+    async function (request, reply) {
+      const { chainId, searchParam } = request.params;
+
+      try {
+        const tokens = await getTokenListBySearchParam(chainId, searchParam);
+
+        fastify.log.info(
+          `Token search for "${searchParam}" on chain ${chainId}: ${tokens.length} tokens found`
+        );
+
+        reply.send(tokens);
+      } catch (error) {
+        fastify.log.error('Error searching tokens:', error);
+        reply.code(500).send({
+          message: 'Internal server error while searching tokens',
+        });
+      }
+    }
+  );
+};
+
+export default root;

apps/api/src/app/routes/__chainId/tokens/search/__searchParam/schemas.ts

@@ -0,0 +1,81 @@
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
+import { SupportedChainIdSchema } from '../../../../../schemas';
+import { AllChainIds } from '@cowprotocol/shared';
+
+export const paramsSchema = {
+  type: 'object',
+  required: ['chainId', 'searchParam'],
+  additionalProperties: false,
+  properties: {
+    chainId: SupportedChainIdSchema,
+    searchParam: {
+      title: 'Search Parameter',
+      description: 'Token search parameter (name, symbol, or address)',
+      type: 'string',
+      minLength: 3,
+      maxLength: 100,
+    },
+  },
+} as const satisfies JSONSchema;
+
+export const successSchema = {
+  type: 'array',
+  items: {
+    type: 'object',
+    required: ['chainId', 'address', 'name', 'symbol', 'decimals', 'logoURI'],
+    additionalProperties: false,
+    properties: {
+      chainId: {
+        title: 'Chain ID',
+        description: 'Blockchain network identifier.',
+        type: 'integer',
+        enum: AllChainIds,
+      },
+      address: {
+        title: 'Token Address',
+        description: 'Contract address of the token.',
+        type: 'string',
+        pattern: '^0x[a-fA-F0-9]{40}$',
+      },
+      name: {
+        title: 'Name',
+        description: 'Full name of the token.',
+        type: 'string',
+      },
+      symbol: {
+        title: 'Symbol',
+        description: 'Token symbol/ticker.',
+        type: 'string',
+      },
+      decimals: {
+        title: 'Decimals',
+        description: 'Number of decimal places for the token.',
+        type: 'integer',
+        minimum: 0,
+        maximum: 18,
+      },
+      logoURI: {
+        title: 'Logo URI',
+        description: 'URI to the token logo.',
+        type: 'string',
+      },
+    },
+  },
+} as const satisfies JSONSchema;
+
+export const errorSchema = {
+  type: 'object',
+  required: ['message'],
+  additionalProperties: false,
+  properties: {
+    message: {
+      title: 'Message',
+      description: 'Message describing the error.',
+      type: 'string',
+    },
+  },
+} as const satisfies JSONSchema;
+
+export type RouteSchema = FromSchema<typeof paramsSchema>;
+export type SuccessSchema = FromSchema<typeof successSchema>;
+export type ErrorSchema = FromSchema<typeof errorSchema>;

apps/api/src/main.ts

@@ -1,6 +1,8 @@
 import Fastify from 'fastify';
 import { app } from './app/app';
 import { logger } from '@cowprotocol/shared';
+import { getTokenCacheRepository } from '@cowprotocol/services';
+import { setTokenCacheRepository } from '@cowprotocol/repositories';
 
 const host = process.env.HOST ?? 'localhost';
 const port = process.env.PORT ? Number(process.env.PORT) : 3001;
@@ -10,6 +12,15 @@ export const server = Fastify({
   logger,
 });
 
+// Initialize token cache repository
+try {
+  const tokenCacheRepository = getTokenCacheRepository();
+  setTokenCacheRepository(tokenCacheRepository);
+  logger.info('Token cache repository initialized with Redis');
+} catch (error) {
+  logger.warn('Token cache repository not initialized:', error);
+}
+
 // Register your application as a normal plugin.
 server.register(app);
 

apps/notification-producer/jest.config.ts

@@ -6,6 +6,9 @@ export default {
   transform: {
     '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
   },
+  transformIgnorePatterns: [
+    'node_modules/(?!(node-fetch|data-uri-to-buffer|fetch-blob|formdata-polyfill|@cowprotocol|@uniswap)/)',
+  ],
   moduleFileExtensions: ['ts', 'js', 'html'],
   coverageDirectory: '../../coverage/apps/notification-producer',
   setupFilesAfterEnv: ['../../jest.setup.ts'],

libs/repositories/jest.config.ts

@@ -6,6 +6,9 @@ export default {
   transform: {
     '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
   },
+  transformIgnorePatterns: [
+    'node_modules/(?!(node-fetch|data-uri-to-buffer|fetch-blob|formdata-polyfill|@cowprotocol|@uniswap)/)',
+  ],
   moduleFileExtensions: ['ts', 'js', 'html'],
   coverageDirectory: '../../coverage/libs/repositories',
   setupFilesAfterEnv: ['../../jest.setup.ts'],

libs/repositories/src/datasources/tokenSearch/getTokensByChain.ts

@@ -0,0 +1,41 @@
+import { SupportedChainId } from '@cowprotocol/cow-sdk';
+import { TokenFromAPI } from './types';
+
+async function fetchTokensFromCoinGecko(
+  chainName: string,
+  chainId: SupportedChainId
+): Promise<TokenFromAPI[]> {
+  const tokenSource = `https://tokens.coingecko.com/${chainName}/all.json`;
+
+  console.log(`Fetching tokens for ${chainName}`);
+
+  const response = await fetch(tokenSource);
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch tokens from ${tokenSource}: ${response.status} ${response.statusText}`
+    );
+  }
+
+  const data = await response.json();
+
+  if (!data.tokens || !Array.isArray(data.tokens)) {
+    throw new Error(
+      `Invalid token list format from ${tokenSource}: missing or invalid tokens array`
+    );
+  }
+
+  console.log(`Fetched ${data.tokens.length} tokens for ${chainName}`);
+
+  return data.tokens.map((token: TokenFromAPI) => ({
+    ...token,
+    chainId,
+  }));
+}
+
+export async function getTokensByChainName(
+  chainName: string,
+  chainId: SupportedChainId
+): Promise<TokenFromAPI[]> {
+  return fetchTokensFromCoinGecko(chainName, chainId);
+}

libs/repositories/src/datasources/tokenSearch/index.ts

@@ -0,0 +1 @@
+export * from './tokenList';