Define FlattenedBackgroundStateProxy to type metamask slice

MetaMask · MajorLift · Nov 6, 2024 · Nov 6, 2024 · Dec 6, 2024 · Nov 11, 2024
commit f1c8bf5a5d90701d8efd4946c641a0fe8dbfa17b
diff --git a/shared/types/background.ts b/shared/types/background.ts
@@ -164,8 +164,14 @@ import AppMetadataController, {
 } from '../../app/scripts/controllers/app-metadata';
 import { SwapsControllerState } from '../../app/scripts/controllers/swaps/swaps.types';
 
-import { BridgeControllerState as BridgeState } from './bridge';
-import { BridgeStatusControllerState as BridgeStatusState } from './bridge-status';
+import {
+  BridgeControllerState,
+  BridgeControllerState as BridgeState,
+} from './bridge';
+import {
+  BridgeStatusControllerState,
+  BridgeStatusControllerState as BridgeStatusState,
+} from './bridge-status';
 import {
   CustodyControllerState,
   InstitutionalFeaturesControllerState,
@@ -325,3 +331,207 @@ export type MemStoreControllersComposedState = Omit<
 export type BackgroundStateProxy = {
   isInitialized: boolean;
 } & MemStoreControllersComposedState;
+
+export type FlattenedBackgroundStateProxy = {
+  isInitialized: boolean;
+  internalAccounts: AccountsControllerState['internalAccounts'];
+  accounts: AccountTrackerControllerState['accounts'];
+  accountsByChainId: AccountTrackerControllerState['accountsByChainId'];
+  currentBlockGasLimit: AccountTrackerControllerState['currentBlockGasLimit'];
+  currentBlockGasLimitByChainId: AccountTrackerControllerState['currentBlockGasLimitByChainId'];
+  addressBook: AddressBookControllerState['addressBook'];
+  alertEnabledness: AlertControllerState['alertEnabledness'];
+  unconnectedAccountAlertShownOrigins: AlertControllerState['unconnectedAccountAlertShownOrigins'];
+  web3ShimUsageOrigins: AlertControllerState['web3ShimUsageOrigins'];
+  announcements: AnnouncementControllerState['announcements'];
+  isSignedIn: AuthenticationController.AuthenticationControllerState['isSignedIn'];
+  orderedNetworkList: NetworkOrderControllerState['orderedNetworkList'];
+  pinnedAccountList: AccountOrderControllerState['pinnedAccountList'];
+  hiddenAccountList: AccountOrderControllerState['hiddenAccountList'];
+  currentAppVersion: AppMetadataControllerState['currentAppVersion'];
+  currentMigrationVersion: AppMetadataControllerState['currentMigrationVersion'];
+  previousAppVersion: AppMetadataControllerState['previousAppVersion'];
+  previousMigrationVersion: AppMetadataControllerState['previousMigrationVersion'];
+  approvalFlows: ApprovalControllerState['approvalFlows'];
+  pendingApprovals: ApprovalControllerState['pendingApprovals'];
+  pendingApprovalCount: ApprovalControllerState['pendingApprovalCount'];
+  browserEnvironment: AppStateControllerState['browserEnvironment'];
+  connectedStatusPopoverHasBeenShown: AppStateControllerState['connectedStatusPopoverHasBeenShown'];
+  currentPopupId: AppStateControllerState['currentPopupId'];
+  onboardingDate: AppStateControllerState['onboardingDate'];
+  currentExtensionPopupId: AppStateControllerState['currentExtensionPopupId'];
+  defaultHomeActiveTabName: AppStateControllerState['defaultHomeActiveTabName'];
+  fullScreenGasPollTokens: AppStateControllerState['fullScreenGasPollTokens'];
+  hadAdvancedGasFeesSetPriorToMigration92_3: AppStateControllerState['hadAdvancedGasFeesSetPriorToMigration92_3'];
+  nftsDetectionNoticeDismissed: AppStateControllerState['nftsDetectionNoticeDismissed'];
+  nftsDropdownState: AppStateControllerState['nftsDropdownState'];
+  notificationGasPollTokens: AppStateControllerState['notificationGasPollTokens'];
+  outdatedBrowserWarningLastShown: AppStateControllerState['outdatedBrowserWarningLastShown'];
+  popupGasPollTokens: AppStateControllerState['popupGasPollTokens'];
+  qrHardware: AppStateControllerState['qrHardware'];
+  recoveryPhraseReminderHasBeenShown: AppStateControllerState['recoveryPhraseReminderHasBeenShown'];
+  recoveryPhraseReminderLastShown: AppStateControllerState['recoveryPhraseReminderLastShown'];
+  signatureSecurityAlertResponses: AppStateControllerState['signatureSecurityAlertResponses'];
+  showBetaHeader: AppStateControllerState['showBetaHeader'];
+  showPermissionsTour: AppStateControllerState['showPermissionsTour'];
+  showNetworkBanner: AppStateControllerState['showNetworkBanner'];
+  showAccountBanner: AppStateControllerState['showAccountBanner'];
+  switchedNetworkDetails: AppStateControllerState['switchedNetworkDetails'];
+  switchedNetworkNeverShowMessage: AppStateControllerState['switchedNetworkNeverShowMessage'];
+  showTestnetMessageInDropdown: AppStateControllerState['showTestnetMessageInDropdown'];
+  surveyLinkLastClickedOrClosed: AppStateControllerState['surveyLinkLastClickedOrClosed'];
+  snapsInstallPrivacyWarningShown: AppStateControllerState['snapsInstallPrivacyWarningShown'];
+  termsOfUseLastAgreed: AppStateControllerState['termsOfUseLastAgreed'];
+  timeoutMinutes: AppStateControllerState['timeoutMinutes'];
+  trezorModel: AppStateControllerState['trezorModel'];
+  newPrivacyPolicyToastClickedOrClosed: AppStateControllerState['newPrivacyPolicyToastClickedOrClosed'];
+  newPrivacyPolicyToastShownDate: AppStateControllerState['newPrivacyPolicyToastShownDate'];
+  balances: BalancesControllerState['balances'];
+  bridgeState: BridgeControllerState;
+  bridgeStatusState: BridgeStatusControllerState;
+  jobs: CronjobControllerState['jobs'];
+  currentCurrency: CurrencyRateState['currentCurrency'];
+  currencyRates: CurrencyRateState['currencyRates'];
+  unapprovedDecryptMsgs: DecryptMessageControllerState['unapprovedDecryptMsgs'];
+  unapprovedDecryptMsgCount: DecryptMessageControllerState['unapprovedDecryptMsgCount'];
+  unapprovedEncryptionPublicKeyMsgs: EncryptionPublicKeyControllerState['unapprovedEncryptionPublicKeyMsgs'];
+  unapprovedEncryptionPublicKeyMsgCount: EncryptionPublicKeyControllerState['unapprovedEncryptionPublicKeyMsgCount'];
+  ensResolutionsByAddress: EnsControllerState['ensResolutionsByAddress'];
+  ensEntries: EnsControllerState['ensEntries'];
+  estimatedGasFeeTimeBounds: GasFeeState['estimatedGasFeeTimeBounds'];
+  gasEstimateType: GasFeeState['gasEstimateType'];
+  gasFeeEstimates: GasFeeState['gasFeeEstimates'];
+  gasFeeEstimatesByChainId: GasFeeState['gasFeeEstimatesByChainId'];
+  nonRPCGasFeeApisDisabled: GasFeeState['nonRPCGasFeeApisDisabled'];
+  isUnlocked: KeyringControllerState['isUnlocked'];
+  keyrings: KeyringControllerState['keyrings'];
+  logs: LoggingControllerState['logs'];
+  subscriptionAccountsSeen: NotificationServicesController.NotificationServicesControllerState['subscriptionAccountsSeen'];
+  isMetamaskNotificationsFeatureSeen: NotificationServicesController.NotificationServicesControllerState['isMetamaskNotificationsFeatureSeen'];
+  isNotificationServicesEnabled: NotificationServicesController.NotificationServicesControllerState['isNotificationServicesEnabled'];
+  isFeatureAnnouncementsEnabled: NotificationServicesController.NotificationServicesControllerState['isFeatureAnnouncementsEnabled'];
+  metamaskNotificationsList: NotificationServicesController.NotificationServicesControllerState['metamaskNotificationsList'];
+  metamaskNotificationsReadList: NotificationServicesController.NotificationServicesControllerState['metamaskNotificationsReadList'];
+  isCheckingAccountsPresence: NotificationServicesController.NotificationServicesControllerState['isCheckingAccountsPresence'];
+  isFetchingMetamaskNotifications: NotificationServicesController.NotificationServicesControllerState['isFetchingMetamaskNotifications'];
+  isUpdatingMetamaskNotifications: NotificationServicesController.NotificationServicesControllerState['isUpdatingMetamaskNotifications'];
+  isUpdatingMetamaskNotificationsAccount: NotificationServicesController.NotificationServicesControllerState['isUpdatingMetamaskNotificationsAccount'];
+  eventsBeforeMetricsOptIn: MetaMetricsControllerState['eventsBeforeMetricsOptIn'];
+  fragments: MetaMetricsControllerState['fragments'];
+  metaMetricsId: MetaMetricsControllerState['metaMetricsId'];
+  participateInMetaMetrics: MetaMetricsControllerState['participateInMetaMetrics'];
+  previousUserTraits: MetaMetricsControllerState['previousUserTraits'];
+  segmentApiCalls: MetaMetricsControllerState['segmentApiCalls'];
+  traits: MetaMetricsControllerState['traits'];
+  dataCollectionForMarketing: MetaMetricsControllerState['dataCollectionForMarketing'];
+  marketingCampaignCookieId: MetaMetricsControllerState['marketingCampaignCookieId'];
+  latestNonAnonymousEventTimestamp: MetaMetricsControllerState['latestNonAnonymousEventTimestamp'];
+  metaMetricsDataDeletionId: MetaMetricsDataDeletionState['metaMetricsDataDeletionId'];
+  metaMetricsDataDeletionTimestamp: MetaMetricsDataDeletionState['metaMetricsDataDeletionTimestamp'];
+  names: NameControllerState['names'];
+  nameSources: NameControllerState['nameSources'];
+  // networkConfigurations: NetworkState['networkConfigurations'];
+  networksMetadata: NetworkState['networksMetadata'];
+  selectedNetworkClientId: NetworkState['selectedNetworkClientId'];
+  allNftContracts: NftControllerState['allNftContracts'];
+  allNfts: NftControllerState['allNfts'];
+  ignoredNfts: NftControllerState['ignoredNfts'];
+  completedOnboarding: OnboardingControllerState['completedOnboarding'];
+  firstTimeFlowType: OnboardingControllerState['firstTimeFlowType'];
+  onboardingTabs: OnboardingControllerState['onboardingTabs'];
+  seedPhraseBackedUp: OnboardingControllerState['seedPhraseBackedUp'];
+  storageMetadata: PPOMState['storageMetadata'];
+  versionInfo: PPOMState['versionInfo'];
+  subjects: PermissionControllerState<PermissionConstraint>['subjects'];
+  permissionActivityLog: PermissionLogControllerState['permissionActivityLog'];
+  permissionHistory: PermissionLogControllerState['permissionHistory'];
+  advancedGasFee: PreferencesControllerState['advancedGasFee'];
+  currentLocale: PreferencesControllerState['currentLocale'];
+  dismissSeedBackUpReminder: PreferencesControllerState['dismissSeedBackUpReminder'];
+  overrideContentSecurityPolicyHeader: PreferencesControllerState['overrideContentSecurityPolicyHeader'];
+  featureFlags: PreferencesControllerState['featureFlags'];
+  forgottenPassword: PreferencesControllerState['forgottenPassword'];
+  identities: PreferencesControllerState['identities'];
+  incomingTransactionsPreferences: PreferencesControllerState['incomingTransactionsPreferences'];
+  isIpfsGatewayEnabled: PreferencesControllerState['isIpfsGatewayEnabled'];
+  ipfsGateway: PreferencesControllerState['ipfsGateway'];
+  knownMethodData: PreferencesControllerState['knownMethodData'];
+  ledgerTransportType: PreferencesControllerState['ledgerTransportType'];
+  lostIdentities: PreferencesControllerState['lostIdentities'];
+  openSeaEnabled: PreferencesControllerState['openSeaEnabled'];
+  preferences: PreferencesControllerState['preferences'];
+  useExternalServices: PreferencesControllerState['useExternalServices'];
+  securityAlertsEnabled: PreferencesControllerState['securityAlertsEnabled'];
+  selectedAddress: PreferencesControllerState['selectedAddress'];
+  snapRegistryList: PreferencesControllerState['snapRegistryList'];
+  theme: PreferencesControllerState['theme'];
+  use4ByteResolution: PreferencesControllerState['use4ByteResolution'];
+  useAddressBarEnsResolution: PreferencesControllerState['useAddressBarEnsResolution'];
+  useBlockie: PreferencesControllerState['useBlockie'];
+  useCurrencyRateCheck: PreferencesControllerState['useCurrencyRateCheck'];
+  useExternalNameSources: PreferencesControllerState['useExternalNameSources'];
+  useMultiAccountBalanceChecker: PreferencesControllerState['useMultiAccountBalanceChecker'];
+  useNftDetection: PreferencesControllerState['useNftDetection'];
+  useNonceField: PreferencesControllerState['useNonceField'];
+  usePhishDetect: PreferencesControllerState['usePhishDetect'];
+  useTokenDetection: PreferencesControllerState['useTokenDetection'];
+  // useRequestQueue: PreferencesControllerState['useRequestQueue'];
+  useTransactionSimulations: PreferencesControllerState['useTransactionSimulations'];
+  enableMV3TimestampSave: PreferencesControllerState['enableMV3TimestampSave'];
+  useSafeChainsListValidation: PreferencesControllerState['useSafeChainsListValidation'];
+  watchEthereumAccountEnabled: PreferencesControllerState['watchEthereumAccountEnabled'];
+  bitcoinSupportEnabled: PreferencesControllerState['bitcoinSupportEnabled'];
+  bitcoinTestnetSupportEnabled: PreferencesControllerState['bitcoinTestnetSupportEnabled'];
+  addSnapAccountEnabled: PreferencesControllerState['addSnapAccountEnabled'];
+  snapsAddSnapAccountModalDismissed: PreferencesControllerState['snapsAddSnapAccountModalDismissed'];
+  remoteFeatureFlags: RemoteFeatureFlagControllerState['remoteFeatureFlags'];
+  cacheTimestamp: RemoteFeatureFlagControllerState['cacheTimestamp'];
+  fcmToken: NotificationServicesPushController.NotificationServicesPushControllerState['fcmToken'];
+  fiatCurrency: RatesControllerState['fiatCurrency'];
+  rates: RatesControllerState['rates'];
+  cryptocurrencies: RatesControllerState['cryptocurrencies'];
+  queuedRequestCount: QueuedRequestControllerState['queuedRequestCount'];
+  domains: SelectedNetworkControllerState['domains'];
+  unapprovedPersonalMsgCount: SignatureControllerState['unapprovedPersonalMsgCount'];
+  unapprovedPersonalMsgs: SignatureControllerState['unapprovedPersonalMsgs'];
+  unapprovedTypedMessages: SignatureControllerState['unapprovedTypedMessages'];
+  unapprovedTypedMessagesCount: SignatureControllerState['unapprovedTypedMessagesCount'];
+  smartTransactionsState: SmartTransactionsControllerState['smartTransactionsState'];
+  snaps: SnapControllerState['snaps'];
+  interfaces: SnapInterfaceControllerState['interfaces'];
+  insights: SnapInsightsControllerState['insights'];
+  database: SnapsRegistryState['database'];
+  lastUpdated: SnapsRegistryState['lastUpdated'];
+  databaseUnavailable: SnapsRegistryState['databaseUnavailable'];
+  subjectMetadata: SubjectMetadataControllerState['subjectMetadata'];
+  swapsState: SwapsControllerState['swapsState'];
+  tokenBalances: TokenBalancesControllerState['tokenBalances'];
+  allDetectedTokens: TokensControllerState['allDetectedTokens'];
+  allIgnoredTokens: TokensControllerState['allIgnoredTokens'];
+  allTokens: TokensControllerState['allTokens'];
+  detectedTokens: TokensControllerState['detectedTokens'];
+  ignoredTokens: TokensControllerState['ignoredTokens'];
+  tokens: TokensControllerState['tokens'];
+  preventPollingOnNetworkRestart: TokenListState['preventPollingOnNetworkRestart'];
+  tokenList: TokenListState['tokenList'];
+  tokensChainsCache: TokenListState['tokensChainsCache'];
+  marketData: TokenRatesControllerState['marketData'];
+  lastFetchedBlockNumbers: TransactionControllerState['lastFetchedBlockNumbers'];
+  methodData: TransactionControllerState['methodData'];
+  transactions: TransactionControllerState['transactions'];
+  userOperations: UserOperationControllerState['userOperations'];
+  isProfileSyncingEnabled: UserStorageController.UserStorageControllerState['isProfileSyncingEnabled'];
+  isProfileSyncingUpdateLoading: UserStorageController.UserStorageControllerState['isProfileSyncingUpdateLoading'];
+  hasAccountSyncingSyncedAtLeastOnce: UserStorageController.UserStorageControllerState['hasAccountSyncingSyncedAtLeastOnce'];
+  isAccountSyncingReadyToBeDispatched: UserStorageController.UserStorageControllerState['isAccountSyncingReadyToBeDispatched'];
+  ///: BEGIN:ONLY_INCLUDE_IF(build-mmi)
+  custodyAccountDetails: CustodyControllerState['custodyAccountDetails'];
+  apiRequestLogs: CustodyControllerState['apiRequestLogs'];
+  custodianConnectRequest: CustodyControllerState['custodianConnectRequest'];
+  custodyStatusMaps: CustodyControllerState['custodyStatusMaps'];
+  custodianSupportedChains: CustodyControllerState['custodianSupportedChains'];
+  waitForConfirmDeepLinkDialog: CustodyControllerState['waitForConfirmDeepLinkDialog'];
+  institutionalFeatures: InstitutionalFeaturesControllerState['institutionalFeatures'];
+  mmiConfiguration: MmiConfigurationControllerState['mmiConfiguration'];
+  ///: END:ONLY_INCLUDE_IF
+};
diff --git a/ui/store/store.ts b/ui/store/store.ts
@@ -3,7 +3,8 @@ import { configureStore as baseConfigureStore } from '@reduxjs/toolkit';
 import devtoolsEnhancer from 'remote-redux-devtools';
 import rootReducer from '../ducks';
 import { AppSliceState } from '../ducks/app/app';
-import { MetaMaskSliceState } from '../ducks/metamask/metamask';
+import { BackgroundSliceState } from '../ducks/background/background';
+import { FlattenedBackgroundStateProxy } from '../../shared/types/background';
 
 /**
  * This interface is temporary and is copied from the message-manager.js file
@@ -45,7 +46,8 @@ type ReduxState = {
   activeTab: {
     origin: string;
   };
-  metamask: MetaMaskSliceState['metamask'];
+  metamask: FlattenedBackgroundStateProxy;
+  background: BackgroundSliceState['background'];
   appState: AppSliceState['appState'];
 } & Omit<RootReducerReturnType, 'activeTab' | 'metamask' | 'appState'>;
 

diff --git a/app/scripts/controllers/swaps/swaps.test.ts b/app/scripts/controllers/swaps/swaps.test.ts

      // TODO: Re think how to test this without exposing internal state

      // it('should replace ethers instance when called with a different chainId than was current when the controller was instantiated', async function () {
      //   fetchTradesInfoStub.mockReset();

      //   const _swapsController = getSwapsController();
      //   expect(currentEthersInstance).not.toStrictEqual(newEthersInstance);
      // });

      // it('should not replace ethers instance when called with the same chainId that was current when the controller was instantiated', async function () {
      //   const _swapsController = new SwapsController({
      //     getBufferedGasLimit: MOCK_GET_BUFFERED_GAS_LIMIT,
      //     provider,
      //   expect(currentEthersInstance).toStrictEqual(newEthersInstance);
      // });

      // it('should replace ethers instance, and _ethersProviderChainId, twice when called twice with two different chainIds, and successfully set the _ethersProviderChainId when returning to the original chain', async function () {
      //   const _swapsController = new SwapsController({
      //     getBufferedGasLimit: MOCK_GET_BUFFERED_GAS_LIMIT,
      //     provider,
        });
      });

      // it('clears polling timeout', function () {
      //   swapsController._pollingTimeout = setTimeout(() => {
      //     throw new Error('Polling timeout not cleared');
      //   }, POLLING_TIMEOUT);
    describe('stopPollingForQuotes', function () {
      // TODO: Re think how to test this without exposing internal state

      // it('clears polling timeout', function () {
      //   swapsController._pollingTimeout = setTimeout(() => {
      //     throw new Error('Polling timeout not cleared');
      //   }, POLLING_TIMEOUT);
    describe('resetPostFetchState', function () {
      // TODO: Re think how to test this without exposing internal state

      // it('clears polling timeout', function () {
      //   swapsController._pollingTimeout = setTimeout(() => {
      //     throw new Error('Polling timeout not cleared');
      //   }, POLLING_TIMEOUT);
diff --git a/ui/components/app/detected-token/detected-token.js b/ui/components/app/detected-token/detected-token.js
    };

    setTokensListDetected(newTokensList());
  }, [
    isTokenNetworkFilterEqualCurrentNetwork,
    detectedTokensMultichain,
    detectedTokens,
diff --git a/ui/components/app/name/name.stories.tsx b/ui/components/app/name/name.stories.tsx
 * No name has been saved for the value and type.
 */
 export const NoSavedName = {
  name: 'No Saved Name',
  args: {
    value: ADDRESS_MOCK,
    type: NameType.ETHEREUM_ADDRESS,
diff --git a/ui/components/app/snaps/snap-home-page/snap-home-renderer.js b/ui/components/app/snaps/snap-home-page/snap-home-renderer.js

  useEffect(() => {
    return () => interfaceId && dispatch(deleteInterface(interfaceId));
  }, [interfaceId]);

  useEffect(() => {
    // Snaps are allowed to redirect to their own pending confirmations (templated or not)
    } else if (snapApproval) {
      history.push(`${CONFIRM_TRANSACTION_ROUTE}/${snapApproval.id}`);
    }
  }, [unapprovedTemplatedConfirmations, unapprovedConfirmations, history]);

  return (
    <Box
diff --git a/ui/ducks/background/background.ts b/ui/ducks/background/background.ts
 import { initialBackgroundState } from './constants';

 export type BackgroundSliceState = {
  background: BackgroundStateProxy
 };

 /**

	// TODO: Re think how to test this without exposing internal state

	// it('should replace ethers instance when called with a different chainId than was current when the controller was instantiated', async function () {
Check warning on line 1265 in app/scripts/controllers/swaps/swaps.test.ts GitHub Actions / Test lint / Test lint `Some tests seem to be commented`
	// fetchTradesInfoStub.mockReset();

	// const _swapsController = getSwapsController();
	// expect(currentEthersInstance).not.toStrictEqual(newEthersInstance);
	// });

	// it('should not replace ethers instance when called with the same chainId that was current when the controller was instantiated', async function () {
Check warning on line 1286 in app/scripts/controllers/swaps/swaps.test.ts GitHub Actions / Test lint / Test lint `Some tests seem to be commented`
	// const _swapsController = new SwapsController({
	// getBufferedGasLimit: MOCK_GET_BUFFERED_GAS_LIMIT,
	// provider,
	// expect(currentEthersInstance).toStrictEqual(newEthersInstance);
	// });

	// it('should replace ethers instance, and _ethersProviderChainId, twice when called twice with two different chainIds, and successfully set the _ethersProviderChainId when returning to the original chain', async function () {
Check warning on line 1306 in app/scripts/controllers/swaps/swaps.test.ts GitHub Actions / Test lint / Test lint `Some tests seem to be commented`
	// const _swapsController = new SwapsController({
	// getBufferedGasLimit: MOCK_GET_BUFFERED_GAS_LIMIT,
	// provider,
	});
	});

	// it('clears polling timeout', function () {
Check warning on line 1390 in app/scripts/controllers/swaps/swaps.test.ts GitHub Actions / Test lint / Test lint `Some tests seem to be commented`
	// swapsController._pollingTimeout = setTimeout(() => {
	// throw new Error('Polling timeout not cleared');
	// }, POLLING_TIMEOUT);
	describe('stopPollingForQuotes', function () {
	// TODO: Re think how to test this without exposing internal state

	// it('clears polling timeout', function () {
Check warning on line 1406 in app/scripts/controllers/swaps/swaps.test.ts GitHub Actions / Test lint / Test lint `Some tests seem to be commented`
	// swapsController._pollingTimeout = setTimeout(() => {
	// throw new Error('Polling timeout not cleared');
	// }, POLLING_TIMEOUT);
	describe('resetPostFetchState', function () {
	// TODO: Re think how to test this without exposing internal state

	// it('clears polling timeout', function () {
Check warning on line 1429 in app/scripts/controllers/swaps/swaps.test.ts GitHub Actions / Test lint / Test lint `Some tests seem to be commented`
	// swapsController._pollingTimeout = setTimeout(() => {
	// throw new Error('Polling timeout not cleared');
	// }, POLLING_TIMEOUT);
	};

	setTokensListDetected(newTokensList());
	}, [
Check warning on line 117 in ui/components/app/detected-token/detected-token.js GitHub Actions / Test lint / Test lint `React Hook useEffect has a missing dependency: 'tokensListDetected'. Either include it or remove the dependency array`
	isTokenNetworkFilterEqualCurrentNetwork,
	detectedTokensMultichain,
	detectedTokens,
	* No name has been saved for the value and type.
	*/
	export const NoSavedName = {
	name: 'No Saved Name',
Check warning on line 129 in ui/components/app/name/name.stories.tsx GitHub Actions / Test lint / Test lint `Named exports should not use the name annotation if it is redundant to the name that would be generated by the export name`
	args: {
	value: ADDRESS_MOCK,
	type: NameType.ETHEREUM_ADDRESS,

	useEffect(() => {
	return () => interfaceId && dispatch(deleteInterface(interfaceId));
	}, [interfaceId]);
Check warning on line 49 in ui/components/app/snaps/snap-home-page/snap-home-renderer.js GitHub Actions / Test lint / Test lint `React Hook useEffect has a missing dependency: 'dispatch'. Either include it or remove the dependency array`

	useEffect(() => {
	// Snaps are allowed to redirect to their own pending confirmations (templated or not)
	} else if (snapApproval) {
	history.push(`${CONFIRM_TRANSACTION_ROUTE}/${snapApproval.id}`);
	}
	}, [unapprovedTemplatedConfirmations, unapprovedConfirmations, history]);
Check warning on line 65 in ui/components/app/snaps/snap-home-page/snap-home-renderer.js GitHub Actions / Test lint / Test lint `React Hook useEffect has a missing dependency: 'snapId'. Either include it or remove the dependency array`

	return (
	<Box
	import { initialBackgroundState } from './constants';

	export type BackgroundSliceState = {
	background: BackgroundStateProxy
Check failure on line 38 in ui/ducks/background/background.ts GitHub Actions / Test lint / Test lint Insert `;`
	};

	/**