feat: upgrade assets controllers to version 43

app/components/UI/Tokens/index.tsx

@@ -41,6 +41,7 @@ import {
 import ButtonBase from '../../../component-library/components/Buttons/Button/foundation/ButtonBase';
 import { selectNetworkName } from '../../../selectors/networkInfos';
 import ButtonIcon from '../../../component-library/components/Buttons/ButtonIcon';
+import { Hex } from '@metamask/utils';
 
 // this will be imported from TokenRatesController when it is exported from there
 // PR: https://github.com/MetaMask/core/pull/4622
@@ -180,7 +181,11 @@ const Tokens: React.FC<TokensI> = ({ tokens }) => {
         TokenRatesController,
       } = Engine.context;
       const actions = [
-        TokenDetectionController.detectTokens(),
+        TokenDetectionController.detectTokens({
+          chainIds: isPortfolioViewEnabled
+            ? Object.keys(networkConfigurationsByChainId) as Hex[]
+            : [chainId]
+        }),
         AccountTrackerController.refresh(),
         CurrencyRateController.updateExchangeRate(nativeCurrencies),
         ...(isPortfolioViewEnabled

app/components/hooks/AssetPolling/AssetPollingProvider.tsx

@@ -1,13 +1,17 @@
 import React, { ReactNode } from 'react';
 import useCurrencyRatePolling from './useCurrencyRatePolling';
 import useTokenRatesPolling from './useTokenRatesPolling';
+import useTokenDetectionPolling from './useTokenDetectionPolling';
+import useTokenListPolling from './useTokenListPolling';
 
 // This provider is a step towards making controller polling fully UI based.
 // Eventually, individual UI components will call the use*Polling hooks to
 // poll and return particular data. This polls globally in the meantime.
 export const AssetPollingProvider = ({ children }: { children: ReactNode }) => {
   useCurrencyRatePolling();
   useTokenRatesPolling();
+  useTokenDetectionPolling();
+  useTokenListPolling();
 
   return <>{children}</>;
 };

app/components/hooks/AssetPolling/useTokenDetectionPolling.test.ts

@@ -0,0 +1,92 @@
+import { renderHookWithProvider } from '../../../util/test/renderWithProvider';
+import Engine from '../../../core/Engine';
+import useTokenDetectionPolling from './useTokenDetectionPolling';
+
+jest.mock('../../../core/Engine', () => ({
+  context: {
+    TokenDetectionController: {
+      startPolling: jest.fn(),
+      stopPollingByPollingToken: jest.fn(),
+    },
+  },
+}));
+
+describe('useTokenDetectionPolling', () => {
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  const selectedAddress = '0x1234567890abcdef';
+  const selectedChainId = '0x1' as const;
+
+  const state = {
+    engine: {
+      backgroundState: {
+        AccountsController: {
+          internalAccounts: {
+            selectedAccount: '1',
+            accounts: {
+              '1': {
+                address: selectedAddress
+              }
+            },
+          },
+        },
+        PreferencesController: {
+          useTokenDetection: true,
+        },
+        NetworkController: {
+          selectedNetworkClientId: 'selectedNetworkClientId',
+          networkConfigurationsByChainId: {
+            [selectedChainId]: {
+              chainId: selectedChainId,
+              rpcEndpoints: [{
+                networkClientId: 'selectedNetworkClientId',
+              }]
+            },
+            '0x89': {},
+          },
+        },
+      },
+    },
+  };
+
+  it('Should poll by current chain ids/address, and stop polling on dismount', async () => {
+
+    const { unmount } = renderHookWithProvider(() => useTokenDetectionPolling(), {state});
+
+    const mockedTokenDetectionController = jest.mocked(Engine.context.TokenDetectionController);
+
+    expect(mockedTokenDetectionController.startPolling).toHaveBeenCalledTimes(1);
+    expect(
+      mockedTokenDetectionController.startPolling
+    ).toHaveBeenCalledWith({chainIds: [selectedChainId], address: selectedAddress});
+
+    expect(mockedTokenDetectionController.stopPollingByPollingToken).toHaveBeenCalledTimes(0);
+    unmount();
+    expect(mockedTokenDetectionController.stopPollingByPollingToken).toHaveBeenCalledTimes(1);
+
+  });
+
+  it('Should not poll when token detection is disabled', async () => {
+
+    renderHookWithProvider(() => useTokenDetectionPolling({chainIds: ['0x1']}), {state:{
+      ...state,
+      engine: {
+        ...state.engine,
+        backgroundState: {
+          ...state.engine.backgroundState,
+          PreferencesController: {
+            ...state.engine.backgroundState.PreferencesController,
+            useTokenDetection: false,
+          },
+        },
+      },
+    }});
+
+    const mockedTokenDetectionController = jest.mocked(Engine.context.TokenDetectionController);
+    expect(mockedTokenDetectionController.startPolling).toHaveBeenCalledTimes(0);
+    expect(mockedTokenDetectionController.stopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+});

app/components/hooks/AssetPolling/useTokenDetectionPolling.ts

@@ -0,0 +1,37 @@
+import { useSelector } from 'react-redux';
+import usePolling from '../usePolling';
+import Engine from '../../../core/Engine';
+import { selectChainId, selectNetworkConfigurations } from '../../../selectors/networkController';
+import { Hex } from '@metamask/utils';
+import { isPortfolioViewEnabled } from '../../../util/networks';
+import { selectSelectedInternalAccount } from '../../../selectors/accountsController';
+import { selectUseTokenDetection } from '../../../selectors/preferencesController';
+
+const useTokenDetectionPolling = ({ chainIds }: { chainIds?: Hex[] } = {}) => {
+
+  const networkConfigurations = useSelector(selectNetworkConfigurations);
+  const currentChainId = useSelector(selectChainId);
+  const selectedAccount = useSelector(selectSelectedInternalAccount);
+  const useTokenDetection = useSelector(selectUseTokenDetection);
+
+  const chainIdsToPoll = isPortfolioViewEnabled
+    ? (chainIds ?? Object.keys(networkConfigurations))
+    : [currentChainId];
+
+  const { TokenDetectionController } = Engine.context;
+
+  usePolling({
+    startPolling:
+      TokenDetectionController.startPolling.bind(TokenDetectionController),
+    stopPollingByPollingToken:
+      TokenDetectionController.stopPollingByPollingToken.bind(TokenDetectionController),
+    input: useTokenDetection ? [{
+      chainIds: chainIdsToPoll as Hex[],
+      address: selectedAccount?.address as Hex
+    }] : []
+  });
+
+  return { };
+};
+
+export default useTokenDetectionPolling;

app/components/hooks/AssetPolling/useTokenListPolling.test.ts

@@ -0,0 +1,55 @@
+import { renderHookWithProvider } from '../../../util/test/renderWithProvider';
+import Engine from '../../../core/Engine';
+import useTokenListPolling from './useTokenListPolling';
+
+jest.mock('../../../core/Engine', () => ({
+  context: {
+    TokenListController: {
+      startPolling: jest.fn(),
+      stopPollingByPollingToken: jest.fn(),
+    },
+  },
+}));
+
+describe('useTokenListPolling', () => {
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  const selectedChainId = '0x1' as const;
+  const state = {
+    engine: {
+      backgroundState: {
+        NetworkController: {
+          selectedNetworkClientId: 'selectedNetworkClientId',
+          networkConfigurationsByChainId: {
+            [selectedChainId]: {
+              chainId: selectedChainId,
+              rpcEndpoints: [{
+                networkClientId: 'selectedNetworkClientId',
+              }]
+            },
+            '0x89': {},
+          },
+        },
+      },
+    },
+  };
+
+  it('Should poll by selected chain id, and stop polling on dismount', async () => {
+
+    const { unmount } = renderHookWithProvider(() => useTokenListPolling(), {state});
+
+    const mockedTokenListController = jest.mocked(Engine.context.TokenListController);
+
+    expect(mockedTokenListController.startPolling).toHaveBeenCalledTimes(1);
+    expect(
+      mockedTokenListController.startPolling
+    ).toHaveBeenCalledWith({chainId: selectedChainId});
+
+    expect(mockedTokenListController.stopPollingByPollingToken).toHaveBeenCalledTimes(0);
+    unmount();
+    expect(mockedTokenListController.stopPollingByPollingToken).toHaveBeenCalledTimes(1);
+  });
+});

app/components/hooks/AssetPolling/useTokenListPolling.ts

@@ -0,0 +1,39 @@
+import { useSelector } from 'react-redux';
+import usePolling from '../usePolling';
+import Engine from '../../../core/Engine';
+import { selectChainId, selectNetworkConfigurations } from '../../../selectors/networkController';
+import { Hex } from '@metamask/utils';
+import { isPortfolioViewEnabled } from '../../../util/networks';
+import { selectERC20TokensByChain, selectTokenList } from '../../../selectors/tokenListController';
+
+const useTokenListPolling = ({ chainIds }: { chainIds?: Hex[] } = {}) => {
+
+  // Selectors to determine polling input
+  const networkConfigurations = useSelector(selectNetworkConfigurations);
+  const currentChainId = useSelector(selectChainId);
+
+  // Selectors returning state updated by the polling
+  const tokenList = useSelector(selectTokenList);
+  const tokenListByChain = useSelector(selectERC20TokensByChain);
+
+  const chainIdsToPoll = isPortfolioViewEnabled
+    ? (chainIds ?? Object.keys(networkConfigurations))
+    : [currentChainId];
+
+  const { TokenListController } = Engine.context;
+
+  usePolling({
+    startPolling:
+      TokenListController.startPolling.bind(TokenListController),
+    stopPollingByPollingToken:
+      TokenListController.stopPollingByPollingToken.bind(TokenListController),
+    input: chainIdsToPoll.map((chainId) => ({ chainId: chainId as Hex }))
+  });
+
+  return {
+    tokenList,
+    tokenListByChain,
+  };
+};
+
+export default useTokenListPolling;

app/core/Engine.ts

@@ -1545,6 +1545,7 @@ export class Engine {
           ),
         platform: 'mobile',
         useAccountsAPI: true,
+        disabled: false
       }),
 
       new NftDetectionController({
@@ -1908,13 +1909,9 @@ export class Engine {
 
   startPolling() {
     const {
-      TokenDetectionController,
-      TokenListController,
       TransactionController,
     } = this.context;
 
-    TokenListController.start();
-    TokenDetectionController.start();
     // leaving the reference of TransactionController here, rather than importing it from utils to avoid circular dependency
     TransactionController.startIncomingTransactionPolling();
   }

app/core/NotificationManager.js

@@ -238,7 +238,7 @@ class NotificationManager {
             pollPromises.push(
               ...[
                 TokenBalancesController.poll(),
-                TokenDetectionController.start(),
+                TokenDetectionController.detectTokens({ chainIds: [transactionMeta.chainId] }),
               ],
             );
             break;

package.json

@@ -140,7 +140,7 @@
     "@metamask/accounts-controller": "^18.2.1",
     "@metamask/address-book-controller": "^6.0.1",
     "@metamask/approval-controller": "^7.1.0",
-    "@metamask/assets-controllers": "^42.0.0",
+    "@metamask/assets-controllers": "^43.1.1",
     "@metamask/base-controller": "^7.0.1",
     "@metamask/composable-controller": "^3.0.0",
     "@metamask/controller-utils": "^11.3.0",