feat: add tokens search discovery controller

.github/CODEOWNERS

@@ -71,6 +71,10 @@ e2e/specs/identity @MetaMask/identity
 ses.cjs                              @MetaMask/supply-chain
 patches/react-native+0.*.patch       @MetaMask/supply-chain
 
+# Portfolio Team
+app/components/hooks/useTokenSearchDiscovery @MetaMask/portfolio
+app/core/Engine/controllers/TokenSearchDiscoveryController @MetaMask/portfolio
+
 # Snaps Team
 **/snaps/**                          @MetaMask/snaps-devs
 **/Snaps/**                          @MetaMask/snaps-devs

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

@@ -0,0 +1,82 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import Engine from '../../../core/Engine';
+import useTokenSearchDiscovery from './useTokenSearchDiscovery';
+import { TokenSearchParams } from '@metamask/token-search-discovery-controller';
+
+jest.mock('react-redux', () => ({
+  ...jest.requireActual('react-redux'),
+  useSelector: jest.fn(),
+}));
+
+jest.mock('../../../core/Engine', () => ({
+  context: {
+    TokenSearchDiscoveryController: {
+      searchTokens: jest.fn(),
+    },
+  },
+}));
+
+describe('useTokenSearchDiscovery', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('updates states correctly when searching tokens', async () => {
+    const mockSearchParams: TokenSearchParams = {
+      chains: ['0x1'],
+      query: 'DAI',
+      limit: '10',
+    };
+    const mockSearchResult = [{ name: 'DAI', address: '0x123' }];
+
+    (
+      Engine.context.TokenSearchDiscoveryController.searchTokens as jest.Mock
+    ).mockResolvedValueOnce(mockSearchResult);
+
+    const { result } = renderHook(() => useTokenSearchDiscovery());
+
+    // Initial state
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBe(null);
+    expect(result.current.results).toEqual([]);
+
+    // Call search
+    await act(async () => {
+      result.current.searchTokens(mockSearchParams);
+      jest.advanceTimersByTime(300);
+      await Promise.resolve();
+    });
+
+    // Final state
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBe(null);
+    expect(result.current.results).toEqual(mockSearchResult);
+    expect(
+      Engine.context.TokenSearchDiscoveryController.searchTokens,
+    ).toHaveBeenCalledWith(mockSearchParams);
+  });
+
+  it('returns error and empty results if search failed', async () => {
+    const mockError = new Error('Search failed');
+    (
+      Engine.context.TokenSearchDiscoveryController.searchTokens as jest.Mock
+    ).mockRejectedValueOnce(mockError);
+
+    const { result } = renderHook(() => useTokenSearchDiscovery());
+
+    await act(async () => {
+      result.current.searchTokens({});
+      jest.advanceTimersByTime(300);
+      await Promise.resolve();
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toEqual(mockError);
+    expect(result.current.results).toEqual([]);
+  });
+});

app/components/hooks/useTokenSearchDiscovery/useTokenSearchDiscovery.ts

@@ -0,0 +1,57 @@
+import { useState, useRef, useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import { debounce } from 'lodash';
+import Engine from '../../../core/Engine';
+import { selectRecentTokenSearches } from '../../../selectors/tokenSearchDiscoveryController';
+import {
+  TokenSearchResponseItem,
+  TokenSearchParams,
+} from '@metamask/token-search-discovery-controller';
+
+const SEARCH_DEBOUNCE_DELAY = 300;
+
+export const useTokenSearchDiscovery = () => {
+  const recentSearches = useSelector(selectRecentTokenSearches);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [results, setResults] = useState<TokenSearchResponseItem[]>([]);
+  const latestRequestId = useRef<number>(0);
+
+  const searchTokens = useMemo(
+    () =>
+      debounce(async (params: TokenSearchParams) => {
+        setIsLoading(true);
+        setError(null);
+        const requestId = ++latestRequestId.current;
+
+        try {
+          const { TokenSearchDiscoveryController } = Engine.context;
+          const result = await TokenSearchDiscoveryController.searchTokens(
+            params,
+          );
+          if (requestId === latestRequestId.current) {
+            setResults(result);
+          }
+        } catch (err) {
+          if (requestId === latestRequestId.current) {
+            setError(err as Error);
+          }
+        } finally {
+          if (requestId === latestRequestId.current) {
+            setIsLoading(false);
+          }
+        }
+      }, SEARCH_DEBOUNCE_DELAY),
+    [],
+  );
+
+  return {
+    searchTokens,
+    recentSearches,
+    isLoading,
+    error,
+    results,
+  };
+};
+
+export default useTokenSearchDiscovery;

app/core/Engine/Engine.ts

@@ -223,6 +223,7 @@ import {
   getGlobalNetworkClientId,
 } from '../../util/networks/global-network';
 import { logEngineCreation } from './utils/logger';
+import { createTokenSearchDiscoveryController } from './controllers/TokenSearchDiscoveryController';
 import {
   SnapControllerClearSnapStateAction,
   SnapControllerGetSnapAction,
@@ -572,6 +573,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',
@@ -1499,6 +1511,7 @@ export class Engine {
         isDecodeSignatureRequestEnabled: () =>
           preferencesController.state.useTransactionSimulations,
       }),
+      TokenSearchDiscoveryController: tokenSearchDiscoveryController,
       LoggingController: loggingController,
       ///: BEGIN:ONLY_INCLUDE_IF(preinstalled-snaps,external-snaps)
       SnapController: this.snapController,
@@ -2147,6 +2160,7 @@ export default {
       PPOMController,
       TokenBalancesController,
       TokenRatesController,
+      TokenSearchDiscoveryController,
       TransactionController,
       SmartTransactionsController,
       SwapsController,
@@ -2186,6 +2200,7 @@ export default {
       PreferencesController,
       TokenBalancesController,
       TokenRatesController,
+      TokenSearchDiscoveryController,
       TokensController,
       TransactionController,
       SmartTransactionsController,

app/core/Engine/constants.ts

@@ -41,6 +41,7 @@ export const BACKGROUND_STATE_CHANGE_EVENT_NAMES = [
   'TokenListController:stateChange',
   'TokenRatesController:stateChange',
   'TokensController:stateChange',
+  'TokenSearchDiscoveryController:stateChange',
   'TransactionController:stateChange',
   ///: BEGIN:ONLY_INCLUDE_IF(preinstalled-snaps,external-snaps)
   SnapControllerStateChangeEvent,

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;
+}