@lifi/widget 4.7.1 → 4.9.0

package/src/hooks/useRouteExecution.ts

@@ -43,7 +43,7 @@ export const useRouteExecution = ({
   const queryClient = useQueryClient()
   const { account } = useAccount()
   const resumedAfterMount = useRef(false)
-  const { keyPrefix } = useWidgetConfig()
+  const { storageScopeKey } = useWidgetConfig()
   const sdkClient = useSDKClient()
   const emitter = useWidgetEvents()
   const routeExecutionStoreContext = useRouteExecutionStoreContext()
@@ -84,16 +84,16 @@ export const useRouteExecution = ({
     if (executionCompleted || executionFailed) {
       const invalidateKeys = [
         [
-          getQueryKey('token-balances', keyPrefix),
+          getQueryKey('token-balances', storageScopeKey),
           clonedUpdatedRoute.fromAddress,
           clonedUpdatedRoute.fromChainId,
         ],
         [
-          getQueryKey('token-balances', keyPrefix),
+          getQueryKey('token-balances', storageScopeKey),
           clonedUpdatedRoute.toAddress,
           clonedUpdatedRoute.toChainId,
         ],
-        [getQueryKey('transaction-history', keyPrefix)],
+        [getQueryKey('transaction-history', storageScopeKey)],
       ]
       for (const key of invalidateKeys) {
         queryClient.invalidateQueries(
@@ -133,7 +133,7 @@ export const useRouteExecution = ({
         throw new Error('Execution route not found.')
       }
       queryClient.removeQueries({
-        queryKey: [getQueryKey('routes', keyPrefix)],
+        queryKey: [getQueryKey('routes', storageScopeKey)],
         exact: false,
       })
       return executeRoute(sdkClient, routeExecution.route, {

package/src/hooks/useRoutes.ts

@@ -9,10 +9,7 @@ import {
   parseUnits,
 } from '@lifi/sdk'
 import { useAccount } from '@lifi/wallet-management'
-import {
-  useChainTypeFromAddress,
-  useEthereumContext,
-} from '@lifi/widget-provider'
+import { useAddressForChain, useEthereumContext } from '@lifi/widget-provider'
 import {
   keepPreviousData,
   useQuery,
@@ -29,7 +26,11 @@ import { defaultSlippage } from '../stores/settings/createSettingsStore.js'
 import { useSettings } from '../stores/settings/useSettings.js'
 import { WidgetEvent } from '../types/events.js'
 import type { TokensByChain } from '../types/token.js'
-import { isCustomReceiverBlocked } from '../utils/customReceiver.js'
+import {
+  canQuoteWithToAddress,
+  isCustomReceiverBlocked,
+  isSignerInvalidReceiver,
+} from '../utils/customReceiver.js'
 import { getQueryKey } from '../utils/queries.js'
 import { updateTokenInCache } from '../utils/token.js'
 import { useChain } from './useChain.js'
@@ -82,7 +83,7 @@ export const useRoutes = ({
     exchanges,
     feeConfig,
     useRelayerRoutes,
-    keyPrefix,
+    storageScopeKey,
   } = useWidgetConfig()
   const sdkClient = useSDKClient()
   const setExecutableRoute = useSetExecutableRoute()
@@ -138,7 +139,7 @@ export const useRoutes = ({
   const { chain: toChain } = useChain(toChainId)
   const { enabled: enabledRefuel, fromAmount: gasRecommendationFromAmount } =
     useGasRefuel()
-  const { getChainTypeFromAddress } = useChainTypeFromAddress()
+  const { isAddressForChain } = useAddressForChain()
   const { isGaslessStep, disableMessageSigning } = useEthereumContext()
   const { account } = useAccount({ chainType: fromChain?.chainType })
   const { isBatchingSupported, isBatchingSupportedLoading } =
@@ -165,18 +166,22 @@ export const useRoutes = ({
     ? Boolean(account.address)
     : mode !== 'custom' || customType === 'deposit'
 
-  const effectiveFromAddress = account.address ?? quoteFromAddress
+  // Quote as if disconnected while the signer would be taken as the receiver.
+  const effectiveFromAddress = isSignerInvalidReceiver({
+    signerAddress: account.address,
+    toAddress,
+    fromChain,
+    toChain,
+    isAddressForChain,
+  })
+    ? quoteFromAddress
+    : (account.address ?? quoteFromAddress)
 
-  // When we bridge between ecosystems we need to be sure toAddress is set and has the same chainType as toChain
-  // If toAddress is set, it must have the same chainType as toChain
-  const hasToAddressAndChainTypeSatisfied: boolean =
-    !!toChain &&
-    !!toAddress &&
-    getChainTypeFromAddress(toAddress) === toChain.chainType
-  // We need to check for toAddress only if it is set
-  const isToAddressSatisfied = toAddress
-    ? hasToAddressAndChainTypeSatisfied
-    : true
+  const isToAddressSatisfied = canQuoteWithToAddress(
+    toAddress,
+    toChain,
+    isAddressForChain
+  )
 
   // Not `effectiveFromAddress`: a quote placeholder must never match a receiver.
   const customReceiverBlocked = isCustomReceiverBlocked({
@@ -214,7 +219,7 @@ export const useRoutes = ({
   const queryKey = useMemo(
     () =>
       [
-        getQueryKey('routes', keyPrefix),
+        getQueryKey('routes', storageScopeKey),
         effectiveFromAddress,
         fromChain?.id as number,
         fromToken?.address as string,
@@ -244,7 +249,7 @@ export const useRoutes = ({
         observableRoute?.id,
       ] as const,
     [
-      keyPrefix,
+      storageScopeKey,
       effectiveFromAddress,
       fromChain?.id,
       fromToken?.address,
@@ -550,14 +555,14 @@ export const useRoutes = ({
         ;[fromToken, toToken].forEach((token) => {
           // Update main tokens cache (verified)
           queryClient.setQueriesData<TokensByChain>(
-            { queryKey: [getQueryKey('tokens', keyPrefix)] },
+            { queryKey: [getQueryKey('tokens', storageScopeKey)] },
             (data) => updateTokenInCache(data, token)
           )
 
           // Update search tokens cache (unverified) - matches any search query
           queryClient.setQueriesData<TokensByChain>(
             {
-              queryKey: [getQueryKey('tokens-search', keyPrefix)],
+              queryKey: [getQueryKey('tokens-search', storageScopeKey)],
               exact: false,
             },
             (data) => updateTokenInCache(data, token)
@@ -566,7 +571,7 @@ export const useRoutes = ({
           queryClient.setQueriesData<Token[]>(
             {
               queryKey: [
-                getQueryKey('token-balances', keyPrefix),
+                getQueryKey('token-balances', storageScopeKey),
                 fromAddress,
                 token.chainId,
               ],

package/src/hooks/useToAddressAutoPopulate.ts

@@ -1,5 +1,5 @@
 import { useAccount } from '@lifi/wallet-management'
-import { useChainTypeFromAddress } from '@lifi/widget-provider'
+import { useAddressForChain } from '@lifi/widget-provider'
 import { useCallback } from 'react'
 import { useBookmarkActions } from '../stores/bookmarks/useBookmarkActions.js'
 import type { FormType } from '../stores/form/types.js'
@@ -24,7 +24,7 @@ export const useToAddressAutoPopulate = (): ((
   const { setSelectedBookmark } = useBookmarkActions()
   const { getChainById } = useAvailableChains()
   const { accounts } = useAccount()
-  const { getChainTypeFromAddress } = useChainTypeFromAddress()
+  const { isAddressForChain } = useAddressForChain()
 
   return useCallback(
     ({
@@ -52,22 +52,18 @@ export const useToAddressAutoPopulate = (): ((
       ) {
         return
       }
-      // Identify the destination chain type based on the bridge direction ('from' or 'to')
-      const destinationChainType =
-        formType === 'from'
-          ? selectedOppositeChain.chainType
-          : selectedChain.chainType
-      // If toAddress is already selected, verify that it matches the destination chain type
-      if (selectedToAddress) {
-        const selectedToAddressChainType =
-          getChainTypeFromAddress(selectedToAddress)
-        if (destinationChainType === selectedToAddressChainType) {
-          return
-        }
+      const destinationChain =
+        formType === 'from' ? selectedOppositeChain : selectedChain
+      if (
+        selectedToAddress &&
+        isAddressForChain(selectedToAddress, destinationChain)
+      ) {
+        return
       }
-      // Find connected account compatible with the destination chain type
       const destinationAccount = accounts?.find(
-        (account) => account.chainType === destinationChainType
+        (account) =>
+          account.address &&
+          isAddressForChain(account.address, destinationChain)
       )
       // If a compatible destination account is found, set toAddress as if selecting it from the "Send to Wallet" connected wallets page
       if (destinationAccount?.address) {
@@ -89,7 +85,7 @@ export const useToAddressAutoPopulate = (): ((
       getChainById,
       setFieldValue,
       setSelectedBookmark,
-      getChainTypeFromAddress,
+      isAddressForChain,
     ]
   )
 }

package/src/hooks/useToAddressRequirements.ts

@@ -1,6 +1,6 @@
-import type { ChainType, RouteExtended } from '@lifi/sdk'
+import type { RouteExtended } from '@lifi/sdk'
 import { useAccount } from '@lifi/wallet-management'
-import { useEthereumContext } from '@lifi/widget-provider'
+import { useAddressForChain, useEthereumContext } from '@lifi/widget-provider'
 import { useChain } from '../hooks/useChain.js'
 import { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'
 import { useFieldValues } from '../stores/form/useFieldValues.js'
@@ -16,7 +16,8 @@ export const useToAddressRequirements = (
   requiredToAddress: boolean
   unsupportedToAddress: boolean
   unsupportedReceiverBlocking: boolean
-  requiredToChainType: ChainType | undefined
+  /** Whether a saved or connected address can receive on the destination chain. */
+  isValidReceiver: (address?: string) => boolean
   accountNotDeployedAtDestination: boolean
   accountDeployedAtDestination: boolean
   toAddress: string | undefined
@@ -32,6 +33,7 @@ export const useToAddressRequirements = (
     'toAddress'
   )
   const { isDelegationDesignatorCode } = useEthereumContext()
+  const { isAddressForChain } = useAddressForChain()
 
   const fromChainId = route?.fromChainId ?? formFromChainId
   const toChainId = route?.toChainId ?? formToChainId
@@ -87,14 +89,27 @@ export const useToAddressRequirements = (
     receiverRequired: requiredUI?.toAddress,
   })
 
+  // A shared chain type is not a shared format: a Bitcoin signer cannot receive on ZEC.
+  const isSignerAddressInvalidAtDestination = Boolean(
+    fromAddress &&
+      fromChain &&
+      toChain &&
+      isAddressForChain(fromAddress, fromChain) &&
+      !isAddressForChain(fromAddress, toChain)
+  )
+
   const requiredToAddress = Boolean(
     (isDifferentChainType ||
       isCrossChainContractAddress ||
+      isSignerAddressInvalidAtDestination ||
       requiredUI?.toAddress) &&
       !hiddenUI?.toAddress &&
       !unsupportedToAddress
   )
 
+  const isValidReceiver = (address?: string): boolean =>
+    !toChain || (!!address && isAddressForChain(address, toChain))
+
   const accountNotDeployedAtDestination = Boolean(
     isFromContractAddress &&
       !fromContractCodeHasDelegationIndicator &&
@@ -113,7 +128,7 @@ export const useToAddressRequirements = (
     requiredToAddress,
     unsupportedToAddress,
     unsupportedReceiverBlocking,
-    requiredToChainType: toChain?.chainType,
+    isValidReceiver,
     accountNotDeployedAtDestination,
     accountDeployedAtDestination,
     toAddress,

package/src/hooks/useToAddressReset.ts

@@ -1,4 +1,5 @@
 import type { ExtendedChain } from '@lifi/sdk'
+import { useAddressForChain } from '@lifi/widget-provider'
 import { useCallback } from 'react'
 import { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'
 import { useBookmarkActions } from '../stores/bookmarks/useBookmarkActions.js'
@@ -12,16 +13,18 @@ export const useToAddressReset = (): {
   const { setFieldValue } = useFieldActions()
   const { selectedBookmark } = useBookmarks()
   const { setSelectedBookmark } = useBookmarkActions()
+  const { isAddressForChain } = useAddressForChain()
 
   const tryResetToAddress = useCallback(
     (toChain: ExtendedChain) => {
       const requiredToAddress = requiredUI?.toAddress
 
-      const bookmarkSatisfiesToChainType =
-        selectedBookmark?.chainType === toChain?.chainType
+      const bookmarkSatisfiesToChain = Boolean(
+        selectedBookmark && isAddressForChain(selectedBookmark.address, toChain)
+      )
 
       const shouldResetToAddress =
-        !requiredToAddress && !bookmarkSatisfiesToChainType
+        !requiredToAddress && !bookmarkSatisfiesToChain
 
       // We reset toAddress on each chain change if it's no longer required, ensuring that
       // switching chain types doesn't leave a stale toAddress from a different ecosystem.
@@ -30,7 +33,13 @@ export const useToAddressReset = (): {
         setSelectedBookmark()
       }
     },
-    [setFieldValue, setSelectedBookmark, requiredUI, selectedBookmark]
+    [
+      setFieldValue,
+      setSelectedBookmark,
+      requiredUI,
+      selectedBookmark,
+      isAddressForChain,
+    ]
   )
 
   return {

package/src/hooks/useTokenBalance.ts

@@ -8,6 +8,7 @@ import { useQuery, useQueryClient } from '@tanstack/react-query'
 import { useCallback, useMemo } from 'react'
 import { useSDKClient } from '../providers/SDKClientProvider.js'
 import { useWidgetConfig } from '../providers/WidgetProvider/WidgetProvider.js'
+import { isDestinationOnlyChain } from '../utils/chainType.js'
 import { getQueryKey } from '../utils/queries.js'
 
 const defaultRefetchInterval = 30_000
@@ -23,18 +24,18 @@ export const useTokenBalance = (
   getTokenBalancesWithRetry: typeof getTokenBalancesWithRetry
 } => {
   const queryClient = useQueryClient()
-  const { keyPrefix } = useWidgetConfig()
+  const { storageScopeKey } = useWidgetConfig()
   const sdkClient = useSDKClient()
 
   const tokenBalanceQueryKey = useMemo(
     () =>
       [
-        getQueryKey('token-balance', keyPrefix),
+        getQueryKey('token-balance', storageScopeKey),
         accountAddress,
         token?.chainId,
         token?.address,
       ] as const,
-    [token?.address, token?.chainId, accountAddress, keyPrefix]
+    [token?.address, token?.chainId, accountAddress, storageScopeKey]
   )
 
   const { data, isLoading, refetch } = useQuery({
@@ -67,7 +68,7 @@ export const useTokenBalance = (
       queryClient.setQueriesData<TokenAmount[]>(
         {
           queryKey: [
-            getQueryKey('token-balances', keyPrefix),
+            getQueryKey('token-balances', storageScopeKey),
             accountAddress,
             tokenChainId,
           ],
@@ -93,7 +94,11 @@ export const useTokenBalance = (
       } as TokenAmount
     },
 
-    enabled: Boolean(accountAddress && token),
+    // No provider reads a balance on a destination-only chain, and a balance
+    // without a block number is retried until the backoff gives up.
+    enabled:
+      Boolean(accountAddress && token) &&
+      !isDestinationOnlyChain(token?.chainId),
     refetchInterval: defaultRefetchInterval,
     staleTime: defaultRefetchInterval,
   })

package/src/hooks/useTokenBalancesQueries.ts

@@ -20,7 +20,7 @@ export const useTokenBalancesQueries = (
   isLoading: boolean
   isError: boolean
 } => {
-  const { keyPrefix } = useWidgetConfig()
+  const { storageScopeKey } = useWidgetConfig()
   const sdkClient = useSDKClient()
   const firstLoadStartRef = useRef<number | null>(null)
 
@@ -34,7 +34,7 @@ export const useTokenBalancesQueries = (
           const chainId = Number(chainIdStr)
           return {
             queryKey: [
-              getQueryKey('token-balances', keyPrefix),
+              getQueryKey('token-balances', storageScopeKey),
               accountAddress,
               chainId,
               tokens.length,
@@ -55,7 +55,7 @@ export const useTokenBalancesQueries = (
           }
         })
     )
-  }, [accountsWithTokens, isBalanceLoadingEnabled, keyPrefix, sdkClient])
+  }, [accountsWithTokens, isBalanceLoadingEnabled, storageScopeKey, sdkClient])
 
   const result = useQueries({
     queries: queryConfig,

package/src/hooks/useTokenSearch.ts

@@ -18,11 +18,15 @@ export const useTokenSearch = (
   isLoading: boolean
 } => {
   const queryClient = useQueryClient()
-  const { tokens: configTokens, keyPrefix } = useWidgetConfig()
+  const { tokens: configTokens, storageScopeKey } = useWidgetConfig()
   const sdkClient = useSDKClient()
 
   const { data, isLoading } = useQuery({
-    queryKey: [getQueryKey('token-search', keyPrefix), chainId, tokenQuery],
+    queryKey: [
+      getQueryKey('token-search', storageScopeKey),
+      chainId,
+      tokenQuery,
+    ],
     queryFn: async ({ queryKey: [, chainId, tokenQuery], signal }) => {
       const token = await getToken(
         sdkClient,
@@ -52,7 +56,7 @@ export const useTokenSearch = (
 
         // Add token to main tokens cache
         queryClient.setQueriesData<TokensByChain>(
-          { queryKey: [getQueryKey('tokens', keyPrefix)] },
+          { queryKey: [getQueryKey('tokens', storageScopeKey)] },
           (data) => {
             if (!data) {
               return data

package/src/hooks/useTokens.ts

@@ -25,6 +25,14 @@ import { useAvailableChains } from './useAvailableChains.js'
 
 const refetchInterval = 300_000
 
+// The main list and the search send the same list parameters.
+const tokenListParams = {
+  orderBy: 'volumeUSD24H',
+  extended: true,
+  limit: 1100,
+  minPriceUSD: 0.000001,
+} as const
+
 export const useTokens = (
   formType?: FormType,
   search?: string,
@@ -39,7 +47,7 @@ export const useTokens = (
   const {
     tokens: configTokens,
     chains: chainsConfig,
-    keyPrefix,
+    storageScopeKey,
   } = useWidgetConfig()
   const sdkClient = useSDKClient()
   const { getChainTypeFromTokenAddress } = useChainTypeFromAddress()
@@ -55,7 +63,7 @@ export const useTokens = (
 
   // Main tokens cache - verified tokens from API
   const { data: verifiedTokens, isLoading } = useQuery({
-    queryKey: [getQueryKey('tokens', keyPrefix)],
+    queryKey: [getQueryKey('tokens', storageScopeKey)],
     queryFn: async ({ signal }) => {
       const chainTypes = [
         ChainType.EVM,
@@ -68,13 +76,7 @@ export const useTokens = (
 
       const tokensResponse: TokensExtendedResponse = await getTokens(
         sdkClient,
-        {
-          chainTypes,
-          orderBy: 'volumeUSD24H',
-          extended: true,
-          limit: 1000,
-          minPriceUSD: 0.000001,
-        },
+        { ...tokenListParams, chainTypes },
         { signal }
       )
 
@@ -95,7 +97,7 @@ export const useTokens = (
   // Search tokens cache - unverified tokens from search
   const { data: searchTokens, isLoading: isSearchLoading } = useQuery({
     queryKey: [
-      getQueryKey('tokens-search', keyPrefix),
+      getQueryKey('tokens-search', storageScopeKey),
       trimmedSearch,
       chainId,
       isAddressSearch,
@@ -114,12 +116,9 @@ export const useTokens = (
       const tokensResponse: TokensExtendedResponse = await getTokens(
         sdkClient,
         {
+          ...tokenListParams,
           chainTypes,
-          orderBy: 'volumeUSD24H',
-          extended: true,
           search: searchQuery,
-          limit: 1000,
-          minPriceUSD: 0.000001,
         },
         { signal }
       )

package/src/hooks/useTools.sharedEntry.test.tsx

@@ -0,0 +1,155 @@
+/** @vitest-environment happy-dom */
+
+import type * as LifiSdk from '@lifi/sdk'
+import type { SDKClient, ToolsResponse } from '@lifi/sdk'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { WidgetConfig } from '../types/widget.js'
+
+/**
+ * The tools entry is shared with the host app through
+ * `getToolsQueryOptions`, keyed by the client's API base and the widget's
+ * `queryScopeKey`. When the host fetched first, the widget must read that entry
+ * — no request of its own — and still seed its settings store from the
+ * filtered view.
+ */
+
+const API_URL = 'https://api.example/v1'
+
+const mocks = vi.hoisted(() => ({
+  getTools: vi.fn(),
+  initializeTools: vi.fn(),
+}))
+
+vi.mock('@lifi/sdk', async (importOriginal) => ({
+  ...(await importOriginal<typeof LifiSdk>()),
+  getTools: mocks.getTools,
+}))
+
+let widgetConfig: Partial<WidgetConfig> = {}
+
+vi.mock('../providers/WidgetProvider/WidgetProvider.js', () => ({
+  useWidgetConfig: () => widgetConfig,
+}))
+
+const client = { config: { apiUrl: API_URL } } as unknown as SDKClient
+vi.mock('../providers/SDKClientProvider.js', () => ({
+  useSDKClient: () => client,
+}))
+
+const settingsStore = {
+  getState: () => ({ initializeTools: mocks.initializeTools }),
+}
+vi.mock('../stores/settings/SettingsStore.js', () => ({
+  useSettingsStoreContext: () => settingsStore,
+}))
+
+import { getToolsQueryKey } from '../queries/getTools.js'
+import { useTools } from './useTools.js'
+
+const TOOLS = {
+  bridges: [{ key: 'across' }, { key: 'stargate' }, { key: 'hop' }],
+  exchanges: [{ key: '1inch' }, { key: 'paraswap' }],
+} as unknown as ToolsResponse
+
+const Probe = () => {
+  useTools()
+  return null
+}
+
+let root: Root
+let queryClient: QueryClient
+
+const render = async () => {
+  await act(async () => {
+    root.render(
+      <QueryClientProvider client={queryClient}>
+        <Probe />
+      </QueryClientProvider>
+    )
+  })
+}
+
+describe('useTools with a shared tools entry', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.getTools.mockResolvedValue(TOOLS)
+    widgetConfig = {
+      integrator: 'test',
+      queryScopeKey: 'host',
+      bridges: { allow: ['across', 'hop'] },
+      exchanges: { deny: ['paraswap'] },
+    }
+    queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    })
+    const container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+  })
+
+  afterEach(async () => {
+    await act(async () => root.unmount())
+    queryClient.clear()
+  })
+
+  it('initialises the settings store when the host already fetched the tools', async () => {
+    // The host app fetched first and filled the shared entry.
+    queryClient.setQueryData(
+      getToolsQueryKey({ apiUrl: API_URL, scopeKey: 'host' }),
+      TOOLS
+    )
+
+    await render()
+
+    await vi.waitFor(() => {
+      expect(mocks.initializeTools).toHaveBeenCalledWith('Bridges', [
+        'across',
+        'hop',
+      ])
+    })
+    expect(mocks.initializeTools).toHaveBeenCalledWith('Exchanges', ['1inch'])
+    // The widget read the host's entry instead of sending its own request.
+    expect(mocks.getTools).not.toHaveBeenCalled()
+  })
+
+  it('initialises the settings store when the widget fetched the tools itself', async () => {
+    await render()
+
+    await vi.waitFor(() => {
+      expect(mocks.initializeTools).toHaveBeenCalledWith('Bridges', [
+        'across',
+        'hop',
+      ])
+    })
+    expect(mocks.getTools).toHaveBeenCalledTimes(1)
+  })
+
+  it('initialises with the filtered view while the cache keeps the raw list', async () => {
+    await render()
+
+    await vi.waitFor(() => {
+      expect(mocks.initializeTools).toHaveBeenCalled()
+    })
+    const cached = queryClient.getQueryData<ToolsResponse>(
+      getToolsQueryKey({ apiUrl: API_URL, scopeKey: 'host' })
+    )
+    expect(cached?.bridges).toHaveLength(3)
+    expect(cached?.exchanges).toHaveLength(2)
+  })
+
+  it('refreshes the tools every three minutes', async () => {
+    await render()
+    await vi.waitFor(() => {
+      expect(mocks.initializeTools).toHaveBeenCalled()
+    })
+
+    const [observer] = queryClient.getQueryCache().find({
+      queryKey: getToolsQueryKey({ apiUrl: API_URL, scopeKey: 'host' }),
+    })!.observers
+    expect(observer.options.refetchInterval).toBe(180_000)
+    expect(observer.options.staleTime).toBe(180_000)
+  })
+})