Update discover search to v3 endpoint

src/__swaps__/screens/Swap/resources/search/search.ts

@@ -4,10 +4,14 @@ import { SearchAsset, TokenSearchAssetKey, TokenSearchListId, TokenSearchThresho
 import { RainbowError, logger } from '@/logger';
 import { RainbowFetchClient } from '@/rainbow-fetch';
 import { QueryConfigWithSelect, QueryFunctionArgs, QueryFunctionResult, createQueryKey, queryClient } from '@/react-query';
-import { isAddress } from '@ethersproject/address';
+import { getAddress, isAddress } from '@ethersproject/address';
+import { getUniqueId } from '@/utils/ethereumUtils';
+import { Contract } from '@ethersproject/contracts';
 import { useQuery } from '@tanstack/react-query';
 import qs from 'qs';
-import { parseTokenSearch } from './utils';
+import { parseTokenSearch, parseTokenSearchAcrossNetworks } from './utils';
+import { getProvider } from '@/handlers/web3';
+import { erc20ABI } from '@/references';
 
 const ALL_VERIFIED_TOKENS_PARAM = '/?list=verifiedAssets';
 
@@ -27,12 +31,16 @@ export type TokenSearchArgs = {
   chainId?: ChainId;
   fromChainId?: ChainId | '';
   keys?: TokenSearchAssetKey[];
-  list: TokenSearchListId;
+  list?: TokenSearchListId;
   threshold?: TokenSearchThreshold;
   query?: string;
   shouldPersist?: boolean;
 };
 
+export type TokenSearchAllNetworksArgs = {
+  query: string;
+};
+
 // ///////////////////////////////////////////////
 // Query Key
 
@@ -44,17 +52,64 @@ const tokenSearchQueryKey = ({ chainId, fromChainId, keys, list, threshold, quer
   );
 };
 
+const tokenSearchAllNetworksQueryKey = ({ query }: TokenSearchAllNetworksArgs) => {
+  const shouldPersist = query === '';
+  return createQueryKey('TokenSearchAllNetworks', { query }, { persisterVersion: shouldPersist ? 1 : undefined });
+};
+
 type TokenSearchQueryKey = ReturnType<typeof tokenSearchQueryKey>;
 
+type TokenSearchAllNetworksQueryKey = ReturnType<typeof tokenSearchAllNetworksQueryKey>;
+
 // ///////////////////////////////////////////////
 // Query Function
+const getImportedAsset = async (searchQuery: string, chainId: number = ChainId.mainnet): Promise<SearchAsset[]> => {
+  if (isAddress(searchQuery)) {
+    const provider = getProvider({ chainId });
+    const tokenContract = new Contract(searchQuery, erc20ABI, provider);
+    try {
+      const [name, symbol, decimals, address] = await Promise.all([
+        tokenContract.name(),
+        tokenContract.symbol(),
+        tokenContract.decimals(),
+        getAddress(searchQuery),
+      ]);
+      const uniqueId = getUniqueId(address, chainId);
+
+      return [
+        {
+          chainId,
+          address,
+          decimals,
+          highLiquidity: false,
+          isRainbowCurated: false,
+          isVerified: false,
+          mainnetAddress: address,
+          name,
+          networks: {
+            [chainId]: {
+              address,
+              decimals,
+            },
+          },
+          symbol,
+          uniqueId,
+        } as SearchAsset,
+      ];
+    } catch (e) {
+      logger.warn('[getImportedAsset]: error getting imported token data', { error: (e as Error).message });
+      return [];
+    }
+  }
+  return [];
+};
 
 async function tokenSearchQueryFunction({
   queryKey: [{ chainId, fromChainId, keys, list, threshold, query }],
 }: QueryFunctionArgs<typeof tokenSearchQueryKey>) {
   const queryParams: {
     keys?: string;
-    list: TokenSearchListId;
+    list?: TokenSearchListId;
     threshold?: TokenSearchThreshold;
     query?: string;
     fromChainId?: number | string;
@@ -73,7 +128,7 @@ async function tokenSearchQueryFunction({
   }
 
   const url = `${chainId ? `/${chainId}` : ''}/?${qs.stringify(queryParams)}`;
-  const isSearchingVerifiedAssets = queryParams.list === 'verifiedAssets';
+  const isSearchingVerifiedAssets = (queryParams.list && queryParams.list === 'verifiedAssets') || !queryParams.list;
 
   try {
     if (isAddressSearch && isSearchingVerifiedAssets) {
@@ -102,6 +157,43 @@ async function tokenSearchQueryFunction({
   }
 }
 
+async function tokenSearchQueryFunctionAllNetworks({ queryKey: [{ query }] }: QueryFunctionArgs<typeof tokenSearchAllNetworksQueryKey>) {
+  const queryParams: {
+    list?: string;
+    query?: string;
+  } = {
+    query,
+  };
+
+  const isAddressSearch = query && isAddress(query);
+
+  const searchDefaultMainnetVerifiedList = query === '';
+  if (searchDefaultMainnetVerifiedList) {
+    queryParams.list = 'verifiedAssets';
+  }
+
+  const url = `${searchDefaultMainnetVerifiedList ? `/${ChainId.mainnet}` : ''}/?${qs.stringify(queryParams)}`;
+
+  try {
+    if (isAddressSearch) {
+      const tokenSearch = await tokenSearchHttp.get<{ data: SearchAsset[] }>(url);
+
+      if (tokenSearch && tokenSearch.data.data.length > 0) {
+        return parseTokenSearch(tokenSearch.data.data);
+      }
+
+      const result = await getImportedAsset(query);
+      return result;
+    } else {
+      const tokenSearch = await tokenSearchHttp.get<{ data: SearchAsset[] }>(url);
+      return parseTokenSearchAcrossNetworks(tokenSearch.data.data);
+    }
+  } catch (e) {
+    logger.error(new RainbowError('[tokenSearchQueryFunction]: Token search failed'), { url });
+    return [];
+  }
+}
+
 export type TokenSearchResult = QueryFunctionResult<typeof tokenSearchQueryFunction>;
 
 // ///////////////////////////////////////////////
@@ -144,3 +236,13 @@ export function useTokenSearch(
     keepPreviousData: true,
   });
 }
+
+export function useTokenSearchAllNetworks(
+  { query }: TokenSearchAllNetworksArgs,
+  config: QueryConfigWithSelect<TokenSearchResult, Error, TokenSearchResult, TokenSearchAllNetworksQueryKey> = {}
+) {
+  return useQuery(tokenSearchAllNetworksQueryKey({ query }), tokenSearchQueryFunctionAllNetworks, {
+    ...config,
+    keepPreviousData: true,
+  });
+}

src/__swaps__/screens/Swap/resources/search/utils.ts

@@ -1,3 +1,4 @@
+import { uniqBy } from 'lodash';
 import { ChainId } from '@/state/backendNetworks/types';
 import { SearchAsset } from '@/__swaps__/types/search';
 import { Address } from 'viem';
@@ -49,3 +50,30 @@ export function parseTokenSearch(assets: SearchAsset[], chainId?: ChainId): Sear
 
   return results;
 }
+
+export function parseTokenSearchAcrossNetworks(assets: SearchAsset[]): SearchAsset[] {
+  const results = assets.map(asset => {
+    const assetNetworks = asset.networks;
+    const networkKeys = Object.keys(assetNetworks);
+    const firstNetworkChainId = Number(networkKeys[0] || asset.chainId);
+
+    const mainnetInfo = assetNetworks[ChainId.mainnet];
+    const firstNetworkInfo = assetNetworks[firstNetworkChainId];
+    const chainId = mainnetInfo ? ChainId.mainnet : firstNetworkChainId;
+    const address = mainnetInfo ? mainnetInfo.address : firstNetworkInfo?.address || asset.address;
+    const decimals = mainnetInfo ? mainnetInfo.decimals : firstNetworkInfo?.decimals || asset.decimals;
+    const uniqueId = `${address}_${chainId}`;
+
+    return {
+      ...asset,
+      address,
+      chainId,
+      decimals,
+      isNativeAsset: isNativeAsset(address, chainId),
+      mainnetAddress: mainnetInfo ? mainnetInfo.address : chainId === ChainId.mainnet ? address : ('' as Address),
+      uniqueId,
+    };
+  });
+  const uniqRes = uniqBy(results, 'address');
+  return uniqRes;
+}

src/__swaps__/types/search.ts

@@ -10,6 +10,14 @@ export type TokenSearchThreshold = 'CONTAINS' | 'CASE_SENSITIVE_EQUAL';
 
 export type TokenSearchListId = 'highLiquidityAssets' | 'lowLiquidityAssets' | 'verifiedAssets';
 
+interface Market {
+  market_cap: {
+    value: number;
+  };
+  volume_24h: number;
+  circulating_supply: number;
+}
+
 export type SearchAsset = {
   address: AddressOrEth;
   chainId: ChainId;
@@ -22,6 +30,7 @@ export type SearchAsset = {
   isNativeAsset?: boolean;
   isVerified: boolean;
   mainnetAddress: AddressOrEth;
+  market?: Market;
   name: string;
   networks: {
     [chainId in ChainId]?: {

src/components/Discover/DiscoverSearch.tsx

@@ -72,7 +72,7 @@ export default function DiscoverSearch() {
   const lastSearchQuery = usePrevious(searchQueryForSearch);
 
   const [ensResults, setEnsResults] = useState<EnsSearchResult[]>([]);
-  const { swapCurrencyList, swapCurrencyListLoading } = useSearchCurrencyList(searchQueryForSearch, ChainId.mainnet);
+  const { swapCurrencyList, swapCurrencyListLoading } = useSearchCurrencyList(searchQueryForSearch);
 
   const profilesEnabled = useExperimentalFlag(PROFILES);
   const marginBottom = TAB_BAR_HEIGHT + safeAreaInsetValues.bottom + 16;
@@ -83,7 +83,7 @@ export default function DiscoverSearch() {
     // 1. favorites
     // 2. verified
     // 3. profiles
-    // 4. unverified
+    // 4. unverified high liquidity
     // 5. low liquidity
     let list = swapCurrencyList;
     const listKeys = swapCurrencyList.map(item => item.key);

src/components/expanded-state/asset/ChartExpandedState.js

@@ -168,7 +168,7 @@ export default function ChartExpandedState({ asset }) {
             chainId: asset.chainId,
             network: asset.network,
             address: asset.address,
-            mainnetAddress: asset?.networks?.[useBackendNetworksStore.getState().getChainsName()[ChainId.mainnet]]?.address,
+            mainnetAddress: asset?.networks?.[ChainId.mainnet]?.address,
           }
         : asset;
   }, [asset, genericAsset, hasBalance]);