feat: add tokens search discovery controller

app/components/hooks/useTokenSearchDiscovery/useTokenSearchDiscovery.test.ts

@@ -0,0 +1,67 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { useSelector } from 'react-redux';
+import Engine from '../../../core/Engine';
+import useTokenSearchDiscovery from './useTokenSearchDiscovery';
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+  useSelector: jest.fn(),
+}));
+
+jest.mock('../../../core/Engine', () => ({
+  context: {
+    TokenSearchDiscoveryController: {
+      searchTokens: jest.fn(),
+    },
+  },
+}));
+
+describe('useTokenSearchDiscovery', () => {
+  const mockRecentSearches = ['0x123', '0x456'];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (useSelector as jest.Mock).mockReturnValue(mockRecentSearches);
+  });
+
+  it('should return searchTokens function and recent searches', () => {
+    const { result } = renderHook(() => useTokenSearchDiscovery());
+
+    expect(result.current.searchTokens).toBeDefined();
+    expect(result.current.recentSearches).toEqual(mockRecentSearches);
+  });
+
+  it('should call TokenSearchDiscoveryController.searchTokens with correct params', async () => {
+    const mockSearchParams = {
+      chainId: '0x1',
+      query: 'DAI',
+      limit: '10',
+    };
+    const mockSearchResult = { tokens: [] };
+
+    (
+      Engine.context.TokenSearchDiscoveryController.searchTokens as jest.Mock
+    ).mockResolvedValueOnce(mockSearchResult);
+
+    const { result } = renderHook(() => useTokenSearchDiscovery());
+    const response = await result.current.searchTokens(mockSearchParams);
+
+    expect(
+      Engine.context.TokenSearchDiscoveryController.searchTokens,
+    ).toHaveBeenCalledWith(mockSearchParams);
+    expect(response).toEqual(mockSearchResult);
+  });
+
+  it('should handle search errors gracefully', async () => {
+    const mockError = new Error('Search failed');
+    (
+      Engine.context.TokenSearchDiscoveryController.searchTokens as jest.Mock
+    ).mockRejectedValueOnce(mockError);
+
+    const { result } = renderHook(() => useTokenSearchDiscovery());
+
+    await expect(result.current.searchTokens({})).rejects.toThrow(
+      'Search failed',
+    );
+  });
+});

app/components/hooks/useTokenSearchDiscovery/useTokenSearchDiscovery.ts

@@ -0,0 +1,21 @@
+import { useCallback } from 'react';
+import { useSelector } from 'react-redux';
+import Engine from '../../../core/Engine';
+import { selectRecentTokenSearches } from '../../../selectors/tokenSearchDiscoveryController';
+import { TokenSearchParams } from '@metamask/token-search-discovery-controller/dist/types.cjs';
+
+export const useTokenSearchDiscovery = () => {
+  const recentSearches = useSelector(selectRecentTokenSearches);
+
+  const searchTokens = useCallback(async (params: TokenSearchParams) => {
+    const { TokenSearchDiscoveryController } = Engine.context;
+    return await TokenSearchDiscoveryController.searchTokens(params);
+  }, []);
+
+  return {
+    searchTokens,
+    recentSearches,
+  };
+};
+
+export default useTokenSearchDiscovery;

app/core/Engine/Engine.ts

@@ -215,6 +215,7 @@ import {
   getGlobalNetworkClientId,
 } from '../../util/networks/global-network';
 import { logEngineCreation } from './utils/logger';
+import { createTokenSearchDiscoveryController } from './controllers/TokenSearchDiscoveryController';
 
 const NON_EMPTY = 'NON_EMPTY';
 
@@ -518,6 +519,17 @@ export class Engine {
       getMetaMetricsId: () => metaMetricsId ?? '',
     });
 
