@lifi/widget 3.0.0-alpha.21 → 3.0.0-alpha.23

package/hooks/useTokens.ts

@@ -4,7 +4,6 @@ import { useMemo } from 'react';
 import { useWidgetConfig } from '../providers';
 import type { TokenAmount } from '../types';
 import { useChains } from './useChains';
-import { useFeaturedTokens } from './useFeaturedTokens';
 
 export const useTokens = (selectedChainId?: number) => {
   const { tokens: configTokens } = useWidgetConfig();
@@ -18,10 +17,9 @@ export const useTokens = (selectedChainId?: number) => {
     isLoading: isSupportedChainsLoading,
     getChainById,
   } = useChains();
-  const featuredTokens = useFeaturedTokens(selectedChainId);
 
   const filteredData = useMemo(() => {
-    if (isSupportedChainsLoading) {
+    if (isSupportedChainsLoading || !data) {
       return;
     }
     const chain = getChainById(selectedChainId, chains);
@@ -29,55 +27,84 @@ export const useTokens = (selectedChainId?: number) => {
     if (!chainAllowed) {
       return;
     }
-    let filteredTokens = data?.tokens[selectedChainId];
+    let filteredTokens = data.tokens?.[selectedChainId] || [];
     const includedTokens = configTokens?.include?.filter(
       (token) => token.chainId === selectedChainId,
     );
     if (includedTokens?.length) {
-      filteredTokens = filteredTokens
-        ? [...includedTokens, ...filteredTokens]
-        : includedTokens;
+      filteredTokens = [...includedTokens, ...filteredTokens];
     }
-    const allowedTokens = configTokens?.allow
-      ?.filter((token) => token.chainId === selectedChainId)
-      .map((token) => token.address);
-    if (allowedTokens?.length) {
-      filteredTokens = filteredTokens?.filter((token) =>
-        allowedTokens.includes(token.address),
+
+    if (configTokens?.allow?.length || configTokens?.deny?.length) {
+      const allowedTokensSet = new Set(
+        configTokens?.allow
+          ?.filter((token) => token.chainId === selectedChainId)
+          .map((token) => token.address),
       );
-    }
-    const deniedTokenAddresses = configTokens?.deny
-      ?.filter((token) => token.chainId === selectedChainId)
-      .map((token) => token.address);
-    if (deniedTokenAddresses?.length) {
-      filteredTokens = filteredTokens?.filter(
-        (token) => !deniedTokenAddresses.includes(token.address),
+
+      const deniedTokenAddressesSet = new Set(
+        configTokens?.deny
+          ?.filter((token) => token.chainId === selectedChainId)
+          .map((token) => token.address),
       );
+
+      if (allowedTokensSet.size || deniedTokenAddressesSet.size) {
+        filteredTokens = filteredTokens.filter(
+          (token) =>
+            (!allowedTokensSet.size || allowedTokensSet.has(token.address)) &&
+            !deniedTokenAddressesSet.has(token.address),
+        );
+      }
     }
-    const featuredTokenAddresses = new Set(
-      featuredTokens?.map((token) => token.address),
+    const filteredTokensMap = new Map(
+      filteredTokens.map((token) => [token.address, token]),
     );
-    const tokens = [
-      ...(featuredTokens?.map((token) => {
-        (token as TokenAmount).featured = true;
+
+    const [popularTokens, featuredTokens] = (
+      ['popular', 'featured'] as ('popular' | 'featured')[]
+    ).map((tokenType) => {
+      const typedConfigTokens = configTokens?.[tokenType]?.filter(
+        (token) => token.chainId === selectedChainId,
+      );
+
+      const populatedConfigTokens = typedConfigTokens?.map((token) => {
+        // Mark token as popular
+        (token as TokenAmount)[tokenType] = true;
+        // Check if this token exists in the filteredTokensMap and add priceUSD if it does
+        const matchingFilteredToken = filteredTokensMap.get(token.address);
+        if (matchingFilteredToken?.priceUSD) {
+          (token as TokenAmount).priceUSD = matchingFilteredToken.priceUSD;
+        }
+        if (!token.logoURI && matchingFilteredToken) {
+          (token as TokenAmount).logoURI = matchingFilteredToken.logoURI;
+        }
         return token;
-      }) ?? []),
-      ...(filteredTokens?.filter(
-        (token) => !featuredTokenAddresses.has(token.address),
-      ) ?? []),
-    ] as TokenAmount[];
+      }) as TokenAmount[];
+
+      if (populatedConfigTokens?.length) {
+        const configTokenAddresses = new Set(
+          populatedConfigTokens?.map((token) => token.address),
+        );
+        filteredTokens = filteredTokens.filter(
+          (token) => !configTokenAddresses.has(token.address),
+        );
+        populatedConfigTokens.push(...filteredTokens);
+        filteredTokens = populatedConfigTokens;
+      }
+
+      return populatedConfigTokens;
+    });
 
     return {
-      tokens,
+      tokens: filteredTokens,
+      featuredTokens,
+      popularTokens,
       chain,
     };
   }, [
     chains,
-    configTokens?.allow,
-    configTokens?.deny,
-    configTokens?.include,
-    data?.tokens,
-    featuredTokens,
+    configTokens,
+    data,
     getChainById,
     isSupportedChainsLoading,
     selectedChainId,
@@ -85,6 +112,8 @@ export const useTokens = (selectedChainId?: number) => {
 
   return {
     tokens: filteredData?.tokens,
+    featuredTokens: filteredData?.featuredTokens,
+    popularTokens: filteredData?.popularTokens,
     chain: filteredData?.chain,
     isLoading,
   };

package/i18n/en.json

@@ -174,6 +174,7 @@
     "deselectAll": "Deselect all"
   },
   "main": {
+    "allTokens": "All tokens",
     "crossStepDetails": "Bridge from {{from}} to {{to}} via {{tool}}",
     "currentAmount": "Current amount",
     "featuredTokens": "Featured tokens",
@@ -189,10 +190,11 @@
     "fromAmount": "You pay",
     "gasCost": "Gas cost",
     "inProgress": "in progress",
+    "myTokens": "My tokens",
     "nftStepDetails": "Purchase NFT via {{tool}}",
     "onChain": "on {{chainName}}",
-    "otherTokens": "Other tokens",
     "ownedBy": "Owned by",
+    "popularTokens": "Popular tokens",
     "process": {
       "crossChain": {
         "actionRequired": "Please sign the transaction",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/widget",
-  "version": "3.0.0-alpha.21",
+  "version": "3.0.0-alpha.23",
   "description": "LI.FI Widget for cross-chain bridging and swapping. It will drive your multi-chain strategy and attract new users from everywhere.",
   "type": "module",
   "main": "./_cjs/index.js",
@@ -35,8 +35,8 @@
   "dependencies": {
     "@emotion/react": "^11.11.3",
     "@emotion/styled": "^11.11.0",
-    "@lifi/sdk": "^3.0.0-alpha.53",
-    "@lifi/wallet-management": "^3.0.0-alpha.14",
+    "@lifi/sdk": "^3.0.0-alpha.54",
+    "@lifi/wallet-management": "^3.0.0-alpha.15",
     "@mui/icons-material": "^5.15.7",
     "@mui/lab": "^5.0.0-alpha.163",
     "@mui/material": "^5.15.7",
@@ -44,19 +44,19 @@
     "@solana/wallet-adapter-react": "^0.15.35",
     "@solana/wallet-adapter-wallets": "^0.19.26",
     "@solana/web3.js": "^1.89.1",
-    "@tanstack/react-query": "^5.18.0",
-    "@tanstack/react-virtual": "^3.0.2",
+    "@tanstack/react-query": "^5.18.1",
+    "@tanstack/react-virtual": "^3.0.4",
     "i18next": "^23.8.2",
     "microdiff": "^1.3.2",
     "mitt": "^3.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-i18next": "^14.0.1",
-    "react-intersection-observer": "^9.6.0",
-    "react-router-dom": "^6.21.3",
+    "react-i18next": "^14.0.3",
+    "react-intersection-observer": "^9.7.0",
+    "react-router-dom": "^6.22.0",
     "react-timer-hook": "^3.0.7",
     "uuid": "^9.0.1",
-    "viem": "^2.7.1",
+    "viem": "^2.7.6",
     "wagmi": "^2.5.5",
     "zustand": "^4.5.0"
   },

package/pages/RoutesPage/RoutesPage.tsx

@@ -63,7 +63,7 @@ export const RoutesPage: React.FC<BoxProps> = () => {
       ) : (
         routes?.map((route: Route, index: number) => (
           <RouteCard
-            key={route.id}
+            key={index}
             route={route}
             onClick={() => handleRouteClick(route)}
             active={index === 0}

package/pages/SelectEnabledToolsPage/SelectEnabledToolsPage.tsx

@@ -55,52 +55,33 @@ export const SelectEnabledToolsPage: React.FC<{
 }> = ({ type }) => {
   const typeKey = type.toLowerCase() as 'bridges' | 'exchanges';
   const { tools } = useTools();
-  const [enabledTools, setTools] = useSettingsStore(
-    (state) => [state[`enabled${type}`], state.setTools],
-    shallow,
-  );
+  const [enabledTools, disabledTools, setToolValue, toggleTools] =
+    useSettingsStore(
+      (state) => [
+        state[`enabled${type}`],
+        state[`disabled${type}`],
+        state.setToolValue,
+        state.toggleTools,
+      ],
+      shallow,
+    );
   const headerStoreContext = useHeaderStoreContext();
 
   const handleClick = (key: string) => {
-    if (!tools) {
-      return;
-    }
-    const toolKeys = tools[typeKey].map((tool) => tool.key);
-    if (enabledTools?.includes(key)) {
-      setTools(
-        type,
-        enabledTools.filter((toolKey) => toolKey !== key),
-        toolKeys,
-      );
-    } else {
-      setTools(type, [...enabledTools, key], toolKeys);
-    }
+    setToolValue(type, key, !enabledTools[key]);
   };
 
   useEffect(() => {
-    const allToolsSelected = tools?.[typeKey].length === enabledTools.length;
-    const toggleCheckboxes = () => {
-      if (!tools) {
-        return;
-      }
-      const toolKeys = tools[typeKey].map((tool) => tool.key);
-      if (allToolsSelected) {
-        setTools(type, [], toolKeys);
-      } else {
-        setTools(type, toolKeys, toolKeys);
-      }
-    };
-
     return headerStoreContext
       .getState()
       .setAction(
         <SelectAllCheckbox
-          allCheckboxesSelected={allToolsSelected}
-          anyCheckboxesSelected={!!enabledTools.length}
-          onClick={toggleCheckboxes}
+          allCheckboxesSelected={!disabledTools.length}
+          anyCheckboxesSelected={Boolean(disabledTools.length)}
+          onClick={() => toggleTools(type)}
         />,
       );
-  }, [enabledTools.length, headerStoreContext, setTools, tools, type, typeKey]);
+  }, [disabledTools.length, headerStoreContext, toggleTools, type]);
 
   return (
     <PageContainer disableGutters>
@@ -121,7 +102,7 @@ export const SelectEnabledToolsPage: React.FC<{
               </Avatar>
             </ListItemAvatar>
             <ListItemText primary={tool.name} />
-            {enabledTools?.includes(tool.key) && <CheckIcon color="primary" />}
+            {enabledTools[tool.key] && <CheckIcon color="primary" />}
           </SettingsListItemButton>
         ))}
       </List>

package/pages/SettingsPage/BridgeAndExchangeSettings.tsx

@@ -3,10 +3,10 @@ import SwapHorizIcon from '@mui/icons-material/SwapHoriz';
 import { useTranslation } from 'react-i18next';
 import { useNavigate } from 'react-router-dom';
 import { shallow } from 'zustand/shallow';
+import { CardButton } from '../../components/Card';
 import { useSettingMonitor } from '../../hooks';
 import { useSettingsStore } from '../../stores';
 import { navigationRoutes } from '../../utils';
-import { CardButton } from '../../components/Card';
 import { BadgedValue } from './SettingsCard';
 
 const supportedIcons = {
@@ -21,7 +21,7 @@ export const BridgeAndExchangeSettings: React.FC<{
   const { t } = useTranslation();
   const navigate = useNavigate();
   const [enabledTools, tools] = useSettingsStore((state) => {
-    const enabledTools = Object.values(state[`_enabled${type}`] ?? {});
+    const enabledTools = Object.values(state[`enabled${type}`]);
     return [enabledTools.filter(Boolean).length, enabledTools.length];
   }, shallow);
 

package/stores/form/createFormStore.ts

@@ -7,7 +7,6 @@ import type {
   FormValueControl,
   FormValues,
   FormValuesState,
-  GenericFormValue,
 } from './types';
 
 export const formDefaultValues: DefaultValues = {
@@ -21,9 +20,7 @@ export const formDefaultValues: DefaultValues = {
   toAmount: '',
 };
 
-const defaultValueToFormValue = (
-  value: GenericFormValue,
-): FormValueControl<GenericFormValue> => ({
+const defaultValueToFormValue = <T>(value: T): FormValueControl<T> => ({
   isTouched: false,
   isDirty: false,
   value,
@@ -31,22 +28,25 @@ const defaultValueToFormValue = (
 
 const valuesToFormValues = (defaultValues: DefaultValues): FormValues => {
   return (Object.keys(defaultValues) as FormFieldNames[]).reduce(
-    (accum, key) => {
-      return { ...accum, [key]: defaultValueToFormValue(defaultValues[key]) };
-    },
-    {},
-  ) as FormValues;
+    (accum, key) => ({
+      ...accum,
+      [key]: defaultValueToFormValue(defaultValues[key]),
+    }),
+    {} as FormValues,
+  );
 };
 
 const isString = (str: any) => typeof str === 'string' || str instanceof String;
 
 const getUpdatedTouchedFields = (userValues: FormValues) => {
-  return Object.keys(userValues).reduce(
-    (accum, key) =>
-      userValues[key as FormFieldNames]?.isTouched
-        ? { ...accum, [key]: true }
-        : accum,
-    {},
+  return (Object.keys(userValues) as FormFieldNames[]).reduce(
+    (accum, key) => {
+      if (userValues[key]?.isTouched) {
+        accum[key] = true;
+      }
+      return accum;
+    },
+    {} as Record<FormFieldNames, boolean>,
   );
 };
 

package/stores/form/types.ts

@@ -23,20 +23,9 @@ export interface FormValueControl<T> {
   value: T;
 }
 
-export interface FormValues {
-  contractOutputsToken: FormValueControl<string>;
-  fromAmount: FormValueControl<string>;
-  fromChain?: FormValueControl<number | undefined>;
-  fromToken?: FormValueControl<string | undefined>;
-  toAddress: FormValueControl<string>;
-  toAmount: FormValueControl<string>;
-  toChain?: FormValueControl<number | undefined>;
-  toContractAddress: FormValueControl<string>;
-  toContractCallData: FormValueControl<string>;
-  toContractGasLimit: FormValueControl<string>;
-  toToken?: FormValueControl<string | undefined>;
-  tokenSearchFilter: FormValueControl<string>;
-}
+export type FormValues = {
+  [Property in keyof DefaultValues]: FormValueControl<DefaultValues[Property]>;
+};
 
 export type FormFieldNames = keyof FormValues;
 export type ExtractValueType<T> =

package/stores/settings/types.ts

@@ -2,7 +2,7 @@ import type { Order } from '@lifi/sdk';
 import type { PropsWithChildren } from 'react';
 import type { StoreApi } from 'zustand';
 import type { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
-import type { Appearance, WidgetConfig } from '../../types';
+import type { Appearance } from '../../types';
 
 export type ValueSetter<S> = <K extends keyof S>(
   key: K,
@@ -13,8 +13,8 @@ export type ValuesSetter<S> = <K extends keyof S>(
   values: Record<K, S[Extract<K, string>]>,
 ) => void;
 
-export type SettingsToolType = 'Bridges' | 'Exchanges';
-export const SettingsToolTypes: SettingsToolType[] = ['Bridges', 'Exchanges'];
+export const SettingsToolTypes = ['Bridges', 'Exchanges'] as const;
+export type SettingsToolType = (typeof SettingsToolTypes)[number];
 
 export interface SettingsProps {
   appearance: Appearance;
@@ -24,10 +24,10 @@ export interface SettingsProps {
   enabledAutoRefuel: boolean;
   showDestinationWallet: boolean;
   slippage?: string;
-  enabledBridges: string[];
-  _enabledBridges?: Record<string, boolean>;
-  enabledExchanges: string[];
-  _enabledExchanges?: Record<string, boolean>;
+  disabledBridges: string[];
+  enabledBridges: Record<string, boolean>;
+  disabledExchanges: string[];
+  enabledExchanges: Record<string, boolean>;
 }
 
 export interface SettingsState extends SettingsProps {
@@ -38,12 +38,9 @@ export interface SettingsState extends SettingsProps {
     tools: string[],
     reset?: boolean,
   ): void;
-  setTools(
-    toolType: SettingsToolType,
-    tools: string[],
-    availableTools: string[],
-  ): void;
-  reset(config: WidgetConfig, bridges: string[], exchanges: string[]): void;
+  setToolValue(toolType: SettingsToolType, tool: string, value: boolean): void;
+  toggleTools(toolType: SettingsToolType): void;
+  reset(bridges: string[], exchanges: string[]): void;
 }
 
 export interface SendToWalletState {

package/stores/settings/useSettingsStore.ts

@@ -21,8 +21,10 @@ export const defaultSettings: SettingsProps = {
   gasPrice: 'normal',
   enabledAutoRefuel: true,
   showDestinationWallet: true,
-  enabledBridges: [],
-  enabledExchanges: [],
+  disabledBridges: [],
+  disabledExchanges: [],
+  enabledBridges: {},
+  enabledExchanges: {},
 };
 
 export const useSettingsStore = createWithEqualityFn<SettingsState>(
@@ -49,60 +51,57 @@ export const useSettingsStore = createWithEqualityFn<SettingsState>(
         }
         set((state) => {
           const updatedState = { ...state };
-          if (updatedState[`_enabled${toolType}`] && !reset) {
+          if (!reset) {
             // Add new tools
-            const enabledTools = tools
-              .filter(
-                (tool) =>
-                  !Object.hasOwn(
-                    updatedState[`_enabled${toolType}`] as object,
-                    tool,
-                  ),
-              )
-              .reduce(
-                (values, tool) => {
-                  values[tool] = true;
-                  return values;
-                },
-                updatedState[`_enabled${toolType}`] as Record<string, boolean>,
-              );
+            tools.forEach((tool) => {
+              if (!Object.hasOwn(updatedState[`enabled${toolType}`], tool)) {
+                updatedState[`enabled${toolType}`][tool] = true;
+              }
+            });
             // Filter tools we no longer have
-            updatedState[`_enabled${toolType}`] = Object.fromEntries(
-              Object.entries(enabledTools).filter(([key]) =>
-                tools.includes(key),
+            updatedState[`enabled${toolType}`] = Object.fromEntries(
+              Object.entries(updatedState[`enabled${toolType}`]).filter(
+                ([key]) => tools.includes(key),
               ),
             );
           } else {
-            updatedState[`_enabled${toolType}`] = tools.reduce(
-              (values, tool) => {
-                values[tool] = true;
-                return values;
-              },
-              {} as Record<string, boolean>,
-            );
+            tools.forEach((tool) => {
+              updatedState[`enabled${toolType}`][tool] = true;
+            });
           }
-          updatedState[`enabled${toolType}`] = Object.entries(
-            updatedState[`_enabled${toolType}`]!,
-          )
-            .filter(([_, value]) => value)
-            .map(([key]) => key);
+          updatedState[`disabled${toolType}`] = Object.keys(
+            updatedState[`enabled${toolType}`],
+          ).filter((key) => !updatedState[`enabled${toolType}`][key]);
           return updatedState;
         });
       },
-      setTools: (toolType, tools, availableTools) =>
-        set(() => ({
-          [`enabled${toolType}`]: tools,
-          [`_enabled${toolType}`]: availableTools.reduce(
-            (values, toolKey) => {
-              values[toolKey] = tools.includes(toolKey);
-              return values;
-            },
-            {} as Record<string, boolean>,
-          ),
-        })),
-      reset: (config, bridges, exchanges) => {
+      setToolValue: (toolType, tool, value) =>
+        set((state) => {
+          const enabledTools = {
+            ...state[`enabled${toolType}`],
+            [tool]: value,
+          };
+          return {
+            [`enabled${toolType}`]: enabledTools,
+            [`disabled${toolType}`]: Object.keys(enabledTools).filter(
+              (key) => !enabledTools[key],
+            ),
+          };
+        }),
+      toggleTools: (toolType) =>
+        set((state) => {
+          const enabledTools = { ...state[`enabled${toolType}`] };
+          const enableAll = Boolean(state[`disabled${toolType}`].length);
+          for (const toolKey in enabledTools) {
+            enabledTools[toolKey] = enableAll;
+          }
+          return {
+            [`enabled${toolType}`]: enabledTools,
+            [`disabled${toolType}`]: enableAll ? [] : Object.keys(enabledTools),
+          };
+        }),
+      reset: (bridges, exchanges) => {
         const { appearance, ...restDefaultSettings } = defaultSettings;
-
         set(() => ({
           ...restDefaultSettings,
           ...defaultConfigurableSettings,
@@ -113,19 +112,18 @@ export const useSettingsStore = createWithEqualityFn<SettingsState>(
     }),
     {
       name: `li.fi-widget-settings`,
-      version: 2,
+      version: 3,
       partialize: (state) => {
-        const { enabledBridges, enabledExchanges, ...partializedState } = state;
+        const { disabledBridges, disabledExchanges, ...partializedState } =
+          state;
         return partializedState;
       },
       merge: (persistedState: any, currentState: SettingsState) => {
         const state = { ...currentState, ...persistedState };
         SettingsToolTypes.forEach((toolType) => {
-          state[`enabled${toolType}`] = Object.entries(
-            persistedState[`_enabled${toolType}`],
-          )
-            .filter(([_, value]) => value)
-            .map(([key]) => key);
+          state[`disabled${toolType}`] = Object.keys(
+            persistedState[`enabled${toolType}`],
+          ).filter((key) => !persistedState[`enabled${toolType}`][key]);
         });
         return state;
       },

package/types/token.ts

@@ -2,4 +2,5 @@ import type { TokenAmount as SDKTokenAmount } from '@lifi/sdk';
 
 export interface TokenAmount extends SDKTokenAmount {
   featured?: boolean;
+  popular?: boolean;
 }

package/types/widget.ts

@@ -160,6 +160,7 @@ export interface WidgetConfig {
   tokens?: {
     featured?: StaticToken[];
     include?: Token[];
+    popular?: StaticToken[];
   } & AllowDeny<BaseToken>;
   languages?: {
     default?: LanguageKey;
@@ -167,15 +168,6 @@ export interface WidgetConfig {
   languageResources?: LanguageResources;
 }
 
-export type WidgetDrawerProps = {
-  elementRef?: RefObject<HTMLDivElement>;
-  open?: boolean;
-  /**
-   * Make sure to make the onClose callback stable (e.g. using useCallback) to avoid causing re-renders of the entire widget
-   */
-  onClose?(): void;
-};
-
 export interface WidgetConfigProps {
   config: WidgetConfig;
 }
@@ -187,3 +179,12 @@ export interface WidgetConfigPartialProps {
 export type WidgetProps = WidgetDrawerProps &
   WidgetConfig &
   WidgetConfigPartialProps;
+
+export interface WidgetDrawerProps extends WidgetConfigPartialProps {
+  elementRef?: RefObject<HTMLDivElement>;
+  open?: boolean;
+  /**
+   * Make sure to make the onClose callback stable (e.g. using useCallback) to avoid causing re-renders of the entire widget
+   */
+  onClose?(): void;
+}

package/_cjs/hooks/useFeaturedTokens.d.ts

@@ -1 +0,0 @@
-export declare const useFeaturedTokens: (selectedChainId?: number) => import("@lifi/types").StaticToken[] | undefined;

package/_cjs/hooks/useFeaturedTokens.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFeaturedTokens = void 0;
-const react_1 = require("react");
-const providers_1 = require("../providers");
-const useFeaturedTokens = (selectedChainId) => {
-    const { tokens } = (0, providers_1.useWidgetConfig)();
-    return (0, react_1.useMemo)(() => tokens?.featured?.filter((token) => token.chainId === selectedChainId), [selectedChainId, tokens?.featured]);
-};
-exports.useFeaturedTokens = useFeaturedTokens;
-//# sourceMappingURL=useFeaturedTokens.js.map

package/_cjs/hooks/useFeaturedTokens.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFeaturedTokens.js","sourceRoot":"","sources":["../../hooks/useFeaturedTokens.ts"],"names":[],"mappings":";;;AAAA,iCAAgC;AAChC,4CAA+C;AAExC,MAAM,iBAAiB,GAAG,CAAC,eAAwB,EAAE,EAAE;IAC5D,MAAM,EAAE,MAAM,EAAE,GAAG,IAAA,2BAAe,GAAE,CAAC;IAErC,OAAO,IAAA,eAAO,EACZ,GAAG,EAAE,CACH,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,eAAe,CAAC,EACxE,CAAC,eAAe,EAAE,MAAM,EAAE,QAAQ,CAAC,CACpC,CAAC;AACJ,CAAC,CAAC;AARW,QAAA,iBAAiB,qBAQ5B"}

package/_esm/hooks/useFeaturedTokens.d.ts

@@ -1 +0,0 @@
-export declare const useFeaturedTokens: (selectedChainId?: number) => import("@lifi/types").StaticToken[] | undefined;