+    const tokenSearchDiscoveryController = createTokenSearchDiscoveryController(
+      {
+        state: initialState.TokenSearchDiscoveryController,
+        messenger: this.controllerMessenger.getRestricted({
+          name: 'TokenSearchDiscoveryController',
+          allowedActions: [],
+          allowedEvents: [],
+        }),
+      },
+    );
+
     const phishingController = new PhishingController({
       messenger: this.controllerMessenger.getRestricted({
         name: 'PhishingController',
@@ -1445,6 +1457,7 @@ export class Engine {
         isDecodeSignatureRequestEnabled: () =>
           preferencesController.state.useTransactionSimulations,
       }),
+      TokenSearchDiscoveryController: tokenSearchDiscoveryController,
       LoggingController: loggingController,
       ///: BEGIN:ONLY_INCLUDE_IF(preinstalled-snaps,external-snaps)
       SnapController: this.snapController,

app/core/Engine/controllers/TokenSearchDiscoveryController/constants.ts

@@ -0,0 +1,4 @@
+export const PORTFOLIO_API_URL = {
+  dev: 'https://portfolio.dev-api.cx.metamask.io/',
+  prod: 'https://portfolio.api.cx.metamask.io/',
+};

app/core/Engine/controllers/TokenSearchDiscoveryController/index.ts

@@ -0,0 +1 @@
+export { createTokenSearchDiscoveryController } from './utils';

app/core/Engine/controllers/TokenSearchDiscoveryController/types.ts

@@ -0,0 +1,7 @@
+import { TokenSearchDiscoveryControllerMessenger } from '@metamask/token-search-discovery-controller/dist/token-search-discovery-controller.cjs';
+import { TokenSearchDiscoveryControllerState } from '@metamask/token-search-discovery-controller';
+
+export interface TokenSearchDiscoveryControllerParams {
+  state?: Partial<TokenSearchDiscoveryControllerState>;
+  messenger: TokenSearchDiscoveryControllerMessenger;
+}

app/core/Engine/controllers/TokenSearchDiscoveryController/utils.test.ts

@@ -0,0 +1,194 @@
+import { createTokenSearchDiscoveryController } from './utils';
+import { ControllerMessenger } from '@metamask/base-controller';
+import {
+  TokenSearchDiscoveryControllerMessenger,
+  TokenSearchDiscoveryControllerState,
+} from '@metamask/token-search-discovery-controller/dist/token-search-discovery-controller.cjs';
+import Logger from '../../../../util/Logger';
+import { TokenSearchApiService } from '@metamask/token-search-discovery-controller';
+
+const mockError = new Error('Controller creation failed');
+
+// Top-level mocks
+jest.mock('../../../../util/Logger', () => ({
+  error: jest.fn(),
+}));
+
+jest.mock('@metamask/token-search-discovery-controller', () => ({
+  TokenSearchApiService: jest.fn(),
+  TokenSearchDiscoveryController: jest
+    .fn()
+    .mockImplementation(function (
+      this: { state: TokenSearchDiscoveryControllerState },
+      params: { state?: TokenSearchDiscoveryControllerState },
+    ) {
+      this.state = {
+        lastSearchTimestamp: null,
+        recentSearches: [],
+        ...params.state,
+      };
+      return this;
+    }),
+}));
+
+describe('TokenSearchDiscoveryController utils', () => {
+  let messenger: TokenSearchDiscoveryControllerMessenger;
+
+  beforeEach(() => {
+    messenger =
+      new ControllerMessenger() as unknown as TokenSearchDiscoveryControllerMessenger;
+  });
+
+  describe('createTokenSearchDiscoveryController', () => {
+    afterEach(() => {
+      jest.clearAllMocks();
+      jest.resetModules();
+    });
+
+    it('creates controller with initial undefined state', () => {
+      const controller = createTokenSearchDiscoveryController({
+        state: undefined,
+        messenger,
+      });
+
+      expect(controller).toBeDefined();
+      expect(controller.state).toStrictEqual({
+        lastSearchTimestamp: null,
+        recentSearches: [],
+      });
+    });
+
+    it('internal state matches initial state', () => {
+      const initialState: TokenSearchDiscoveryControllerState = {
+        lastSearchTimestamp: 123456789,
+        recentSearches: [
+          {
+            tokenAddress: '0x123',
+            chainId: '0x1',
+            name: 'Test Token 1',
+            symbol: 'TEST1',
+            usdPrice: 1.0,
+            usdPricePercentChange: {
+              oneDay: 0.0,
+            },
+          },
+          {
+            tokenAddress: '0x456',
+            chainId: '0x1',
+            name: 'Test Token 2',
+            symbol: 'TEST2',
+            usdPrice: 2.0,
+            usdPricePercentChange: {
+              oneDay: 0.0,
+            },
+          },
+        ],
+      };
+
+      const controller = createTokenSearchDiscoveryController({
+        state: initialState,
+        messenger,
+      });
+
+      expect(controller.state).toStrictEqual(initialState);
+    });
+
+    it('controller keeps initial extra data in its state', () => {
+      const initialState = {
+        extraData: true,
+      };
+
+      const controller = createTokenSearchDiscoveryController({
+        // @ts-expect-error giving a wrong initial state
+        state: initialState,
+        messenger,
+      });
+
+      expect(controller.state).toStrictEqual({
+        lastSearchTimestamp: null,
+        recentSearches: [],
+        extraData: true,
+      });
+    });
+
+    it('logs and rethrows error when controller creation fails', () => {
+      (TokenSearchApiService as jest.Mock).mockImplementation(() => {
+        throw mockError;
+      });
+
+      expect(() =>
+        createTokenSearchDiscoveryController({
+          state: undefined,
+          messenger,
+        }),
+      ).toThrow(mockError);
+
+      expect(Logger.error).toHaveBeenCalledWith(mockError);
+    });
+  });
+
+  describe('getPortfolioApiBaseUrl', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      jest.resetModules();
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it('returns dev URL when environment is local', () => {
+      process.env.METAMASK_ENVIRONMENT = 'local';
+      jest.isolateModules(() => {
+        const { createTokenSearchDiscoveryController: freshCreate } =
+          jest.requireActual('./utils');
+        const controller = freshCreate({
+          state: undefined,
+          messenger,
+        });
+        expect(controller.state).toBeDefined();
+      });
+    });
+
+    it('returns prod URL when environment is pre-release', () => {
+      process.env.METAMASK_ENVIRONMENT = 'pre-release';
+      jest.isolateModules(() => {
+        const { createTokenSearchDiscoveryController: freshCreate } =
+          jest.requireActual('./utils');
+        const controller = freshCreate({
+          state: undefined,
+          messenger,
+        });
+        expect(controller.state).toBeDefined();
+      });
+    });
+
+    it('returns prod URL when environment is production', () => {
+      process.env.METAMASK_ENVIRONMENT = 'production';
+      jest.isolateModules(() => {
+        const { createTokenSearchDiscoveryController: freshCreate } =
+          jest.requireActual('./utils');
+        const controller = freshCreate({
+          state: undefined,
+          messenger,
+        });
+        expect(controller.state).toBeDefined();
+      });
+    });
+
+    it('returns dev URL when environment is not recognized', () => {
+      process.env.METAMASK_ENVIRONMENT = 'unknown';
+      jest.isolateModules(() => {
+        const { createTokenSearchDiscoveryController: freshCreate } =
+          jest.requireActual('./utils');
+        const controller = freshCreate({
+          state: undefined,
+          messenger,
+        });
+        expect(controller.state).toBeDefined();
+      });
+    });
+  });
+});

app/core/Engine/controllers/TokenSearchDiscoveryController/utils.ts

@@ -0,0 +1,37 @@
+import Logger from '../../../../util/Logger';
+import {
+  TokenSearchApiService,
+  TokenSearchDiscoveryController,
+} from '@metamask/token-search-discovery-controller';
+import { TokenSearchDiscoveryControllerParams } from './types';
+import { PORTFOLIO_API_URL } from './constants';
+
+const getPortfolioApiBaseUrl = () => {
+  const env = process.env.METAMASK_ENVIRONMENT;
+  switch (env) {
+    case 'local':
+      return PORTFOLIO_API_URL.dev;
+    case 'pre-release':
+    case 'production':
+      return PORTFOLIO_API_URL.prod;
+    default:
+      return PORTFOLIO_API_URL.dev;
+  }
+};
+
+export const createTokenSearchDiscoveryController = ({
+  state,
+  messenger,
+}: TokenSearchDiscoveryControllerParams) => {
+  try {
+    const controller = new TokenSearchDiscoveryController({
+      state,
+      messenger,
+      tokenSearchService: new TokenSearchApiService(getPortfolioApiBaseUrl()),
+    });
+    return controller;
+  } catch (error) {
+    Logger.error(error as Error);
+    throw error;
+  }
+};

app/core/Engine/types.ts

@@ -170,6 +170,10 @@ import {
   RemoteFeatureFlagControllerActions,
   RemoteFeatureFlagControllerEvents,
 } from '@metamask/remote-feature-flag-controller/dist/remote-feature-flag-controller.cjs';
+import {
+  TokenSearchDiscoveryController,
+  TokenSearchDiscoveryControllerState,
+} from '@metamask/token-search-discovery-controller';
 
 /**
  * Controllers that area always instantiated
@@ -323,6 +327,7 @@ export type Controllers = {
   TokenListController: TokenListController;
   TokenDetectionController: TokenDetectionController;
   TokenRatesController: TokenRatesController;
+  TokenSearchDiscoveryController: TokenSearchDiscoveryController;
   TokensController: TokensController;
   TransactionController: TransactionController;
   SmartTransactionsController: SmartTransactionsController;
@@ -363,6 +368,7 @@ export type EngineState = {
   PhishingController: PhishingControllerState;
   TokenBalancesController: TokenBalancesControllerState;
   TokenRatesController: TokenRatesControllerState;
+  TokenSearchDiscoveryController: TokenSearchDiscoveryControllerState;
   TransactionController: TransactionControllerState;
   SmartTransactionsController: SmartTransactionsControllerState;
   SwapsController: SwapsControllerState;