From c1e6850e3921a1159b63889f986fc654c9f10a22 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 5 Nov 2026 10:01:37 +0000 Subject: [PATCH 1/4] feat(assets-controllers): move constructor reads of other controllers into init Constructors of TokensController, TokenBalancesController, TokenDetectionController, TokenRatesController, AccountTrackerController, NftController, MultichainBalancesController, MultichainAssetsRatesController and MultichainAssetsController no longer call other controllers or start background work. The work moves to a new idempotent init method. TokenListController gains init, which calls initialize once. NftController exposes addNfts through its messenger, and TokensController falls back to the selected network client's provider. Co-authored-by: Xiaoming Wang --- packages/assets-controllers/CHANGELOG.md | 24 ++- .../src/AccountTrackerController.test.ts | 107 ++++++++++++ .../src/AccountTrackerController.ts | 60 +++++-- .../MultichainAssetsController.test.ts | 46 +++++ .../MultichainAssetsController.ts | 34 +++- .../MultichainAssetsRatesController.test.ts | 27 +++ .../MultichainAssetsRatesController.ts | 28 ++- .../MultichainBalancesController.test.ts | 56 +++++- .../MultichainBalancesController.ts | 40 ++++- .../src/NftController-method-action-types.ts | 17 ++ .../src/NftController.test.ts | 89 +++++++++- .../assets-controllers/src/NftController.ts | 39 ++++- .../src/TokenBalancesController.test.ts | 26 +++ .../src/TokenBalancesController.ts | 36 +++- .../src/TokenDetectionController.test.ts | 111 ++++++++++++ .../src/TokenDetectionController.ts | 53 ++++-- .../src/TokenListController.test.ts | 39 ++++- .../src/TokenListController.ts | 14 ++ .../src/TokenRatesController.test.ts | 40 ++++- .../src/TokenRatesController.ts | 30 +++- .../src/TokensController.test.ts | 160 +++++++++++++++++- .../src/TokensController.ts | 82 ++++++--- packages/assets-controllers/src/index.ts | 1 + 23 files changed, 1063 insertions(+), 96 deletions(-) diff --git a/packages/assets-controllers/CHANGELOG.md b/packages/assets-controllers/CHANGELOG.md index 431e193bb0e..068aa8dae7f 100644 --- a/packages/assets-controllers/CHANGELOG.md +++ b/packages/assets-controllers/CHANGELOG.md @@ -11,9 +11,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Add `serviceProfile` string option to `searchTokens`, sent as the `x-mm-service-profile` header on the `/tokens/search` request ([#11274](https://github.com/MetaMask/core/pull/11274)) - Defaults to `assets--trending-search`, so the header is sent on every search request - -### Changed - +- Add `init` method to `TokensController`, `TokenBalancesController`, `TokenDetectionController`, `TokenRatesController`, `AccountTrackerController`, `NftController`, `MultichainBalancesController`, `MultichainAssetsRatesController`, `MultichainAssetsController` and `TokenListController` ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) + - `init` reads the other controllers that the constructor used to read. Calling it more than once has no effect. + - `TokenListController.init` calls `initialize` once. +- Expose `addNfts` through the `NftController` messenger ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) + +### Changed + +- **BREAKING:** The constructors of `TokensController`, `TokenBalancesController`, `TokenDetectionController`, `TokenRatesController`, `AccountTrackerController`, `NftController`, `MultichainBalancesController`, `MultichainAssetsRatesController` and `MultichainAssetsController` no longer call other controllers or start background work, so they can be constructed in any order ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) + - Call `init` on each of them once the controllers they read from are registered. Until then: + - `TokensController` does not enrich persisted tokens from the token list, and reads the selected account on demand. + - `TokenBalancesController`, `TokenDetectionController` and `AccountTrackerController` treat the keyring as locked, and `TokenBalancesController` knows of no tokens. + - `TokenRatesController` knows of no tokens and does not pass native asset identifiers to the token prices service. + - `AccountTrackerController` starts with an empty `accountsByChainId`; `init` adds an empty entry for the selected network's chain when no `accountsByChainId` state was provided. + - `NftController` reads the selected account on demand. + - `MultichainBalancesController` does not fetch the initial non-EVM balances. + - `MultichainAssetsRatesController` uses `usd` as the current currency. + - `MultichainAssetsController` does not start the periodic Blockaid re-scan. + - `TokenDetectionController.init` reports a failure to read `PreferencesController:getState` through `messenger.captureException` instead of throwing, and takes the preference from the next `PreferencesController:stateChange` event. +- **BREAKING:** `TokensControllerMessenger` must allow the `NetworkController:getSelectedNetworkClient` action ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- `TokensController` no longer requires the `chainId` and `provider` options ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) + - When `provider` is omitted, the provider of the selected network client (`NetworkController:getSelectedNetworkClient`) is used. - Bump `uuid` from `^14.0.1` to `^14.0.2` ([#11305](https://github.com/MetaMask/core/pull/11305)) ## [113.1.1] diff --git a/packages/assets-controllers/src/AccountTrackerController.test.ts b/packages/assets-controllers/src/AccountTrackerController.test.ts index c0c4835540a..05b9ba43f09 100644 --- a/packages/assets-controllers/src/AccountTrackerController.test.ts +++ b/packages/assets-controllers/src/AccountTrackerController.test.ts @@ -17,6 +17,8 @@ import type { NetworkClientId, NetworkClientConfiguration, NetworkConfiguration, + NetworkControllerGetNetworkClientByIdAction, + NetworkControllerGetStateAction, } from '@metamask/network-controller'; import { getDefaultPreferencesState } from '@metamask/preferences-controller'; import { TransactionStatus } from '@metamask/transaction-controller'; @@ -139,6 +141,110 @@ describe('AccountTrackerController', () => { ); }); + describe('construction and init', () => { + it('does not call other controllers when constructed', () => { + const messenger: AccountTrackerControllerMessenger = new Messenger({ + namespace: 'AccountTrackerController', + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = new AccountTrackerController({ + messenger, + getStakedBalanceForChain: vi.fn(), + }); + + expect(controller.state).toStrictEqual({ accountsByChainId: {} }); + expect(controller.isActive).toBe(false); + expect(call).not.toHaveBeenCalled(); + }); + + it('does not add the selected chain in init when accountsByChainId state is provided', async () => { + await withController( + { + options: { + state: { accountsByChainId: { '0x89': {} } }, + }, + }, + ({ controller }) => { + expect(controller.state).toStrictEqual({ + accountsByChainId: { '0x89': {} }, + }); + }, + ); + }); + + it('keeps an entry for the selected chain that was added before init', () => { + const rootMessenger: RootMessenger = new Messenger({ + namespace: MOCK_ANY_NAMESPACE, + }); + const messenger: AccountTrackerControllerMessenger = new Messenger({ + namespace: 'AccountTrackerController', + parent: rootMessenger, + }); + rootMessenger.delegate({ + messenger, + actions: [ + 'KeyringController:getState', + 'NetworkController:getState', + 'NetworkController:getNetworkClientById', + ], + }); + rootMessenger.registerActionHandler('KeyringController:getState', () => ({ + isUnlocked: true, + keyrings: [], + })); + rootMessenger.registerActionHandler( + 'NetworkController:getState', + () => + ({ selectedNetworkClientId: 'mainnet' }) as ReturnType< + NetworkControllerGetStateAction['handler'] + >, + ); + rootMessenger.registerActionHandler( + 'NetworkController:getNetworkClientById', + () => + ({ configuration: { chainId: initialChainId } }) as ReturnType< + NetworkControllerGetNetworkClientByIdAction['handler'] + >, + ); + const controller = new AccountTrackerController({ + messenger, + getStakedBalanceForChain: vi.fn(), + }); + controller.updateNativeBalances([ + { address: ADDRESS_1, chainId: initialChainId, balance: '0x1' }, + ]); + + controller.init(); + + expect(controller.isActive).toBe(true); + expect(controller.state.accountsByChainId).toStrictEqual({ + [initialChainId]: { + [CHECKSUM_ADDRESS_1]: { balance: '0x1' }, + }, + }); + }); + + it('does not add the selected chain in init when isDeprecated() returns true', async () => { + await withController( + { options: { isDeprecated: () => true } }, + ({ controller }) => { + expect(controller.state).toStrictEqual({ accountsByChainId: {} }); + }, + ); + }); + + it('reads other controllers only once when init is called repeatedly', async () => { + await withController(({ controller, messenger }) => { + const call = vi.spyOn(messenger, 'call'); + + controller.init(); + + expect(call).not.toHaveBeenCalled(); + }); + }); + }); + it('should refresh when selectedAccount changes', async () => { await withController( { @@ -2467,6 +2573,7 @@ async function withController( getStakedBalanceForChain: vi.fn(), ...options, }); + controller.init(); const refresh = async ( networkClientIds: NetworkClientId[], diff --git a/packages/assets-controllers/src/AccountTrackerController.ts b/packages/assets-controllers/src/AccountTrackerController.ts index 134a4c6baad..a8a8d8d769c 100644 --- a/packages/assets-controllers/src/AccountTrackerController.ts +++ b/packages/assets-controllers/src/AccountTrackerController.ts @@ -267,6 +267,10 @@ export class AccountTrackerController extends StaticIntervalPollingController boolean; isDeprecated?: () => boolean; }) { - const { selectedNetworkClientId } = messenger.call( - 'NetworkController:getState', - ); - const { - configuration: { chainId }, - } = messenger.call( - 'NetworkController:getNetworkClientById', - selectedNetworkClientId, - ); super({ name: controllerName, messenger, state: { - accountsByChainId: { - [chainId]: {}, - }, + accountsByChainId: {}, ...state, }, metadata: accountTrackerMetadata, }); + this.#seedSelectedChain = state?.accountsByChainId === undefined; this.#getStakedBalanceForChain = getStakedBalanceForChain; this.#includeStakedAssets = includeStakedAssets; @@ -359,9 +353,6 @@ export class AccountTrackerController extends StaticIntervalPollingController { + state.accountsByChainId[chainId] = {}; + }); + } + } + /** * Whether the controller is active (keyring is unlocked and user is onboarded). * When locked or not onboarded, balance updates should be skipped. diff --git a/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.test.ts b/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.test.ts index 73fc8000fed..58cc6cd2081 100644 --- a/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.test.ts +++ b/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.test.ts @@ -358,6 +358,7 @@ const setupController = ({ blockaidTokenRescanInterval, ...(isDeprecated && { isDeprecated }), }); + controller.init(); return { controller, @@ -1822,6 +1823,51 @@ describe('MultichainAssetsController', () => { expect(storedAssets).toHaveLength(119); }); + it('does not start the periodic rescan or call other controllers when constructed', async () => { + const messenger: MultichainAssetsControllerMessenger = new Messenger({ + namespace: 'MultichainAssetsController', + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = new MultichainAssetsController({ + messenger, + blockaidTokenRescanInterval: 60_000, + state: { + accountsAssets: { + account1: [ + 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1/token:SomeAddr', + ], + }, + assetsMetadata: {}, + allIgnoredAssets: {}, + }, + }); + await vi.advanceTimersByTimeAsync(60_001); + + expect(call).not.toHaveBeenCalled(); + controller.stopAllPolling(); + }); + + it('starts the periodic rescan only once when init is called repeatedly', async () => { + const mockAccountId = 'account1'; + const token = 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1/token:SomeAddr'; + const { controller, mockBulkScanTokens } = setupController({ + blockaidTokenRescanInterval: 60_000, + state: { + accountsAssets: { [mockAccountId]: [token] }, + assetsMetadata: {}, + allIgnoredAssets: {}, + }, + }); + mockBulkScanTokens.mockResolvedValue({}); + + controller.init(); + await vi.advanceTimersByTimeAsync(1); + + expect(mockBulkScanTokens).toHaveBeenCalledTimes(1); + controller.stopAllPolling(); + }); + it('periodic rescan ignores SPL tokens that Blockaid later marks malicious', async () => { const mockAccountId = 'account1'; const token = diff --git a/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.ts b/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.ts index 6506d4d5b6b..2cc9f65f96f 100644 --- a/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.ts +++ b/packages/assets-controllers/src/MultichainAssetsController/MultichainAssetsController.ts @@ -214,6 +214,10 @@ export class MultichainAssetsController extends StaticIntervalPollingController< readonly #isDeprecated: () => boolean; + readonly #blockaidTokenRescanInterval: number; + + #initialized = false; + constructor({ messenger, state = {}, @@ -238,12 +242,10 @@ export class MultichainAssetsController extends StaticIntervalPollingController< this.#snaps = {}; this.#isDeprecated = isDeprecated; + this.#blockaidTokenRescanInterval = blockaidTokenRescanInterval; if (this.#isDeprecated()) { this.#enforceDisabledState(); - } else if (blockaidTokenRescanInterval > 0) { - this.setIntervalLength(blockaidTokenRescanInterval); - this.startPolling(null); } this.messenger.subscribe( @@ -265,6 +267,32 @@ export class MultichainAssetsController extends StaticIntervalPollingController< messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS); } + /** + * Complete initialization once the controllers this controller reads from + * have been constructed: start the periodic Blockaid re-scan of stored + * tokens, unless it is disabled. + * + * The constructor does not call other controllers or start polling, so it + * can run before they are constructed. Calling it more than once has no + * effect. + */ + init(): void { + if (this.#initialized) { + return; + } + this.#initialized = true; + + if (this.#isDeprecated()) { + this.#enforceDisabledState(); + return; + } + + if (this.#blockaidTokenRescanInterval > 0) { + this.setIntervalLength(this.#blockaidTokenRescanInterval); + this.startPolling(null); + } + } + /** * Clears all persisted `accountsAssets`, `assetsMetadata`, and * `allIgnoredAssets` so that no stale asset data remains in state. diff --git a/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.test.ts b/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.test.ts index 14ede120563..de620fe44c3 100644 --- a/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.test.ts +++ b/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.test.ts @@ -236,6 +236,7 @@ const setupController = ({ messenger: multichainAssetsRatesControllerMessenger, ...config, }); + controller.init(); const updateSpy = vi.spyOn(controller, 'update' as never); @@ -268,6 +269,32 @@ describe('MultichainAssetsRatesController', () => { }); }); + describe('construction and init', () => { + it('does not call other controllers when constructed', () => { + const messenger: MultichainAssetsRatesControllerMessenger = new Messenger( + { namespace: 'MultichainAssetsRatesController' }, + ); + const call = vi.spyOn(messenger, 'call'); + + const controller = new MultichainAssetsRatesController({ messenger }); + + expect(controller.state).toStrictEqual({ + conversionRates: {}, + historicalPrices: {}, + }); + expect(call).not.toHaveBeenCalled(); + }); + + it('reads the current currency only once when init is called repeatedly', () => { + const { controller, messenger } = setupController(); + const call = vi.spyOn(messenger, 'call'); + + controller.init(); + + expect(call).not.toHaveBeenCalled(); + }); + }); + it('updates conversion rates for a valid non-EVM account with marketData', async () => { const { controller, messenger } = setupController(); diff --git a/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.ts b/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.ts index 9fefbaa7ffd..cebea909f13 100644 --- a/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.ts +++ b/packages/assets-controllers/src/MultichainAssetsRatesController/MultichainAssetsRatesController.ts @@ -198,10 +198,12 @@ export class MultichainAssetsRatesController extends StaticIntervalPollingContro > { readonly #mutex = new Mutex(); - #currentCurrency: CurrencyRateState['currentCurrency']; + #currentCurrency: CurrencyRateState['currentCurrency'] = 'usd'; #isUnlocked = true; + #initialized = false; + readonly #isDeprecated: () => boolean; /** @@ -257,10 +259,6 @@ export class MultichainAssetsRatesController extends StaticIntervalPollingContro this.#isUnlocked = true; }); - ({ currentCurrency: this.#currentCurrency } = this.messenger.call( - 'CurrencyRateController:getState', - )); - this.messenger.subscribe( 'CurrencyRateController:stateChange', // eslint-disable-next-line @typescript-eslint/no-misused-promises @@ -298,6 +296,26 @@ export class MultichainAssetsRatesController extends StaticIntervalPollingContro ); } + /** + * Complete initialization once the controllers this controller reads from + * have been constructed: read the current currency from + * `CurrencyRateController`. + * + * The constructor does not call other controllers, so it can run before they + * are constructed. Until this is called, the current currency is `usd`. + * Calling it more than once has no effect. + */ + init(): void { + if (this.#initialized) { + return; + } + this.#initialized = true; + + ({ currentCurrency: this.#currentCurrency } = this.messenger.call( + 'CurrencyRateController:getState', + )); + } + /** * Clears all persisted `conversionRates` and `historicalPrices` so that no * stale rates remain in state. diff --git a/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.test.ts b/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.test.ts index 72f2d7d87a4..69404f973c9 100644 --- a/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.test.ts +++ b/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.test.ts @@ -224,6 +224,9 @@ const setupController = ({ state, ...(isDeprecated ? { isDeprecated } : {}), }); + // `init` never rejects; it fetches the initial balances in the background. + // eslint-disable-next-line no-void + void controller.init(); return { controller, @@ -417,6 +420,57 @@ describe('MultichainBalancesController', () => { ); }); + describe('construction and init', () => { + it('does not call other controllers when constructed', () => { + const messenger: MultichainBalancesControllerMessenger = new Messenger({ + namespace: 'MultichainBalancesController', + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = new MultichainBalancesController({ messenger }); + + expect(controller.state).toStrictEqual({ balances: {} }); + expect(call).not.toHaveBeenCalled(); + }); + + it('fetches the initial balances only once when init is called repeatedly', async () => { + const { controller, mockListMultichainAccounts } = setupController(); + await waitForAllPromises(); + mockListMultichainAccounts.mockClear(); + + await controller.init(); + + expect(mockListMultichainAccounts).not.toHaveBeenCalled(); + }); + + it('logs and resolves when fetching the initial balances of an account fails', async () => { + const consoleErrorSpy = vi + .spyOn(console, 'error') + .mockImplementation(() => undefined); + const messenger = getRootMessenger(); + messenger.registerActionHandler( + 'AccountsController:listMultichainAccounts', + () => [mockBtcAccount], + ); + const controller = new MultichainBalancesController({ + messenger: getRestrictedMessenger(messenger), + }); + + await controller.init(); + + expect(consoleErrorSpy).toHaveBeenCalledWith( + 'Failed to fetch initial balances:', + expect.objectContaining({ + message: expect.stringContaining( + 'MultichainAssetsController:getState', + ), + }), + ); + expect(controller.state.balances).toStrictEqual({}); + consoleErrorSpy.mockRestore(); + }); + }); + it('fetches initial balances for existing non-EVM accounts', async () => { const { controller } = setupController({ mocks: { @@ -921,7 +975,7 @@ describe('MultichainBalancesController', () => { expect(controller.state.balances).toStrictEqual(initialState.balances); }); - it('does not fetch initial balances at construction when isDeprecated() returns true', async () => { + it('does not fetch initial balances in init when isDeprecated() returns true', async () => { const { mockSnapHandleRequest } = setupController({ isDeprecated: () => true, }); diff --git a/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.ts b/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.ts index 2d028153085..f8b82f3adc6 100644 --- a/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.ts +++ b/packages/assets-controllers/src/MultichainBalancesController/MultichainBalancesController.ts @@ -143,6 +143,8 @@ export class MultichainBalancesController extends BaseController< > { readonly #isDeprecated: () => boolean; + #initialized = false; + /** * Creates a MultichainBalancesController instance. * @@ -179,13 +181,6 @@ export class MultichainBalancesController extends BaseController< if (this.#isDeprecated()) { this.#enforceDisabledState(); - } else { - // Fetch initial balances for all non-EVM accounts - for (const account of this.#listAccounts()) { - // Fetching the balance is asynchronous and we cannot use `await` here. - // eslint-disable-next-line no-void - void this.updateBalance(account.id); - } } this.messenger.subscribe( @@ -215,6 +210,37 @@ export class MultichainBalancesController extends BaseController< ); } + /** + * Complete initialization once the controllers this controller reads from + * have been constructed: fetch the initial balances of all non-EVM accounts. + * + * The constructor does not call other controllers, so it can run before they + * are constructed. A failure to fetch the balances of one account is logged + * and does not affect the others. Calling it more than once has no effect. + */ + async init(): Promise { + if (this.#initialized) { + return; + } + this.#initialized = true; + + if (this.#isDeprecated()) { + this.#enforceDisabledState(); + return; + } + + const results = await Promise.allSettled( + this.#listAccounts().map(async (account) => + this.updateBalance(account.id), + ), + ); + for (const result of results) { + if (result.status === 'rejected') { + console.error('Failed to fetch initial balances:', result.reason); + } + } + } + /** * Clears all persisted `balances` so that no stale balances remain in state. * diff --git a/packages/assets-controllers/src/NftController-method-action-types.ts b/packages/assets-controllers/src/NftController-method-action-types.ts index 01d4dd2c849..aa91f1c086a 100644 --- a/packages/assets-controllers/src/NftController-method-action-types.ts +++ b/packages/assets-controllers/src/NftController-method-action-types.ts @@ -55,6 +55,22 @@ export type NftControllerAddNftAction = { handler: NftController['addNft']; }; +/** + * Adds multiple NFTs and respective NFT contracts to the stored NFT and NFT contracts lists. + * + * @param nfts - An array of NFT objects to add. + * @param nfts[].tokenAddress - Hex address of the NFT contract. + * @param nfts[].tokenId - The NFT identifier. + * @param nfts[].nftMetadata - NFT metadata including chainId. + * @param userAddress - The address of the current user. + * @param source - Whether the NFT was detected, added manually or suggested by a dapp. Defaults to `Source.Custom`; pass `Source.Detected` when refreshing existing NFTs. + * @returns Promise resolving to the current NFT list. + */ +export type NftControllerAddNftsAction = { + type: `NftController:addNfts`; + handler: NftController['addNfts']; +}; + /** * Removes an NFT from the stored token list. * @@ -119,6 +135,7 @@ export type NftControllerMethodActions = | NftControllerIsNftOwnerAction | NftControllerAddNftVerifyOwnershipAction | NftControllerAddNftAction + | NftControllerAddNftsAction | NftControllerRemoveNftAction | NftControllerRemoveAndIgnoreNftAction | NftControllerCheckAndUpdateSingleNftOwnershipStatusAction diff --git a/packages/assets-controllers/src/NftController.test.ts b/packages/assets-controllers/src/NftController.test.ts index 5c7748f143b..7574ece1d6d 100644 --- a/packages/assets-controllers/src/NftController.test.ts +++ b/packages/assets-controllers/src/NftController.test.ts @@ -68,7 +68,10 @@ import type { NFTStandardType, NftMetadata, } from './NftController.js'; -import { NftController } from './NftController.js'; +import { + getDefaultNftControllerState, + NftController, +} from './NftController.js'; import type { Collection } from './NftDetectionController.js'; type AllActions = @@ -415,6 +418,7 @@ function setupController({ messenger: nftControllerMessenger, ...options, }); + nftController.init(); const triggerPreferencesStateChange = ( state: PreferencesState & { openSeaEnabled?: boolean }, @@ -501,6 +505,89 @@ describe('NftController', () => { }); }); + describe('construction and init', () => { + it('does not call other controllers when constructed', () => { + const messenger: NftControllerMessenger = new Messenger({ + namespace: 'NftController', + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = new NftController({ messenger }); + + expect(controller.state).toStrictEqual(getDefaultNftControllerState()); + expect(call).not.toHaveBeenCalled(); + }); + + it('reads the selected account only once when init is called repeatedly', () => { + const getSelectedAccount = vi.fn().mockReturnValue(OWNER_ACCOUNT); + const { nftController } = setupController({ getSelectedAccount }); + getSelectedAccount.mockClear(); + + nftController.init(); + + expect(getSelectedAccount).not.toHaveBeenCalled(); + }); + + it('uses the selected account address before init is called', () => { + const rootMessenger: RootMessenger = new Messenger({ + namespace: MOCK_ANY_NAMESPACE, + }); + const messenger: NftControllerMessenger = new Messenger({ + namespace: 'NftController', + parent: rootMessenger, + }); + rootMessenger.delegate({ + messenger, + actions: [ + 'AccountsController:getSelectedAccount', + 'NetworkController:getNetworkClientById', + ], + }); + const getSelectedAccount = vi.fn().mockReturnValue(OWNER_ACCOUNT); + rootMessenger.registerActionHandler( + 'AccountsController:getSelectedAccount', + getSelectedAccount, + ); + rootMessenger.registerActionHandler( + 'NetworkController:getNetworkClientById', + buildMockGetNetworkClientById(), + ); + const controller = new NftController({ messenger }); + + controller.removeNft(ERC721_NFT_ADDRESS, ERC721_NFT_ID, 'mainnet'); + + expect(getSelectedAccount).toHaveBeenCalledTimes(1); + }); + + it('exposes addNfts over the messenger', async () => { + const { nftController, messenger } = setupController({ + getERC721AssetName: vi.fn().mockResolvedValue('Name'), + }); + + await messenger.call( + 'NftController:addNfts', + [ + { + tokenAddress: '0x01', + tokenId: '1', + nftMetadata: { + name: 'NFT 1', + image: 'image1', + description: 'description 1', + standard: 'ERC721', + chainId: 1, + }, + }, + ], + OWNER_ACCOUNT.address, + ); + + expect( + nftController.state.allNfts[OWNER_ACCOUNT.address]?.['0x1'], + ).toHaveLength(1); + }); + }); + describe('watchNft', function () { const ERC721_NFT = { address: ERC721_NFT_ADDRESS, diff --git a/packages/assets-controllers/src/NftController.ts b/packages/assets-controllers/src/NftController.ts index be8c24f0f65..61e8f792849 100644 --- a/packages/assets-controllers/src/NftController.ts +++ b/packages/assets-controllers/src/NftController.ts @@ -296,6 +296,7 @@ const controllerName = 'NftController'; const MESSENGER_EXPOSED_METHODS = [ 'addNft', + 'addNfts', 'addNftVerifyOwnership', 'removeAndIgnoreNft', 'removeNft', @@ -365,7 +366,9 @@ export class NftController extends BaseController< > { readonly #mutex = new Mutex(); - #selectedAccountId: string; + #selectedAccountId: string | undefined; + + #initialized = false; #ipfsGateway: string; @@ -429,9 +432,6 @@ export class NftController extends BaseController< }, }); - this.#selectedAccountId = this.messenger.call( - 'AccountsController:getSelectedAccount', - ).id; this.#ipfsGateway = ipfsGateway; this.#displayNftMedia = displayNftMedia; this.#useIpfsSubdomains = useIpfsSubdomains; @@ -454,6 +454,26 @@ export class NftController extends BaseController< ); } + /** + * Complete initialization once the controllers this controller reads from + * have been constructed: read the selected account from + * `AccountsController`. + * + * The constructor does not call other controllers, so it can run before they + * are constructed. Until this is called, the selected account is read on + * demand. Calling it more than once has no effect. + */ + init(): void { + if (this.#initialized) { + return; + } + this.#initialized = true; + + this.#selectedAccountId ??= this.messenger.call( + 'AccountsController:getSelectedAccount', + ).id; + } + /** * Handles the state change of the preference controller. * @@ -2208,10 +2228,13 @@ export class NftController extends BaseController< } // If the address is not defined (or empty), we fallback to the currently selected account's address - const selectedAccount = this.messenger.call( - 'AccountsController:getAccount', - this.#selectedAccountId, - ); + const selectedAccount = + this.#selectedAccountId === undefined + ? this.messenger.call('AccountsController:getSelectedAccount') + : this.messenger.call( + 'AccountsController:getAccount', + this.#selectedAccountId, + ); return selectedAccount?.address || ''; } diff --git a/packages/assets-controllers/src/TokenBalancesController.test.ts b/packages/assets-controllers/src/TokenBalancesController.test.ts index 132747a5e1f..dfcc57dade4 100644 --- a/packages/assets-controllers/src/TokenBalancesController.test.ts +++ b/packages/assets-controllers/src/TokenBalancesController.test.ts @@ -241,6 +241,7 @@ const setupController = ({ messenger: tokenBalancesControllerMessenger, ...config, }); + controller.init(); const updateSpy = vi.spyOn(controller, 'update' as never); return { @@ -6830,6 +6831,31 @@ describe('TokenBalancesController', () => { }); }); + describe('construction and init', () => { + it('does not call other controllers when constructed', () => { + const messenger: TokenBalancesControllerMessenger = new Messenger({ + namespace: 'TokenBalancesController', + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = new TokenBalancesController({ messenger }); + + expect(controller.state).toStrictEqual({ tokenBalances: {} }); + expect(controller.isActive).toBe(false); + expect(call).not.toHaveBeenCalled(); + }); + + it('reads the token and keyring state only once when init is called repeatedly', () => { + const { controller, tokenBalancesControllerMessenger } = + setupController(); + const call = vi.spyOn(tokenBalancesControllerMessenger, 'call'); + + controller.init(); + + expect(call).not.toHaveBeenCalled(); + }); + }); + describe('keyring lock/unlock handling', () => { it('should initialize isUnlocked from KeyringController state', () => { const { controller } = setupController(); diff --git a/packages/assets-controllers/src/TokenBalancesController.ts b/packages/assets-controllers/src/TokenBalancesController.ts index ee5dae7adc5..9a78db2ad45 100644 --- a/packages/assets-controllers/src/TokenBalancesController.ts +++ b/packages/assets-controllers/src/TokenBalancesController.ts @@ -350,6 +350,8 @@ export class TokenBalancesController extends StaticIntervalPollingController<{ /** Track if the keyring is unlocked */ #isUnlocked = false; + #initialized = false; + /** Store original chainIds from startPolling to preserve intent */ #requestedChainIds: ChainIdHex[] = []; @@ -419,15 +421,6 @@ export class TokenBalancesController extends StaticIntervalPollingController<{ this.setIntervalLength(interval); - const { allTokens, allDetectedTokens, allIgnoredTokens } = - this.messenger.call('TokensController:getState'); - this.#allTokens = allTokens; - this.#detectedTokens = allDetectedTokens; - this.#allIgnoredTokens = allIgnoredTokens; - - const { isUnlocked } = this.messenger.call('KeyringController:getState'); - this.#isUnlocked = isUnlocked; - this.#batchedUpdateBalances = createBatchedHandler( (buffer) => buffer.length === 0 @@ -451,6 +444,31 @@ export class TokenBalancesController extends StaticIntervalPollingController<{ messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS); } + /** + * Complete initialization once the controllers this controller reads from + * have been constructed: read the current tokens from `TokensController` and + * the lock state from `KeyringController`. + * + * The constructor does not call other controllers, so it can run before they + * are constructed. Until this is called, the controller treats the keyring as + * locked and knows of no tokens. Calling it more than once has no effect. + */ + init(): void { + if (this.#initialized) { + return; + } + this.#initialized = true; + + const { allTokens, allDetectedTokens, allIgnoredTokens } = + this.messenger.call('TokensController:getState'); + this.#allTokens = allTokens; + this.#detectedTokens = allDetectedTokens; + this.#allIgnoredTokens = allIgnoredTokens; + + const { isUnlocked } = this.messenger.call('KeyringController:getState'); + this.#isUnlocked = isUnlocked; + } + /** * Clears all persisted `tokenBalances` so that no stale balances remain in * state. diff --git a/packages/assets-controllers/src/TokenDetectionController.test.ts b/packages/assets-controllers/src/TokenDetectionController.test.ts index 835b7eefa74..e54985585d2 100644 --- a/packages/assets-controllers/src/TokenDetectionController.test.ts +++ b/packages/assets-controllers/src/TokenDetectionController.test.ts @@ -231,6 +231,116 @@ function buildTokenDetectionControllerMessenger( return tokenDetectionControllerMessenger; } +describe('TokenDetectionController construction and init', () => { + const buildController = ( + messenger: TokenDetectionControllerMessenger, + ): TokenDetectionController => + new TokenDetectionController({ + disabled: false, + getBalancesInSingleCall: vi.fn(), + trackMetaMetricsEvent: vi.fn(), + messenger, + tokenListService: { + fetchTokensByChainId: vi.fn().mockResolvedValue({}), + } as unknown as TokenListService, + }); + + it('does not call other controllers when constructed', () => { + const messenger: TokenDetectionControllerMessenger = new Messenger({ + namespace: controllerName, + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = buildController(messenger); + + expect(controller.isActive).toBe(false); + expect(call).not.toHaveBeenCalled(); + }); + + it('reads the selected account, keyring and preferences state in init, only once', () => { + const rootMessenger = buildRootMessenger(); + const getSelectedAccount = vi + .fn() + .mockReturnValue(createMockInternalAccount()); + rootMessenger.registerActionHandler( + 'AccountsController:getSelectedAccount', + getSelectedAccount, + ); + rootMessenger.registerActionHandler('KeyringController:getState', () => ({ + isUnlocked: true, + keyrings: [], + })); + const getPreferencesState = vi + .fn() + .mockReturnValue(getDefaultPreferencesState()); + rootMessenger.registerActionHandler( + 'PreferencesController:getState', + getPreferencesState, + ); + const controller = buildController( + buildTokenDetectionControllerMessenger(rootMessenger), + ); + + controller.init(); + controller.init(); + + expect(controller.isActive).toBe(true); + expect(getSelectedAccount).toHaveBeenCalledTimes(1); + expect(getPreferencesState).toHaveBeenCalledTimes(1); + }); + + it('uses the selected account address before init is called', async () => { + const rootMessenger = buildRootMessenger(); + const getSelectedAccount = vi + .fn() + .mockReturnValue(createMockInternalAccount()); + rootMessenger.registerActionHandler( + 'AccountsController:getSelectedAccount', + getSelectedAccount, + ); + rootMessenger.registerActionHandler( + 'NetworkController:getState', + getDefaultNetworkControllerState, + ); + const controller = buildController( + buildTokenDetectionControllerMessenger(rootMessenger), + ); + rootMessenger.publish('KeyringController:unlock'); + + await controller.detectTokens({ chainIds: [] }); + + expect(getSelectedAccount).toHaveBeenCalled(); + }); + + it('reports the error and continues when PreferencesController is not registered yet', () => { + const captureException = vi.fn(); + const rootMessenger: RootMessenger = new Messenger({ + namespace: MOCK_ANY_NAMESPACE, + captureException, + }); + rootMessenger.registerActionHandler( + 'AccountsController:getSelectedAccount', + () => createMockInternalAccount(), + ); + rootMessenger.registerActionHandler('KeyringController:getState', () => ({ + isUnlocked: true, + keyrings: [], + })); + const controller = buildController( + buildTokenDetectionControllerMessenger(rootMessenger), + ); + + controller.init(); + + expect(controller.isActive).toBe(true); + expect(captureException).toHaveBeenCalledWith( + expect.objectContaining({ + message: expect.stringContaining('PreferencesController:getState'), + }), + ); + }); +}); + describe('TokenDetectionController', () => { const defaultSelectedAccount = createMockInternalAccount(); @@ -4581,6 +4691,7 @@ async function withController( tokenListService, ...options, }); + controller.init(); try { return await fn({ controller, diff --git a/packages/assets-controllers/src/TokenDetectionController.ts b/packages/assets-controllers/src/TokenDetectionController.ts index 74a537c3c94..2f20280fb6a 100644 --- a/packages/assets-controllers/src/TokenDetectionController.ts +++ b/packages/assets-controllers/src/TokenDetectionController.ts @@ -192,15 +192,17 @@ export class TokenDetectionController extends StaticIntervalPollingController { #intervalId?: ReturnType; - #selectedAccountId: string; + #selectedAccountId: string | undefined; readonly #tokenListService: TokenListService; #disabled: boolean; - #isUnlocked: boolean; + #isUnlocked = false; - #isDetectionEnabledFromPreferences: boolean; + #isDetectionEnabledFromPreferences: boolean | undefined; + + #initialized = false; readonly #useTokenDetection: () => boolean; @@ -279,22 +281,12 @@ export class TokenDetectionController extends StaticIntervalPollingController { }); }); + describe('init', () => { + it('does not call other controllers when constructed', () => { + const messenger: TokenListControllerMessenger = new Messenger({ + namespace, + }); + const call = vi.spyOn(messenger, 'call'); + + const controller = new TokenListController({ + chainId: ChainId.mainnet, + messenger, + }); + + expect(controller.state).toStrictEqual(getDefaultTokenListState()); + expect(call).not.toHaveBeenCalled(); + }); + + it('initializes the controller only once when called repeatedly', async () => { + const messenger = getMessenger(); + const restrictedMessenger = getRestrictedMessenger(messenger); + const call = vi.spyOn(restrictedMessenger, 'call'); + const controller = new TokenListController({ + chainId: ChainId.mainnet, + messenger: restrictedMessenger, + }); + + await Promise.all([controller.init(), controller.init()]); + const callCount = call.mock.calls.length; + await controller.init(); + + expect(callCount).toBeGreaterThan(0); + expect(call).toHaveBeenCalledTimes(callCount); + }); + }); + describe('StorageService migration', () => { // State changes after construction trigger debounced persistence it('should persist state changes to StorageService via debounced subscription', async () => { diff --git a/packages/assets-controllers/src/TokenListController.ts b/packages/assets-controllers/src/TokenListController.ts index 93db17a1a7a..d075a9e40c4 100644 --- a/packages/assets-controllers/src/TokenListController.ts +++ b/packages/assets-controllers/src/TokenListController.ts @@ -122,6 +122,8 @@ export class TokenListController extends StaticIntervalPollingController; + #initPromise?: Promise; + /** * Promise that resolves when the current persist operation completes. * Used to prevent race conditions between persist operations. @@ -242,6 +244,18 @@ export class TokenListController extends StaticIntervalPollingController { + this.#initPromise ??= this.initialize(); + await this.#initPromise; + } + /** * Initialize the controller by loading cache from storage and running migration. * This method should be called by clients after construction. diff --git a/packages/assets-controllers/src/TokenRatesController.test.ts b/packages/assets-controllers/src/TokenRatesController.test.ts index 7512793bc2c..463f51a27b9 100644 --- a/packages/assets-controllers/src/TokenRatesController.test.ts +++ b/packages/assets-controllers/src/TokenRatesController.test.ts @@ -84,6 +84,43 @@ function buildTokenRatesControllerMessenger( describe('TokenRatesController', () => { describe('constructor', () => { + it('does not call other controllers when constructed', () => { + const messenger: TokenRatesControllerMessenger = new Messenger({ + namespace: 'TokenRatesController', + }); + const call = vi.spyOn(messenger, 'call'); + const setNativeAssetIdentifiers = vi.fn(); + + const controller = new TokenRatesController({ + messenger, + tokenPricesService: buildMockTokenPricesService({ + setNativeAssetIdentifiers, + }), + }); + + expect(controller.state).toStrictEqual({ marketData: {} }); + expect(call).not.toHaveBeenCalled(); + expect(setNativeAssetIdentifiers).not.toHaveBeenCalled(); + }); + + it('reads other controllers only once when init is called repeatedly', async () => { + const setNativeAssetIdentifiers = vi.fn(); + await withController( + { + options: { + tokenPricesService: buildMockTokenPricesService({ + setNativeAssetIdentifiers, + }), + }, + }, + async ({ controller }) => { + controller.init(); + + expect(setNativeAssetIdentifiers).toHaveBeenCalledTimes(1); + }, + ); + }); + it('should set default state', async () => { await withController(async ({ controller }) => { expect(controller.state).toStrictEqual({ @@ -92,7 +129,7 @@ describe('TokenRatesController', () => { }); }); - it('should call setNativeAssetIdentifiers on tokenPricesService if available', async () => { + it('should call setNativeAssetIdentifiers on tokenPricesService in init if available', async () => { const setNativeAssetIdentifiers = vi.fn(); const tokenPricesService = buildMockTokenPricesService({ setNativeAssetIdentifiers, @@ -1514,6 +1551,7 @@ async function withController( messenger: buildTokenRatesControllerMessenger(messenger), ...options, }); + controller.init(); try { return await fn({ controller, diff --git a/packages/assets-controllers/src/TokenRatesController.ts b/packages/assets-controllers/src/TokenRatesController.ts index cf49fc5f588..221ee8ff9c9 100644 --- a/packages/assets-controllers/src/TokenRatesController.ts +++ b/packages/assets-controllers/src/TokenRatesController.ts @@ -199,9 +199,11 @@ export class TokenRatesController extends StaticIntervalPollingController boolean; - #allTokens: TokensControllerState['allTokens']; + #allTokens: TokensControllerState['allTokens'] = {}; - #allDetectedTokens: TokensControllerState['allDetectedTokens']; + #allDetectedTokens: TokensControllerState['allDetectedTokens'] = {}; + + #initialized = false; /** * Creates a TokenRatesController instance. @@ -250,16 +252,32 @@ export class TokenRatesController extends StaticIntervalPollingController { }, }, async ({ controller }) => { - // The enrichment is async (fires in constructor); wait for it. + // The enrichment is async (fires in `init`); wait for it. await new Promise((resolve) => setTimeout(resolve, 0)); // TokenListService returns the token list for mainnet with a name. @@ -3359,7 +3360,7 @@ describe('TokensController', () => { }, }, async ({ controller }) => { - // Enrichment is a fire-and-forget async call in the constructor. + // Enrichment is a fire-and-forget async call in `init`. await new Promise((resolve) => setTimeout(resolve, 0)); const token = @@ -3374,6 +3375,155 @@ describe('TokensController', () => { }); }); + describe('construction and init', () => { + it('does not call other controllers when constructed', () => { + const messenger: TokensControllerMessenger = new Messenger({ + namespace: 'TokensController', + }); + const call = vi.spyOn(messenger, 'call'); + const fetchTokensByChainId = vi.fn().mockResolvedValue({}); + + const controller = new TokensController({ + messenger, + tokenListService: { + fetchTokensByChainId, + } as unknown as import('./TokenListService.js').TokenListService, + }); + + expect(controller.state).toStrictEqual(getDefaultTokensState()); + expect(call).not.toHaveBeenCalled(); + expect(fetchTokensByChainId).not.toHaveBeenCalled(); + }); + + it('reads the selected account only once when init is called repeatedly', async () => { + await withController( + async ({ controller, getSelectedAccountHandler }) => { + getSelectedAccountHandler.mockClear(); + + await controller.init(); + + expect(getSelectedAccountHandler).not.toHaveBeenCalled(); + }, + ); + }); + + it('does not read the selected account or enrich tokens in init when isDeprecated() returns true', async () => { + const fetchTokensByChainId = vi.fn().mockResolvedValue({}); + await withController( + { + options: { + isDeprecated: () => true, + tokenListService: { + fetchTokensByChainId, + } as unknown as import('./TokenListService.js').TokenListService, + }, + }, + async ({ getSelectedAccountHandler }) => { + expect(getSelectedAccountHandler).not.toHaveBeenCalled(); + expect(fetchTokensByChainId).not.toHaveBeenCalled(); + }, + ); + }); + + it('uses the selected account address before init is called', async () => { + const messenger: RootMessenger = new Messenger({ + namespace: MOCK_ANY_NAMESPACE, + }); + const tokensControllerMessenger: TokensControllerMessenger = + new Messenger({ namespace: 'TokensController', parent: messenger }); + messenger.delegate({ + messenger: tokensControllerMessenger, + actions: [ + 'AccountsController:getSelectedAccount', + 'NetworkController:getNetworkClientById', + ], + }); + messenger.registerActionHandler( + 'AccountsController:getSelectedAccount', + () => defaultMockInternalAccount, + ); + messenger.registerActionHandler( + 'NetworkController:getNetworkClientById', + () => + ({ + configuration: { chainId: ChainId.mainnet }, + }) as ReturnType< + NetworkControllerGetNetworkClientByIdAction['handler'] + >, + ); + const controller = new TokensController({ + messenger: tokensControllerMessenger, + tokenListService: { + fetchTokensByChainId: vi.fn().mockResolvedValue({}), + } as unknown as import('./TokenListService.js').TokenListService, + }); + + await controller.addTokens( + [{ address: '0x01', symbol: 'bar', decimals: 2 }], + 'mainnet', + ); + + expect( + controller.state.allTokens[ChainId.mainnet][ + defaultMockInternalAccount.address + ], + ).toHaveLength(1); + }); + + it('uses the provider of the selected network client when no provider is given', async () => { + const getSelectedNetworkClient = vi + .fn() + .mockReturnValue({ provider: new MockInternalProvider() }); + await withController( + { options: { provider: undefined } }, + async ({ controller, messenger }) => { + messenger.registerActionHandler( + 'NetworkController:getSelectedNetworkClient', + getSelectedNetworkClient, + ); + ContractMock.mockImplementation(function () { + return buildMockEthersERC721Contract({ supportsInterface: true }); + }); + + const result = controller.watchAsset({ + asset: buildToken({ + address: '0x0000000000000000000000000000000000000001', + }), + type: 'ERC20', + networkClientId: '', + }); + + await expect(result).rejects.toThrow('was detected as ERC721'); + expect(getSelectedNetworkClient).toHaveBeenCalled(); + }, + ); + }); + + it('throws when no provider is given and there is no selected network client', async () => { + await withController( + { options: { provider: undefined } }, + async ({ controller, messenger }) => { + messenger.registerActionHandler( + 'NetworkController:getSelectedNetworkClient', + () => undefined, + ); + + const result = controller.watchAsset({ + asset: buildToken({ + address: '0x0000000000000000000000000000000000000001', + }), + type: 'ERC20', + networkClientId: '', + }); + + await expect(result).rejects.toThrow( + 'No provider is available for the selected network', + ); + }, + ); + }); + }); + describe('when selectedAccountId is not set or account not found', () => { describe('detectTokens', () => { it('updates the token states to empty arrays if the selectedAccountId account is undefined', async () => { @@ -4166,6 +4316,7 @@ async function withController( actions: [ 'ApprovalController:addRequest', 'NetworkController:getNetworkClientById', + 'NetworkController:getSelectedNetworkClient', 'AccountsController:getAccount', 'AccountsController:getSelectedAccount', 'AccountsController:listAccounts', @@ -4215,6 +4366,9 @@ async function withController( tokenListService, ...options, }); + // `init` never rejects; its synchronous part runs before this returns. + // eslint-disable-next-line no-void + void controller.init(); const triggerSelectedAccountChange = (internalAccount: InternalAccount) => { getAccountHandler.mockReturnValue(internalAccount); diff --git a/packages/assets-controllers/src/TokensController.ts b/packages/assets-controllers/src/TokensController.ts index ad869a01544..30240efe6ce 100644 --- a/packages/assets-controllers/src/TokensController.ts +++ b/packages/assets-controllers/src/TokensController.ts @@ -32,6 +32,7 @@ import { abiERC721 } from '@metamask/metamask-eth-abis'; import type { NetworkClientId, NetworkControllerGetNetworkClientByIdAction, + NetworkControllerGetSelectedNetworkClientAction, NetworkControllerNetworkDidChangeEvent, NetworkControllerStateChangeEvent, NetworkState, @@ -145,6 +146,7 @@ export type TokensControllerActions = export type AllowedActions = | ApprovalControllerAddRequestAction | NetworkControllerGetNetworkClientByIdAction + | NetworkControllerGetSelectedNetworkClientAction | AccountsControllerGetAccountAction | AccountsControllerGetSelectedAccountAction | AccountsControllerListAccountsAction; @@ -200,20 +202,29 @@ export class TokensController extends BaseController< > { readonly #mutex = new Mutex(); - #selectedAccountId: string; + #selectedAccountId: string | undefined; - readonly #provider: Provider; + readonly #provider: Provider | undefined; + + readonly #tokenListService: TokenListService; readonly #abortController: AbortController; readonly #isDeprecated: () => boolean; + #initialized = false; + /** * Tokens controller options * + * The constructor does not call other controllers, so it can run before they + * are constructed. Call {@link TokensController.init} once they are. + * * @param options - Constructor options. * @param options.chainId - The chain ID of the current network. - * @param options.provider - Network provider. + * @param options.provider - Network provider. When omitted, the provider of + * the selected network client (`NetworkController:getSelectedNetworkClient`) + * is used at call time. * @param options.state - Initial state to set on this controller. * @param options.messenger - The messenger. * @param options.tokenListService - Shared service for fetching token metadata per chain. @@ -232,8 +243,8 @@ export class TokensController extends BaseController< tokenListService, isDeprecated = (): boolean => false, }: { - chainId: Hex; - provider: Provider; + chainId?: Hex; + provider?: Provider; state?: Partial; messenger: TokensControllerMessenger; tokenListService: TokenListService; @@ -250,10 +261,9 @@ export class TokensController extends BaseController< }); this.#provider = provider; + this.#tokenListService = tokenListService; this.#isDeprecated = isDeprecated; - this.#selectedAccountId = this.#getSelectedAccount().id; - this.#abortController = new AbortController(); messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS); @@ -275,14 +285,34 @@ export class TokensController extends BaseController< if (this.#isDeprecated()) { this.#enforceDisabledState(); - } else { - // Enrich persisted tokens with name/rwaData from the token list once at init. - this.#enrichTokensFromTokenList(tokenListService).catch(() => { - // Tokens remain usable without metadata enrichment - }); } } + /** + * Complete initialization once the controllers this controller reads from + * have been constructed: read the selected account and enrich persisted + * tokens with name/rwaData from the token list. + * + * Calling it more than once has no effect. + */ + async init(): Promise { + if (this.#initialized) { + return; + } + this.#initialized = true; + + if (this.#isDeprecated()) { + this.#enforceDisabledState(); + return; + } + + this.#selectedAccountId ??= this.#getSelectedAccount().id; + + await this.#enrichTokensFromTokenList(this.#tokenListService).catch(() => { + // Tokens remain usable without metadata enrichment + }); + } + /** * Clears all persisted token state so that no stale data remains. * @@ -914,14 +944,23 @@ export class TokensController extends BaseController< } #getProvider(networkClientId?: NetworkClientId): Web3Provider { - return new Web3Provider( - networkClientId - ? this.messenger.call( - 'NetworkController:getNetworkClientById', - networkClientId, - ).provider - : this.#provider, - ); + if (networkClientId) { + return new Web3Provider( + this.messenger.call( + 'NetworkController:getNetworkClientById', + networkClientId, + ).provider, + ); + } + + const provider = + this.#provider ?? + this.messenger.call('NetworkController:getSelectedNetworkClient') + ?.provider; + if (!provider) { + throw new Error('No provider is available for the selected network'); + } + return new Web3Provider(provider); } #createEthersContract( @@ -1249,6 +1288,9 @@ export class TokensController extends BaseController< } #getSelectedAddress() { + if (this.#selectedAccountId === undefined) { + return this.#getSelectedAccount().address; + } // If the address is not defined (or empty), we fallback to the currently selected account's address const account = this.messenger.call( 'AccountsController:getAccount', diff --git a/packages/assets-controllers/src/index.ts b/packages/assets-controllers/src/index.ts index 2942636ac26..28a1a18fdcb 100644 --- a/packages/assets-controllers/src/index.ts +++ b/packages/assets-controllers/src/index.ts @@ -70,6 +70,7 @@ export type { NftControllerIsNftOwnerAction, NftControllerAddNftVerifyOwnershipAction, NftControllerAddNftAction, + NftControllerAddNftsAction, NftControllerRemoveNftAction, NftControllerRemoveAndIgnoreNftAction, NftControllerCheckAndUpdateSingleNftOwnershipStatusAction, From 03be254853a323d554b9c8355e99f5e1ffe3406e Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 5 Nov 2026 10:18:18 +0000 Subject: [PATCH 2/4] test(assets-controllers): cast mocked network clients through unknown Co-authored-by: Xiaoming Wang --- .../assets-controllers/src/AccountTrackerController.test.ts | 4 +++- packages/assets-controllers/src/TokensController.test.ts | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/packages/assets-controllers/src/AccountTrackerController.test.ts b/packages/assets-controllers/src/AccountTrackerController.test.ts index 05b9ba43f09..07b4c6798bb 100644 --- a/packages/assets-controllers/src/AccountTrackerController.test.ts +++ b/packages/assets-controllers/src/AccountTrackerController.test.ts @@ -203,7 +203,9 @@ describe('AccountTrackerController', () => { rootMessenger.registerActionHandler( 'NetworkController:getNetworkClientById', () => - ({ configuration: { chainId: initialChainId } }) as ReturnType< + ({ + configuration: { chainId: initialChainId }, + }) as unknown as ReturnType< NetworkControllerGetNetworkClientByIdAction['handler'] >, ); diff --git a/packages/assets-controllers/src/TokensController.test.ts b/packages/assets-controllers/src/TokensController.test.ts index 1365674b3c0..c57c842b54c 100644 --- a/packages/assets-controllers/src/TokensController.test.ts +++ b/packages/assets-controllers/src/TokensController.test.ts @@ -3447,7 +3447,7 @@ describe('TokensController', () => { () => ({ configuration: { chainId: ChainId.mainnet }, - }) as ReturnType< + }) as unknown as ReturnType< NetworkControllerGetNetworkClientByIdAction['handler'] >, ); From a6abb55116f6fa30278d0e38ee8bea8f0e666ec5 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 5 Nov 2026 10:18:18 +0000 Subject: [PATCH 3/4] feat(wallet): add assets-controllers controllers to the default configurations Adds the 16 messenger-based @metamask/assets-controllers controllers to the wallet's default initialization configurations. Each configuration delegates the actions and events its controller's messenger declares, builds callback options from messenger calls so construction order does not matter, and defaults the token prices and token list services. Wallet.init() runs the controllers' init methods. Co-authored-by: Xiaoming Wang --- .github/CODEOWNERS | 1 + codeowners.ts | 1 + packages/wallet/CHANGELOG.md | 12 + packages/wallet/package.json | 1 + packages/wallet/src/Wallet.test.ts | 30 +- .../account-tracker-controller.ts | 70 ++ .../assets-contract-controller.ts | 40 + .../assets-controllers.test.ts | 894 ++++++++++++++++++ .../currency-rate-controller.ts | 43 + .../defi-positions-controller.ts | 37 + .../multichain-assets-controller.ts | 43 + .../multichain-assets-rates-controller.ts | 45 + .../multichain-balances-controller.ts | 43 + .../assets-controllers/nft-controller.ts | 47 + .../nft-detection-controller.ts | 69 ++ .../assets-controllers/rates-controller.ts | 28 + .../token-balances-controller.ts | 59 ++ .../token-detection-controller.ts | 85 ++ .../token-list-controller.ts | 43 + .../token-rates-controller.ts | 45 + .../token-search-discovery-data-controller.ts | 37 + .../assets-controllers/tokens-controller.ts | 52 + .../instances/assets-controllers/types.ts | 188 ++++ .../src/initialization/instances/index.ts | 16 + packages/wallet/src/types.ts | 34 + packages/wallet/tsconfig.build.json | 3 + packages/wallet/tsconfig.json | 3 + packages/wallet/tsconfig.lint.json | 3 + yarn.lock | 1 + 29 files changed, 1972 insertions(+), 1 deletion(-) create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/account-tracker-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/assets-contract-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/assets-controllers.test.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/currency-rate-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/defi-positions-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-rates-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/multichain-balances-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/nft-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/nft-detection-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/rates-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/token-balances-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/token-detection-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/token-list-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/token-rates-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/token-search-discovery-data-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/tokens-controller.ts create mode 100644 packages/wallet/src/initialization/instances/assets-controllers/types.ts diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 0add82d6343..8f9b14a2bee 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -897,6 +897,7 @@ /packages/wallet/src/initialization/instances/accounts-controller/ @MetaMask/accounts-engineers /packages/wallet/src/initialization/instances/address-book-controller/ @MetaMask/confirmations /packages/wallet/src/initialization/instances/approval-controller/ @MetaMask/confirmations +/packages/wallet/src/initialization/instances/assets-controllers/ @MetaMask/metamask-assets /packages/wallet/src/initialization/instances/claims-controller/ @MetaMask/web3auth /packages/wallet/src/initialization/instances/claims-service/ @MetaMask/web3auth /packages/wallet/src/initialization/instances/client-controller/ @MetaMask/core-platform @MetaMask/extension-platform @MetaMask/mobile-platform diff --git a/codeowners.ts b/codeowners.ts index 17eab35aaae..e4e7272ed96 100644 --- a/codeowners.ts +++ b/codeowners.ts @@ -47,6 +47,7 @@ const config = { }, 'assets-controllers': { teams: ['@MetaMask/metamask-assets'], + initializationPath: 'assets-controllers', }, 'authenticated-user-storage': { teams: ['@MetaMask/auth-engineers'], diff --git a/packages/wallet/CHANGELOG.md b/packages/wallet/CHANGELOG.md index 8f4cebbb835..e283778d41d 100644 --- a/packages/wallet/CHANGELOG.md +++ b/packages/wallet/CHANGELOG.md @@ -7,8 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +### Added + +- **BREAKING:** Add the `@metamask/assets-controllers` controllers to the default initialization configurations ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) + - Adds `AccountTrackerController`, `AssetsContractController`, `CurrencyRateController`, `DeFiPositionsController`, `MultichainAssetsController`, `MultichainAssetsRatesController`, `MultichainBalancesController`, `NftController`, `NftDetectionController`, `RatesController`, `TokenBalancesController`, `TokenDetectionController`, `TokenListController`, `TokenRatesController`, `TokensController` and `TokenSearchDiscoveryDataController`. + - Hosts that already register any of these controllers on the wallet root messenger must remove that registration before upgrading, or messenger registration will collide. + - Their constructors call no other controller, so they can be constructed in any order. `Wallet.init()` calls their `init` methods, which read the other controllers and start the initial fetches. Polling is still started by the client. + - Delegates the external actions and events each controller's messenger declares. `Wallet` does not construct `PreferencesController`, `SnapController`, `PhishingController`, `AccountTreeController`, `AuthenticationController` or `AccountActivityService`; clients must register them on the wallet messenger. `wallet.init()` does not fail when they are missing, but the controllers read `PreferencesController:getState` as soon as accounts, networks or the keyring change, so register it before unlocking the wallet. + - `AccountTrackerController`'s `getStakedBalanceForChain` and `TokenDetectionController`'s `getBalancesInSingleCall` call `AssetsContractController` through the messenger, and `NftDetectionController`'s `addNfts`, `removeNft` and `getNftState` call `NftController`. + - `CurrencyRateController`, `TokenRatesController` and `TokenSearchDiscoveryDataController` default `tokenPricesService` to a `CodefiTokenPricesServiceV2`. `TokensController` and `TokenDetectionController` default `tokenListService` to a `TokenListService`. `AssetsContractController` and `TokenListController` default `chainId` to Ethereum mainnet. Every option can be overridden through `instanceOptions`. + - `DeFiPositionsController`, `NftDetectionController` and `TokenDetectionController` take no persisted state. + ### Changed +- Add `@metamask/assets-controllers` `^113.1.1` as a dependency ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) - Bump `@metamask/gas-fee-controller` from `^27.0.0` to `^27.1.0` ([#11289](https://github.com/MetaMask/core/pull/11289)) - Bump `@metamask/subscription-controller` from `^15.1.2` to `^15.2.0` ([#11289](https://github.com/MetaMask/core/pull/11289)) - Bump `@metamask/transaction-controller` from `^73.0.0` to `^73.1.1` ([#11289](https://github.com/MetaMask/core/pull/11289), [#11300](https://github.com/MetaMask/core/pull/11300)) diff --git a/packages/wallet/package.json b/packages/wallet/package.json index e0aab266cac..9125c169a8c 100644 --- a/packages/wallet/package.json +++ b/packages/wallet/package.json @@ -55,6 +55,7 @@ "@metamask/address-book-controller": "^8.0.0", "@metamask/analytics-controller": "^4.1.0", "@metamask/approval-controller": "^10.0.0", + "@metamask/assets-controllers": "^113.1.1", "@metamask/base-controller": "^10.1.0", "@metamask/browser-passworder": "^6.0.0", "@metamask/claims-controller": "^1.1.0", diff --git a/packages/wallet/src/Wallet.test.ts b/packages/wallet/src/Wallet.test.ts index 1cc3dbad7a3..ddb16ea1393 100644 --- a/packages/wallet/src/Wallet.test.ts +++ b/packages/wallet/src/Wallet.test.ts @@ -72,11 +72,37 @@ function getInstanceOptions(): WalletOptions['instanceOptions'] { }; } +/** + * Registers a stub `PreferencesController:getState` on the wallet messenger. + * Clients register `PreferencesController` themselves; the assets + * controllers read it once accounts and networks change. + * + * @param wallet - The wallet. + */ +function registerPreferencesController(wallet: Wallet): void { + const messenger = new Messenger({ + namespace: 'PreferencesController', + parent: wallet.messenger as unknown as Messenger, + }); + + ( + messenger as unknown as { + registerActionHandler(type: string, handler: () => unknown): void; + } + ).registerActionHandler('PreferencesController:getState', () => ({ + isMultiAccountBalancesEnabled: false, + useTokenDetection: false, + useNftDetection: false, + })); +} + async function setupWallet(): Promise { const wallet = new Wallet({ instanceOptions: getInstanceOptions(), }); + registerPreferencesController(wallet); + await importSecretRecoveryPhrase(wallet, TEST_PASSWORD, TEST_SRP); return wallet; @@ -117,6 +143,7 @@ describe('Wallet', () => { }, }, }); + registerPreferencesController(wallet); await importSecretRecoveryPhrase(wallet, TEST_PASSWORD, TEST_SRP); @@ -199,7 +226,7 @@ describe('Wallet', () => { const results = await wallet.init(); - expect(results).toHaveLength(10); + expect(results).toHaveLength(20); }); it('disallows modifying the messenger', async () => { @@ -360,6 +387,7 @@ describe('Wallet', () => { }, instanceOptions: getInstanceOptions(), }); + registerPreferencesController(wallet); await wallet.messenger.call( 'KeyringController:submitPassword', diff --git a/packages/wallet/src/initialization/instances/assets-controllers/account-tracker-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/account-tracker-controller.ts new file mode 100644 index 00000000000..adca61cb530 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/account-tracker-controller.ts @@ -0,0 +1,70 @@ +import { AccountTrackerController } from '@metamask/assets-controllers'; +import type { + AccountTrackerControllerMessenger, + AssetsContractControllerGetStakedBalanceForChainAction, +} from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; +import type { MessengerActions, MessengerEvents } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +/** + * The `AccountTrackerController` messenger, which can also reach + * `AssetsContractController` for staked balances. + */ +export type AccountTrackerControllerInstanceMessenger = Messenger< + 'AccountTrackerController', + | MessengerActions + | AssetsContractControllerGetStakedBalanceForChainAction, + MessengerEvents +>; + +export const accountTrackerController: InitializationConfiguration< + AccountTrackerController, + AccountTrackerControllerInstanceMessenger +> = { + name: 'AccountTrackerController', + reference: AccountTrackerController, + init: ({ state, messenger, options }) => + new AccountTrackerController({ + ...options, + messenger, + state, + getStakedBalanceForChain: async (...args) => + messenger.call( + 'AssetsContractController:getStakedBalanceForChain', + ...args, + ), + }), + getMessenger: (parent) => { + const messenger: AccountTrackerControllerInstanceMessenger = new Messenger({ + namespace: 'AccountTrackerController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:getSelectedAccount', + 'AccountsController:listAccounts', + 'AssetsContractController:getStakedBalanceForChain', + 'KeyringController:getState', + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + 'NetworkEnablementController:getState', + 'NetworkEnablementController:listPopularEvmNetworks', + 'PreferencesController:getState', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:lock', + 'KeyringController:unlock', + 'NetworkController:networkAdded', + 'TransactionController:transactionConfirmed', + 'TransactionController:unapprovedTransactionAdded', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/assets-contract-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/assets-contract-controller.ts new file mode 100644 index 00000000000..ec760dcaa95 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/assets-contract-controller.ts @@ -0,0 +1,40 @@ +import { AssetsContractController } from '@metamask/assets-controllers'; +import type { AssetsContractControllerMessenger } from '@metamask/assets-controllers'; +import { ChainId } from '@metamask/controller-utils'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const assetsContractController: InitializationConfiguration< + AssetsContractController, + AssetsContractControllerMessenger +> = { + name: 'AssetsContractController', + init: ({ messenger, options }) => + new AssetsContractController({ + messenger, + chainId: options.chainId ?? ChainId.mainnet, + }), + getMessenger: (parent) => { + const messenger: AssetsContractControllerMessenger = new Messenger({ + namespace: 'AssetsContractController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'NetworkController:getNetworkClientById', + 'NetworkController:getNetworkConfigurationByNetworkClientId', + 'NetworkController:getSelectedNetworkClient', + 'NetworkController:getState', + ], + events: [ + 'NetworkController:networkDidChange', + 'PreferencesController:stateChange', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/assets-controllers.test.ts b/packages/wallet/src/initialization/instances/assets-controllers/assets-controllers.test.ts new file mode 100644 index 00000000000..af5164e2a5b --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/assets-controllers.test.ts @@ -0,0 +1,894 @@ +import { + AccountTrackerController, + AssetsContractController, + CodefiTokenPricesServiceV2, + CurrencyRateController, + DeFiPositionsController, + MultichainAssetsController, + MultichainAssetsRatesController, + MultichainBalancesController, + NftController, + NftDetectionController, + RatesController, + TokenBalancesController, + TokenDetectionController, + TokenListController, + TokenListService, + TokenRatesController, + TokensController, + TokenSearchDiscoveryDataController, +} from '@metamask/assets-controllers'; +import { ConfigRegistryApiEnv } from '@metamask/config-registry-controller'; +import { Messenger } from '@metamask/messenger'; +import { InMemoryStorageAdapter } from '@metamask/storage-service'; +import { afterEach, describe, expect, it, vi } from 'vitest'; + +import type { WalletOptions } from '../../../types.js'; +import { Wallet } from '../../../Wallet.js'; +import { defaultConfigurations } from '../../defaults.js'; +import type { + DefaultActions, + DefaultEvents, + RootMessenger, +} from '../../defaults.js'; +import { AlwaysOnlineAdapter } from '../connectivity-controller/always-online-adapter.js'; +import { accountTrackerController } from './account-tracker-controller.js'; +import { assetsContractController } from './assets-contract-controller.js'; +import { currencyRateController } from './currency-rate-controller.js'; +import { deFiPositionsController } from './defi-positions-controller.js'; +import { multichainAssetsController } from './multichain-assets-controller.js'; +import { multichainAssetsRatesController } from './multichain-assets-rates-controller.js'; +import { multichainBalancesController } from './multichain-balances-controller.js'; +import { nftController } from './nft-controller.js'; +import { nftDetectionController } from './nft-detection-controller.js'; +import { ratesController } from './rates-controller.js'; +import { tokenBalancesController } from './token-balances-controller.js'; +import { tokenDetectionController } from './token-detection-controller.js'; +import { tokenListController } from './token-list-controller.js'; +import { tokenRatesController } from './token-rates-controller.js'; +import { tokenSearchDiscoveryDataController } from './token-search-discovery-data-controller.js'; +import { tokensController } from './tokens-controller.js'; + +const { constructorOptions, recordConstructorOptions } = vi.hoisted(() => { + type AnyConstructor = new (options: Record) => object; + + const options = new Map>(); + + return { + constructorOptions: options, + recordConstructorOptions: (base: unknown): AnyConstructor => { + const Base = base as AnyConstructor; + return class extends Base { + constructor(controllerOptions: Record) { + options.set(Base.name, controllerOptions); + super(controllerOptions); + } + }; + }, + }; +}); + +// Wraps each controller in a subclass that records the options it is +// constructed with, so the options built by `init` can be inspected. +vi.mock(import('@metamask/assets-controllers'), async (importOriginal) => { + const actual = await importOriginal(); + + return { + ...actual, + AccountTrackerController: recordConstructorOptions( + actual.AccountTrackerController, + ) as unknown as typeof actual.AccountTrackerController, + AssetsContractController: recordConstructorOptions( + actual.AssetsContractController, + ) as unknown as typeof actual.AssetsContractController, + CurrencyRateController: recordConstructorOptions( + actual.CurrencyRateController, + ) as unknown as typeof actual.CurrencyRateController, + DeFiPositionsController: recordConstructorOptions( + actual.DeFiPositionsController, + ) as unknown as typeof actual.DeFiPositionsController, + MultichainAssetsController: recordConstructorOptions( + actual.MultichainAssetsController, + ) as unknown as typeof actual.MultichainAssetsController, + MultichainAssetsRatesController: recordConstructorOptions( + actual.MultichainAssetsRatesController, + ) as unknown as typeof actual.MultichainAssetsRatesController, + MultichainBalancesController: recordConstructorOptions( + actual.MultichainBalancesController, + ) as unknown as typeof actual.MultichainBalancesController, + NftController: recordConstructorOptions( + actual.NftController, + ) as unknown as typeof actual.NftController, + NftDetectionController: recordConstructorOptions( + actual.NftDetectionController, + ) as unknown as typeof actual.NftDetectionController, + RatesController: recordConstructorOptions( + actual.RatesController, + ) as unknown as typeof actual.RatesController, + TokenBalancesController: recordConstructorOptions( + actual.TokenBalancesController, + ) as unknown as typeof actual.TokenBalancesController, + TokenDetectionController: recordConstructorOptions( + actual.TokenDetectionController, + ) as unknown as typeof actual.TokenDetectionController, + TokenListController: recordConstructorOptions( + actual.TokenListController, + ) as unknown as typeof actual.TokenListController, + TokenRatesController: recordConstructorOptions( + actual.TokenRatesController, + ) as unknown as typeof actual.TokenRatesController, + TokensController: recordConstructorOptions( + actual.TokensController, + ) as unknown as typeof actual.TokensController, + TokenSearchDiscoveryDataController: recordConstructorOptions( + actual.TokenSearchDiscoveryDataController, + ) as unknown as typeof actual.TokenSearchDiscoveryDataController, + }; +}); + +type ActionHandler = (...args: unknown[]) => unknown; + +type AnyMessenger = Messenger; + +type LooseInstance = { + state?: unknown; + destroy?: () => void; +}; + +/** + * The shape shared by every configuration under test, without the + * controller-specific types, so the configurations can be driven from one + * table. + */ +type LooseConfiguration = { + name: string; + init(args: { + state: unknown; + messenger: unknown; + options: Record; + }): LooseInstance; + getMessenger(parent: RootMessenger): unknown; +}; + +type ConfigurationTestCase = { + configuration: LooseConfiguration; + reference: abstract new (...args: never[]) => unknown; + actions: string[]; + events: string[]; + forwardsState: boolean; + options: Record; +}; + +const tokenPricesService = new CodefiTokenPricesServiceV2(); +const tokenListService = new TokenListService(); + +const TEST_CASES: ConfigurationTestCase[] = [ + { + configuration: accountTrackerController as unknown as LooseConfiguration, + reference: AccountTrackerController, + actions: [ + 'AccountsController:getSelectedAccount', + 'AccountsController:listAccounts', + 'AssetsContractController:getStakedBalanceForChain', + 'KeyringController:getState', + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + 'NetworkEnablementController:getState', + 'NetworkEnablementController:listPopularEvmNetworks', + 'PreferencesController:getState', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:lock', + 'KeyringController:unlock', + 'NetworkController:networkAdded', + 'TransactionController:transactionConfirmed', + 'TransactionController:unapprovedTransactionAdded', + ], + forwardsState: true, + options: { interval: 5_000, includeStakedAssets: true }, + }, + { + configuration: assetsContractController as unknown as LooseConfiguration, + reference: AssetsContractController, + actions: [ + 'NetworkController:getNetworkClientById', + 'NetworkController:getNetworkConfigurationByNetworkClientId', + 'NetworkController:getSelectedNetworkClient', + 'NetworkController:getState', + ], + events: [ + 'NetworkController:networkDidChange', + 'PreferencesController:stateChange', + ], + forwardsState: false, + options: { chainId: '0x5' }, + }, + { + configuration: currencyRateController, + reference: CurrencyRateController, + actions: [ + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + ], + events: [], + forwardsState: true, + options: { interval: 5_000, tokenPricesService }, + }, + { + configuration: deFiPositionsController as unknown as LooseConfiguration, + reference: DeFiPositionsController, + actions: ['AccountTreeController:getAccountsFromSelectedAccountGroup'], + events: [ + 'AccountTreeController:selectedAccountGroupChange', + 'KeyringController:lock', + 'TransactionController:transactionConfirmed', + ], + forwardsState: false, + options: { trackEvent: vi.fn() }, + }, + { + configuration: multichainAssetsController as unknown as LooseConfiguration, + reference: MultichainAssetsController, + actions: [ + 'AccountsController:listMultichainAccounts', + 'PermissionController:getPermissions', + 'PhishingController:bulkScanTokens', + 'SnapController:getRunnableSnaps', + 'SnapController:handleRequest', + ], + events: [ + 'AccountsController:accountAdded', + 'AccountsController:accountAssetListUpdated', + 'AccountsController:accountRemoved', + ], + forwardsState: true, + options: { blockaidTokenRescanInterval: 0 }, + }, + { + configuration: + multichainAssetsRatesController as unknown as LooseConfiguration, + reference: MultichainAssetsRatesController, + actions: [ + 'AccountsController:getSelectedMultichainAccount', + 'AccountsController:listMultichainAccounts', + 'CurrencyRateController:getState', + 'MultichainAssetsController:getState', + 'SnapController:handleRequest', + ], + events: [ + 'AccountsController:accountAdded', + 'CurrencyRateController:stateChange', + 'KeyringController:lock', + 'KeyringController:unlock', + 'MultichainAssetsController:accountAssetListUpdated', + ], + forwardsState: true, + options: { interval: 5_000 }, + }, + { + configuration: + multichainBalancesController as unknown as LooseConfiguration, + reference: MultichainBalancesController, + actions: [ + 'AccountsController:listMultichainAccounts', + 'KeyringController:getState', + 'MultichainAssetsController:getState', + 'SnapController:handleRequest', + ], + events: [ + 'AccountsController:accountAdded', + 'AccountsController:accountBalancesUpdated', + 'AccountsController:accountRemoved', + 'MultichainAssetsController:accountAssetListUpdated', + ], + forwardsState: true, + options: { isDeprecated: (): boolean => false }, + }, + { + configuration: nftController as unknown as LooseConfiguration, + reference: NftController, + actions: [ + 'AccountsController:getAccount', + 'AccountsController:getSelectedAccount', + 'ApprovalController:addRequest', + 'AssetsContractController:getERC1155TokenURI', + 'AssetsContractController:getERC721AssetName', + 'AssetsContractController:getERC721AssetSymbol', + 'AssetsContractController:getERC721TokenURI', + 'NetworkController:findNetworkClientIdByChainId', + 'NetworkController:getNetworkClientById', + 'PhishingController:bulkScanUrls', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'PreferencesController:stateChange', + ], + forwardsState: true, + options: { displayNftMedia: true }, + }, + { + configuration: nftDetectionController as unknown as LooseConfiguration, + reference: NftDetectionController, + actions: [ + 'AccountsController:getSelectedAccount', + 'ApprovalController:addRequest', + 'NetworkController:findNetworkClientIdByChainId', + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + 'NftController:addNfts', + 'NftController:getState', + 'NftController:removeNft', + 'PreferencesController:getState', + ], + events: [ + 'NetworkController:stateChange', + 'PreferencesController:stateChange', + ], + forwardsState: false, + options: { disabled: true }, + }, + { + configuration: ratesController as unknown as LooseConfiguration, + reference: RatesController, + actions: [], + events: [], + forwardsState: true, + options: { includeUsdRate: true }, + }, + { + configuration: tokenBalancesController, + reference: TokenBalancesController, + actions: [ + 'AccountTrackerController:getState', + 'AccountTrackerController:updateNativeBalances', + 'AccountTrackerController:updateStakedBalances', + 'AccountsController:getSelectedAccount', + 'AccountsController:listAccounts', + 'AuthenticationController:getBearerToken', + 'KeyringController:getState', + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + 'PreferencesController:getState', + 'TokenDetectionController:addDetectedTokensViaPolling', + 'TokenDetectionController:addDetectedTokensViaWs', + 'TokenDetectionController:detectTokens', + 'TokensController:getState', + ], + events: [ + 'AccountActivityService:balanceUpdated', + 'AccountActivityService:statusChanged', + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:accountRemoved', + 'KeyringController:lock', + 'KeyringController:unlock', + 'NetworkController:stateChange', + 'PreferencesController:stateChange', + 'TokensController:stateChange', + 'TransactionController:transactionConfirmed', + ], + forwardsState: true, + options: { platform: 'mobile' }, + }, + { + configuration: tokenDetectionController as unknown as LooseConfiguration, + reference: TokenDetectionController, + actions: [ + 'AccountsController:getAccount', + 'AccountsController:getSelectedAccount', + 'AssetsContractController:getBalancesInSingleCall', + 'AuthenticationController:getBearerToken', + 'KeyringController:getState', + 'NetworkController:findNetworkClientIdByChainId', + 'NetworkController:getNetworkClientById', + 'NetworkController:getNetworkConfigurationByNetworkClientId', + 'NetworkController:getState', + 'PreferencesController:getState', + 'TokensController:addDetectedTokens', + 'TokensController:addTokens', + 'TokensController:getState', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:lock', + 'KeyringController:unlock', + 'NetworkController:networkDidChange', + 'PreferencesController:stateChange', + 'TransactionController:transactionConfirmed', + ], + forwardsState: false, + options: { tokenListService, trackMetaMetricsEvent: vi.fn() }, + }, + { + configuration: tokenListController, + reference: TokenListController, + actions: [ + 'NetworkController:getNetworkClientById', + 'StorageService:getAllKeys', + 'StorageService:getItem', + 'StorageService:setItem', + ], + events: ['NetworkController:stateChange'], + forwardsState: true, + options: { chainId: '0x5' }, + }, + { + configuration: tokenRatesController as unknown as LooseConfiguration, + reference: TokenRatesController, + actions: [ + 'NetworkController:getState', + 'NetworkEnablementController:getState', + 'TokensController:getState', + ], + events: ['NetworkController:stateChange', 'TokensController:stateChange'], + forwardsState: true, + options: { interval: 5_000, tokenPricesService }, + }, + { + configuration: tokensController as unknown as LooseConfiguration, + reference: TokensController, + actions: [ + 'AccountsController:getAccount', + 'AccountsController:getSelectedAccount', + 'AccountsController:listAccounts', + 'ApprovalController:addRequest', + 'NetworkController:getNetworkClientById', + 'NetworkController:getSelectedNetworkClient', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:accountRemoved', + 'NetworkController:networkDidChange', + 'NetworkController:stateChange', + ], + forwardsState: true, + options: { tokenListService }, + }, + { + configuration: + tokenSearchDiscoveryDataController as unknown as LooseConfiguration, + reference: TokenSearchDiscoveryDataController, + actions: ['CurrencyRateController:getState'], + events: [], + forwardsState: true, + options: { tokenPricesService }, + }, +]; + +const wallets: Wallet[] = []; +const instances: LooseInstance[] = []; + +describe('assets-controllers configurations', () => { + afterEach(async () => { + for (const instance of instances.splice(0)) { + instance.destroy?.(); + } + await Promise.all( + wallets.splice(0).map(async (wallet) => wallet.destroy()), + ); + constructorOptions.clear(); + }); + + describe.each(TEST_CASES)( + '$configuration.name configuration', + ({ configuration, reference, actions, events, forwardsState, options }) => { + it('is registered as a default initialization configuration', () => { + expect(Object.values(defaultConfigurations)).toContain(configuration); + }); + + it('constructs without calling controllers that are not registered', () => { + const instance = initConfiguration(configuration, getRootMessenger()); + + expect(instance).toBeInstanceOf(reference); + }); + + it('forwards the provided options to the controller', () => { + initConfiguration(configuration, getRootMessenger(), { options }); + + expect(constructorOptions.get(configuration.name)).toStrictEqual( + expect.objectContaining(options), + ); + }); + + const state = { persisted: true }; + const expectedState = forwardsState ? state : undefined; + const stateBehavior = forwardsState ? 'forwards' : 'does not forward'; + + it(`${stateBehavior} the provided state`, () => { + initConfiguration(configuration, getRootMessenger(), { state }); + + expect(constructorOptions.get(configuration.name)?.state).toBe( + expectedState, + ); + }); + + it.each(actions)('delegates the %s action', (actionType) => { + const rootMessenger = getRootMessenger(); + const handler = vi.fn().mockReturnValue('result'); + registerActionHandler(rootMessenger, actionType, handler); + const messenger = configuration.getMessenger(rootMessenger); + + const result = (messenger as { call(type: string): unknown }).call( + actionType, + ); + + expect(handler).toHaveBeenCalledTimes(1); + expect(result).toBe('result'); + }); + + it.each(events)('delegates the %s event', (eventType) => { + const rootMessenger = getRootMessenger(); + const messenger = configuration.getMessenger(rootMessenger); + const listener = vi.fn(); + ( + messenger as { + subscribe(type: string, handler: ActionHandler): void; + } + ).subscribe(eventType, listener); + + publishEvent(rootMessenger, eventType, 'payload'); + + expect(listener).toHaveBeenCalledWith('payload'); + }); + }, + ); + + describe('assets-controllers configuration defaults', () => { + it.each([ + currencyRateController, + tokenRatesController, + tokenSearchDiscoveryDataController, + ] as unknown as LooseConfiguration[])( + 'defaults $name tokenPricesService to a CodefiTokenPricesServiceV2', + (configuration) => { + initConfiguration(configuration, getRootMessenger()); + + expect( + constructorOptions.get(configuration.name)?.tokenPricesService, + ).toBeInstanceOf(CodefiTokenPricesServiceV2); + }, + ); + + it.each([ + tokensController, + tokenDetectionController, + ] as unknown as LooseConfiguration[])( + 'defaults $name tokenListService to a TokenListService', + (configuration) => { + initConfiguration(configuration, getRootMessenger()); + + expect( + constructorOptions.get(configuration.name)?.tokenListService, + ).toBeInstanceOf(TokenListService); + }, + ); + + it.each([ + assetsContractController, + tokenListController, + ] as unknown as LooseConfiguration[])( + 'defaults $name chainId to Ethereum mainnet', + (configuration) => { + initConfiguration(configuration, getRootMessenger()); + + expect(constructorOptions.get(configuration.name)?.chainId).toBe('0x1'); + }, + ); + + it('defaults RatesController includeUsdRate to false', () => { + initConfiguration( + ratesController as unknown as LooseConfiguration, + getRootMessenger(), + ); + + expect(constructorOptions.get('RatesController')?.includeUsdRate).toBe( + false, + ); + }); + + it('defaults NftDetectionController disabled to false', () => { + initConfiguration( + nftDetectionController as unknown as LooseConfiguration, + getRootMessenger(), + ); + + expect(constructorOptions.get('NftDetectionController')?.disabled).toBe( + false, + ); + }); + + it('defaults TokenDetectionController trackMetaMetricsEvent to a no-op', () => { + initConfiguration( + tokenDetectionController as unknown as LooseConfiguration, + getRootMessenger(), + ); + + const { trackMetaMetricsEvent } = constructorOptions.get( + 'TokenDetectionController', + ) as { trackMetaMetricsEvent: (event: unknown) => unknown }; + + expect( + trackMetaMetricsEvent({ event: 'Token Detected' }), + ).toBeUndefined(); + }); + }); + + describe('assets-controllers messenger-backed callbacks', () => { + it('builds AccountTrackerController getStakedBalanceForChain from AssetsContractController', async () => { + const rootMessenger = getRootMessenger(); + const handler = vi.fn().mockResolvedValue({ '0x1': '0x0' }); + registerActionHandler( + rootMessenger, + 'AssetsContractController:getStakedBalanceForChain', + handler, + ); + initConfiguration( + accountTrackerController as unknown as LooseConfiguration, + rootMessenger, + ); + + const { getStakedBalanceForChain } = constructorOptions.get( + 'AccountTrackerController', + ) as { getStakedBalanceForChain: ActionHandler }; + + expect(await getStakedBalanceForChain(['0x1'], 'mainnet')).toStrictEqual({ + '0x1': '0x0', + }); + expect(handler).toHaveBeenCalledWith(['0x1'], 'mainnet'); + }); + + it('builds TokenDetectionController getBalancesInSingleCall from AssetsContractController', async () => { + const rootMessenger = getRootMessenger(); + const handler = vi.fn().mockResolvedValue({ '0x2': '0x1' }); + registerActionHandler( + rootMessenger, + 'AssetsContractController:getBalancesInSingleCall', + handler, + ); + initConfiguration( + tokenDetectionController as unknown as LooseConfiguration, + rootMessenger, + ); + + const { getBalancesInSingleCall } = constructorOptions.get( + 'TokenDetectionController', + ) as { getBalancesInSingleCall: ActionHandler }; + + expect( + await getBalancesInSingleCall('0x1', ['0x2'], 'mainnet'), + ).toStrictEqual({ '0x2': '0x1' }); + expect(handler).toHaveBeenCalledWith('0x1', ['0x2'], 'mainnet'); + }); + + it('builds the NftDetectionController callbacks from NftController', async () => { + const rootMessenger = getRootMessenger(); + const addNfts = vi.fn().mockResolvedValue(undefined); + const removeNft = vi.fn(); + const nftState = { allNfts: {} }; + const getState = vi.fn().mockReturnValue(nftState); + registerActionHandler(rootMessenger, 'NftController:addNfts', addNfts); + registerActionHandler( + rootMessenger, + 'NftController:removeNft', + removeNft, + ); + registerActionHandler(rootMessenger, 'NftController:getState', getState); + initConfiguration( + nftDetectionController as unknown as LooseConfiguration, + rootMessenger, + ); + + const callbacks = constructorOptions.get('NftDetectionController') as { + addNfts: ActionHandler; + removeNft: ActionHandler; + getNftState: ActionHandler; + }; + await callbacks.addNfts([], '0x1', 'mainnet'); + callbacks.removeNft('0x3', '1', 'mainnet'); + + expect(callbacks.getNftState()).toBe(nftState); + expect(addNfts).toHaveBeenCalledWith([], '0x1', 'mainnet'); + expect(removeNft).toHaveBeenCalledWith('0x3', '1', 'mainnet'); + }); + }); + + describe('assets-controllers in the default Wallet', () => { + it('constructs every controller without PreferencesController, SnapController or AccountTreeController', () => { + const wallet = createWallet(); + + for (const { configuration, reference } of TEST_CASES) { + expect( + wallet.getInstance(configuration.name as 'TokensController'), + ).toBeInstanceOf(reference); + } + }); + + it('runs the controllers init from wallet.init(), which fulfills without the client-registered controllers', async () => { + const references = [ + AccountTrackerController, + MultichainAssetsController, + MultichainAssetsRatesController, + MultichainBalancesController, + NftController, + TokenBalancesController, + TokenDetectionController, + TokenListController, + TokenRatesController, + TokensController, + ]; + const spies = references.map((reference) => + vi.spyOn(reference.prototype, 'init'), + ); + const wallet = createWallet(); + + await wallet.init(); + + for (const spy of spies) { + expect(spy).toHaveBeenCalledTimes(1); + } + const results = await Promise.allSettled( + spies.map(async (spy): Promise => spy.mock.results[0]?.value), + ); + expect(results.map(({ status }) => status)).toStrictEqual( + references.map(() => 'fulfilled'), + ); + }); + + it('destroys the controllers when the wallet is destroyed', async () => { + const spies = TEST_CASES.map(({ reference }) => reference) + .filter((reference) => 'destroy' in reference.prototype) + .map((reference) => + vi.spyOn(reference.prototype as { destroy: () => void }, 'destroy'), + ); + const wallet = createWallet(); + + await wallet.destroy(); + + expect(spies).toHaveLength(15); + for (const spy of spies) { + expect(spy).toHaveBeenCalled(); + } + }); + }); +}); + +/** + * Creates a root messenger for use in tests. + * + * @returns A root messenger. + */ +function getRootMessenger(): RootMessenger { + return new Messenger({ namespace: 'Root' }); +} + +/** + * Builds a configuration's messenger on `rootMessenger` and initializes its + * controller. + * + * @param configuration - The configuration to initialize. + * @param rootMessenger - The root messenger. + * @param args - The state and options to pass to `init`. + * @param args.state - The state. + * @param args.options - The instance options. + * @returns The controller. + */ +function initConfiguration( + configuration: LooseConfiguration, + rootMessenger: RootMessenger, + { + state, + options = {}, + }: { state?: unknown; options?: Record } = {}, +): LooseInstance { + const instance = configuration.init({ + state, + messenger: configuration.getMessenger(rootMessenger), + options, + }); + instances.push(instance); + return instance; +} + +/** + * Creates a `Wallet` with the default configurations. + * + * @returns The wallet. + */ +function createWallet(): Wallet { + const wallet = new Wallet({ instanceOptions: getInstanceOptions() }); + wallets.push(wallet); + return wallet; +} + +/** + * Builds the instance options that the default Wallet requires. + * + * @returns The instance options. + */ +function getInstanceOptions(): WalletOptions['instanceOptions'] { + return { + analyticsController: { + platformAdapter: { + track: vi.fn(), + identify: vi.fn(), + view: vi.fn(), + onSetupCompleted: vi.fn(), + }, + analyticsId: '11111111-1111-4111-8111-111111111111', + }, + configRegistryApiService: { + env: ConfigRegistryApiEnv.DEV, + }, + connectivityController: { + connectivityAdapter: new AlwaysOnlineAdapter(), + }, + gasFeeController: { + clientId: 'test', + }, + networkController: { + infuraProjectId: 'test-infura-project-id', + }, + remoteFeatureFlagController: { + clientConfigApiService: { + fetchRemoteFeatureFlags: async (): Promise<{ + remoteFeatureFlags: Record; + cacheTimestamp: number; + }> => ({ remoteFeatureFlags: {}, cacheTimestamp: Date.now() }), + }, + }, + selectedNetworkController: { + domainProxyMap: new Map(), + }, + storageService: { + storage: new InMemoryStorageAdapter(), + }, + }; +} + +/** + * Registers an action handler on `parent` under the action's namespace. + * + * @param parent - The root messenger. + * @param actionType - The action to register. + * @param handler - The handler. + */ +function registerActionHandler( + parent: RootMessenger, + actionType: string, + handler: ActionHandler, +): void { + const messenger = new Messenger({ + namespace: actionType.split(':')[0], + parent: parent as unknown as AnyMessenger, + }); + + ( + messenger as unknown as { + registerActionHandler(type: string, handler: ActionHandler): void; + } + ).registerActionHandler(actionType, handler); +} + +/** + * Publishes an event on `parent` under the event's namespace. + * + * @param parent - The root messenger. + * @param eventType - The event to publish. + * @param payload - The event payload. + */ +function publishEvent( + parent: RootMessenger, + eventType: string, + ...payload: unknown[] +): void { + const messenger = new Messenger({ + namespace: eventType.split(':')[0], + parent: parent as unknown as AnyMessenger, + }); + + ( + messenger as unknown as { + publish(type: string, ...payload: unknown[]): void; + } + ).publish(eventType, ...payload); +} diff --git a/packages/wallet/src/initialization/instances/assets-controllers/currency-rate-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/currency-rate-controller.ts new file mode 100644 index 00000000000..f1d30b938c3 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/currency-rate-controller.ts @@ -0,0 +1,43 @@ +import { + CodefiTokenPricesServiceV2, + CurrencyRateController, +} from '@metamask/assets-controllers'; +import type { CurrencyRateMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const currencyRateController: InitializationConfiguration< + CurrencyRateController, + CurrencyRateMessenger +> = { + name: 'CurrencyRateController', + reference: CurrencyRateController, + init: ({ state, messenger, options }) => { + const { tokenPricesService = new CodefiTokenPricesServiceV2(), ...rest } = + options; + + return new CurrencyRateController({ + ...rest, + messenger, + state, + tokenPricesService, + }); + }, + getMessenger: (parent) => { + const messenger: CurrencyRateMessenger = new Messenger({ + namespace: 'CurrencyRateController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/defi-positions-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/defi-positions-controller.ts new file mode 100644 index 00000000000..99921f8e803 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/defi-positions-controller.ts @@ -0,0 +1,37 @@ +import { DeFiPositionsController } from '@metamask/assets-controllers'; +import type { DeFiPositionsControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const deFiPositionsController: InitializationConfiguration< + DeFiPositionsController, + DeFiPositionsControllerMessenger +> = { + name: 'DeFiPositionsController', + reference: DeFiPositionsController, + // The controller always starts from its default state; it takes no `state`. + init: ({ messenger, options }) => + new DeFiPositionsController({ + ...options, + messenger, + }), + getMessenger: (parent) => { + const messenger: DeFiPositionsControllerMessenger = new Messenger({ + namespace: 'DeFiPositionsController', + parent, + }); + + parent.delegate({ + messenger, + actions: ['AccountTreeController:getAccountsFromSelectedAccountGroup'], + events: [ + 'AccountTreeController:selectedAccountGroupChange', + 'KeyringController:lock', + 'TransactionController:transactionConfirmed', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-controller.ts new file mode 100644 index 00000000000..abd08ab37ad --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-controller.ts @@ -0,0 +1,43 @@ +import { MultichainAssetsController } from '@metamask/assets-controllers'; +import type { MultichainAssetsControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const multichainAssetsController: InitializationConfiguration< + MultichainAssetsController, + MultichainAssetsControllerMessenger +> = { + name: 'MultichainAssetsController', + reference: MultichainAssetsController, + init: ({ state, messenger, options }) => + new MultichainAssetsController({ + ...options, + messenger, + state, + }), + getMessenger: (parent) => { + const messenger: MultichainAssetsControllerMessenger = new Messenger({ + namespace: 'MultichainAssetsController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:listMultichainAccounts', + 'PermissionController:getPermissions', + 'PhishingController:bulkScanTokens', + 'SnapController:getRunnableSnaps', + 'SnapController:handleRequest', + ], + events: [ + 'AccountsController:accountAdded', + 'AccountsController:accountAssetListUpdated', + 'AccountsController:accountRemoved', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-rates-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-rates-controller.ts new file mode 100644 index 00000000000..36dbd72282a --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/multichain-assets-rates-controller.ts @@ -0,0 +1,45 @@ +import { MultichainAssetsRatesController } from '@metamask/assets-controllers'; +import type { MultichainAssetsRatesControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const multichainAssetsRatesController: InitializationConfiguration< + MultichainAssetsRatesController, + MultichainAssetsRatesControllerMessenger +> = { + name: 'MultichainAssetsRatesController', + reference: MultichainAssetsRatesController, + init: ({ state, messenger, options }) => + new MultichainAssetsRatesController({ + ...options, + messenger, + state, + }), + getMessenger: (parent) => { + const messenger: MultichainAssetsRatesControllerMessenger = new Messenger({ + namespace: 'MultichainAssetsRatesController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:getSelectedMultichainAccount', + 'AccountsController:listMultichainAccounts', + 'CurrencyRateController:getState', + 'MultichainAssetsController:getState', + 'SnapController:handleRequest', + ], + events: [ + 'AccountsController:accountAdded', + 'CurrencyRateController:stateChange', + 'KeyringController:lock', + 'KeyringController:unlock', + 'MultichainAssetsController:accountAssetListUpdated', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/multichain-balances-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/multichain-balances-controller.ts new file mode 100644 index 00000000000..3003e35cd9f --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/multichain-balances-controller.ts @@ -0,0 +1,43 @@ +import { MultichainBalancesController } from '@metamask/assets-controllers'; +import type { MultichainBalancesControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const multichainBalancesController: InitializationConfiguration< + MultichainBalancesController, + MultichainBalancesControllerMessenger +> = { + name: 'MultichainBalancesController', + reference: MultichainBalancesController, + init: ({ state, messenger, options }) => + new MultichainBalancesController({ + ...options, + messenger, + state, + }), + getMessenger: (parent) => { + const messenger: MultichainBalancesControllerMessenger = new Messenger({ + namespace: 'MultichainBalancesController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:listMultichainAccounts', + 'KeyringController:getState', + 'MultichainAssetsController:getState', + 'SnapController:handleRequest', + ], + events: [ + 'AccountsController:accountAdded', + 'AccountsController:accountBalancesUpdated', + 'AccountsController:accountRemoved', + 'MultichainAssetsController:accountAssetListUpdated', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/nft-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/nft-controller.ts new file mode 100644 index 00000000000..2d669e06e05 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/nft-controller.ts @@ -0,0 +1,47 @@ +import { NftController } from '@metamask/assets-controllers'; +import type { NftControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const nftController: InitializationConfiguration< + NftController, + NftControllerMessenger +> = { + name: 'NftController', + reference: NftController, + init: ({ state, messenger, options }) => + new NftController({ + ...options, + messenger, + state, + }), + getMessenger: (parent) => { + const messenger: NftControllerMessenger = new Messenger({ + namespace: 'NftController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:getAccount', + 'AccountsController:getSelectedAccount', + 'ApprovalController:addRequest', + 'AssetsContractController:getERC1155TokenURI', + 'AssetsContractController:getERC721AssetName', + 'AssetsContractController:getERC721AssetSymbol', + 'AssetsContractController:getERC721TokenURI', + 'NetworkController:findNetworkClientIdByChainId', + 'NetworkController:getNetworkClientById', + 'PhishingController:bulkScanUrls', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'PreferencesController:stateChange', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/nft-detection-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/nft-detection-controller.ts new file mode 100644 index 00000000000..47973a37a6b --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/nft-detection-controller.ts @@ -0,0 +1,69 @@ +import { NftDetectionController } from '@metamask/assets-controllers'; +import type { + NftControllerAddNftsAction, + NftControllerGetStateAction, + NftControllerRemoveNftAction, + NftDetectionControllerMessenger, +} from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; +import type { MessengerActions, MessengerEvents } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +/** + * The `NftDetectionController` messenger, which can also reach + * `NftController` to store detected NFTs. + */ +export type NftDetectionControllerInstanceMessenger = Messenger< + 'NftDetectionController', + | MessengerActions + | NftControllerAddNftsAction + | NftControllerGetStateAction + | NftControllerRemoveNftAction, + MessengerEvents +>; + +export const nftDetectionController: InitializationConfiguration< + NftDetectionController, + NftDetectionControllerInstanceMessenger +> = { + name: 'NftDetectionController', + reference: NftDetectionController, + init: ({ messenger, options }) => + new NftDetectionController({ + messenger, + disabled: options.disabled ?? false, + addNfts: async (...args) => + messenger.call('NftController:addNfts', ...args), + removeNft: (...args) => + messenger.call('NftController:removeNft', ...args), + getNftState: () => messenger.call('NftController:getState'), + }), + getMessenger: (parent) => { + const messenger: NftDetectionControllerInstanceMessenger = new Messenger({ + namespace: 'NftDetectionController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:getSelectedAccount', + 'ApprovalController:addRequest', + 'NetworkController:findNetworkClientIdByChainId', + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + 'NftController:addNfts', + 'NftController:getState', + 'NftController:removeNft', + 'PreferencesController:getState', + ], + events: [ + 'NetworkController:stateChange', + 'PreferencesController:stateChange', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/rates-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/rates-controller.ts new file mode 100644 index 00000000000..f51a000f977 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/rates-controller.ts @@ -0,0 +1,28 @@ +import { RatesController } from '@metamask/assets-controllers'; +import type { RatesControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const ratesController: InitializationConfiguration< + RatesController, + RatesControllerMessenger +> = { + name: 'RatesController', + reference: RatesController, + init: ({ state, messenger, options }) => { + const { includeUsdRate = false, ...rest } = options; + + return new RatesController({ + ...rest, + includeUsdRate, + messenger, + state, + }); + }, + getMessenger: (parent) => + new Messenger({ + namespace: 'RatesController', + parent, + }), +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/token-balances-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/token-balances-controller.ts new file mode 100644 index 00000000000..0e40df567d3 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/token-balances-controller.ts @@ -0,0 +1,59 @@ +import { TokenBalancesController } from '@metamask/assets-controllers'; +import type { TokenBalancesControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const tokenBalancesController: InitializationConfiguration< + TokenBalancesController, + TokenBalancesControllerMessenger +> = { + name: 'TokenBalancesController', + reference: TokenBalancesController, + init: ({ state, messenger, options }) => + new TokenBalancesController({ + ...options, + messenger, + state, + }), + getMessenger: (parent) => { + const messenger: TokenBalancesControllerMessenger = new Messenger({ + namespace: 'TokenBalancesController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountTrackerController:getState', + 'AccountTrackerController:updateNativeBalances', + 'AccountTrackerController:updateStakedBalances', + 'AccountsController:getSelectedAccount', + 'AccountsController:listAccounts', + 'AuthenticationController:getBearerToken', + 'KeyringController:getState', + 'NetworkController:getNetworkClientById', + 'NetworkController:getState', + 'PreferencesController:getState', + 'TokenDetectionController:addDetectedTokensViaPolling', + 'TokenDetectionController:addDetectedTokensViaWs', + 'TokenDetectionController:detectTokens', + 'TokensController:getState', + ], + events: [ + 'AccountActivityService:balanceUpdated', + 'AccountActivityService:statusChanged', + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:accountRemoved', + 'KeyringController:lock', + 'KeyringController:unlock', + 'NetworkController:stateChange', + 'PreferencesController:stateChange', + 'TokensController:stateChange', + 'TransactionController:transactionConfirmed', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/token-detection-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/token-detection-controller.ts new file mode 100644 index 00000000000..ecd828359e1 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/token-detection-controller.ts @@ -0,0 +1,85 @@ +import { + TokenDetectionController, + TokenListService, +} from '@metamask/assets-controllers'; +import type { + AssetsContractControllerGetBalancesInSingleCallAction, + TokenDetectionControllerMessenger, +} from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; +import type { MessengerActions, MessengerEvents } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +/** + * The `TokenDetectionController` messenger, which can also reach + * `AssetsContractController` for balances. + */ +export type TokenDetectionControllerInstanceMessenger = Messenger< + 'TokenDetectionController', + | MessengerActions + | AssetsContractControllerGetBalancesInSingleCallAction, + MessengerEvents +>; + +export const tokenDetectionController: InitializationConfiguration< + TokenDetectionController, + TokenDetectionControllerInstanceMessenger +> = { + name: 'TokenDetectionController', + reference: TokenDetectionController, + init: ({ messenger, options }) => { + const { + tokenListService = new TokenListService(), + trackMetaMetricsEvent = (): void => undefined, + ...rest + } = options; + + return new TokenDetectionController({ + ...rest, + messenger, + tokenListService, + trackMetaMetricsEvent, + getBalancesInSingleCall: async (...args) => + messenger.call( + 'AssetsContractController:getBalancesInSingleCall', + ...args, + ), + }); + }, + getMessenger: (parent) => { + const messenger: TokenDetectionControllerInstanceMessenger = new Messenger({ + namespace: 'TokenDetectionController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:getAccount', + 'AccountsController:getSelectedAccount', + 'AssetsContractController:getBalancesInSingleCall', + 'AuthenticationController:getBearerToken', + 'KeyringController:getState', + 'NetworkController:findNetworkClientIdByChainId', + 'NetworkController:getNetworkClientById', + 'NetworkController:getNetworkConfigurationByNetworkClientId', + 'NetworkController:getState', + 'PreferencesController:getState', + 'TokensController:addDetectedTokens', + 'TokensController:addTokens', + 'TokensController:getState', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:lock', + 'KeyringController:unlock', + 'NetworkController:networkDidChange', + 'PreferencesController:stateChange', + 'TransactionController:transactionConfirmed', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/token-list-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/token-list-controller.ts new file mode 100644 index 00000000000..f40cd300c83 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/token-list-controller.ts @@ -0,0 +1,43 @@ +import { TokenListController } from '@metamask/assets-controllers'; +import type { TokenListControllerMessenger } from '@metamask/assets-controllers'; +import { ChainId } from '@metamask/controller-utils'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const tokenListController: InitializationConfiguration< + TokenListController, + TokenListControllerMessenger +> = { + name: 'TokenListController', + reference: TokenListController, + init: ({ state, messenger, options }) => { + const { chainId = ChainId.mainnet, ...rest } = options; + + return new TokenListController({ + ...rest, + chainId, + messenger, + state, + }); + }, + getMessenger: (parent) => { + const messenger: TokenListControllerMessenger = new Messenger({ + namespace: 'TokenListController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'NetworkController:getNetworkClientById', + 'StorageService:getAllKeys', + 'StorageService:getItem', + 'StorageService:setItem', + ], + events: ['NetworkController:stateChange'], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/token-rates-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/token-rates-controller.ts new file mode 100644 index 00000000000..9ccef5cb03b --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/token-rates-controller.ts @@ -0,0 +1,45 @@ +import { + CodefiTokenPricesServiceV2, + TokenRatesController, +} from '@metamask/assets-controllers'; +import type { TokenRatesControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const tokenRatesController: InitializationConfiguration< + TokenRatesController, + TokenRatesControllerMessenger +> = { + name: 'TokenRatesController', + reference: TokenRatesController, + init: ({ state, messenger, options }) => { + const { tokenPricesService = new CodefiTokenPricesServiceV2(), ...rest } = + options; + + return new TokenRatesController({ + ...rest, + messenger, + state, + tokenPricesService, + }); + }, + getMessenger: (parent) => { + const messenger: TokenRatesControllerMessenger = new Messenger({ + namespace: 'TokenRatesController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'NetworkController:getState', + 'NetworkEnablementController:getState', + 'TokensController:getState', + ], + events: ['NetworkController:stateChange', 'TokensController:stateChange'], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/token-search-discovery-data-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/token-search-discovery-data-controller.ts new file mode 100644 index 00000000000..2f1ebf88423 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/token-search-discovery-data-controller.ts @@ -0,0 +1,37 @@ +import { + CodefiTokenPricesServiceV2, + TokenSearchDiscoveryDataController, +} from '@metamask/assets-controllers'; +import type { TokenSearchDiscoveryDataControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const tokenSearchDiscoveryDataController: InitializationConfiguration< + TokenSearchDiscoveryDataController, + TokenSearchDiscoveryDataControllerMessenger +> = { + name: 'TokenSearchDiscoveryDataController', + reference: TokenSearchDiscoveryDataController, + init: ({ state, messenger, options }) => + new TokenSearchDiscoveryDataController({ + messenger, + state, + tokenPricesService: + options.tokenPricesService ?? new CodefiTokenPricesServiceV2(), + }), + getMessenger: (parent) => { + const messenger: TokenSearchDiscoveryDataControllerMessenger = + new Messenger({ + namespace: 'TokenSearchDiscoveryDataController', + parent, + }); + + parent.delegate({ + messenger, + actions: ['CurrencyRateController:getState'], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/tokens-controller.ts b/packages/wallet/src/initialization/instances/assets-controllers/tokens-controller.ts new file mode 100644 index 00000000000..d7891812370 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/tokens-controller.ts @@ -0,0 +1,52 @@ +import { + TokenListService, + TokensController, +} from '@metamask/assets-controllers'; +import type { TokensControllerMessenger } from '@metamask/assets-controllers'; +import { Messenger } from '@metamask/messenger'; + +import type { InitializationConfiguration } from '../../types.js'; + +export const tokensController: InitializationConfiguration< + TokensController, + TokensControllerMessenger +> = { + name: 'TokensController', + reference: TokensController, + init: ({ state, messenger, options }) => { + const { tokenListService = new TokenListService(), ...rest } = options; + + return new TokensController({ + ...rest, + messenger, + state, + tokenListService, + }); + }, + getMessenger: (parent) => { + const messenger: TokensControllerMessenger = new Messenger({ + namespace: 'TokensController', + parent, + }); + + parent.delegate({ + messenger, + actions: [ + 'AccountsController:getAccount', + 'AccountsController:getSelectedAccount', + 'AccountsController:listAccounts', + 'ApprovalController:addRequest', + 'NetworkController:getNetworkClientById', + 'NetworkController:getSelectedNetworkClient', + ], + events: [ + 'AccountsController:selectedEvmAccountChange', + 'KeyringController:accountRemoved', + 'NetworkController:networkDidChange', + 'NetworkController:stateChange', + ], + }); + + return messenger; + }, +}; diff --git a/packages/wallet/src/initialization/instances/assets-controllers/types.ts b/packages/wallet/src/initialization/instances/assets-controllers/types.ts new file mode 100644 index 00000000000..660217221d3 --- /dev/null +++ b/packages/wallet/src/initialization/instances/assets-controllers/types.ts @@ -0,0 +1,188 @@ +import type { + AccountTrackerController, + CurrencyRateController, + DeFiPositionsController, + MultichainAssetsController, + MultichainAssetsRatesController, + MultichainBalancesController, + NftController, + RatesController, + TokenBalancesControllerOptions, + TokenDetectionController, + TokenListController, + TokenRatesController, + TokensController, + TokenSearchDiscoveryDataController, +} from '@metamask/assets-controllers'; +import type { Hex } from '@metamask/utils'; + +type ConstructorOptions< + Controller extends abstract new (...args: never) => unknown, +> = ConstructorParameters[0]; + +type TokenDetectionControllerOptions = ConstructorOptions< + typeof TokenDetectionController +>; + +/** + * Per-instance options for the wallet's `AccountTrackerController`. Every + * field falls back to the controller's own default. + * `getStakedBalanceForChain` is wired to `AssetsContractController` through + * the messenger. + */ +export type AccountTrackerControllerInstanceOptions = Omit< + ConstructorOptions, + 'messenger' | 'state' | 'getStakedBalanceForChain' +>; + +/** + * Per-instance options for the wallet's `AssetsContractController`. + */ +export type AssetsContractControllerInstanceOptions = { + /** + * The chain the controller starts on, until the selected network is read. + * Defaults to Ethereum mainnet. + */ + chainId?: Hex; +}; + +/** + * Per-instance options for the wallet's `CurrencyRateController`. Every field + * falls back to the controller's own default; `tokenPricesService` defaults + * to a `CodefiTokenPricesServiceV2`. + */ +export type CurrencyRateControllerInstanceOptions = Partial< + Omit, 'messenger' | 'state'> +>; + +/** + * Per-instance options for the wallet's `DeFiPositionsController`. Every + * field falls back to the controller's own default. + */ +export type DeFiPositionsControllerInstanceOptions = Omit< + ConstructorOptions, + 'messenger' +>; + +/** + * Per-instance options for the wallet's `MultichainAssetsController`. Every + * field falls back to the controller's own default. + */ +export type MultichainAssetsControllerInstanceOptions = Omit< + ConstructorOptions, + 'messenger' | 'state' +>; + +/** + * Per-instance options for the wallet's `MultichainAssetsRatesController`. + * Every field falls back to the controller's own default. + */ +export type MultichainAssetsRatesControllerInstanceOptions = Omit< + ConstructorOptions, + 'messenger' | 'state' +>; + +/** + * Per-instance options for the wallet's `MultichainBalancesController`. Every + * field falls back to the controller's own default. + */ +export type MultichainBalancesControllerInstanceOptions = Omit< + ConstructorOptions, + 'messenger' | 'state' +>; + +/** + * Per-instance options for the wallet's `NftController`. Every field falls + * back to the controller's own default. + */ +export type NftControllerInstanceOptions = Omit< + ConstructorOptions, + 'messenger' | 'state' +>; + +/** + * Per-instance options for the wallet's `NftDetectionController`. + * `addNfts`, `removeNft` and `getNftState` are wired to `NftController` + * through the messenger. + */ +export type NftDetectionControllerInstanceOptions = { + /** Whether NFT detection is disabled. Defaults to `false`. */ + disabled?: boolean; +}; + +/** + * Per-instance options for the wallet's `RatesController`. Every field falls + * back to the controller's own default; `includeUsdRate` defaults to `false`. + */ +export type RatesControllerInstanceOptions = Partial< + Omit, 'messenger' | 'state'> +>; + +/** + * Per-instance options for the wallet's `TokenBalancesController`. Every + * field falls back to the controller's own default. + */ +export type TokenBalancesControllerInstanceOptions = Omit< + TokenBalancesControllerOptions, + 'messenger' | 'state' +>; + +/** + * Per-instance options for the wallet's `TokenDetectionController`. Every + * field falls back to the controller's own default; `tokenListService` + * defaults to a `TokenListService` and `trackMetaMetricsEvent` to a no-op. + * `getBalancesInSingleCall` is wired to `AssetsContractController` through + * the messenger. + */ +export type TokenDetectionControllerInstanceOptions = Omit< + TokenDetectionControllerOptions, + | 'messenger' + | 'getBalancesInSingleCall' + | 'tokenListService' + | 'trackMetaMetricsEvent' +> & + Partial< + Pick< + TokenDetectionControllerOptions, + 'tokenListService' | 'trackMetaMetricsEvent' + > + >; + +/** + * Per-instance options for the wallet's `TokenListController`. Every field + * falls back to the controller's own default; `chainId` defaults to Ethereum + * mainnet. + */ +export type TokenListControllerInstanceOptions = Partial< + Omit, 'messenger' | 'state'> +>; + +/** + * Per-instance options for the wallet's `TokenRatesController`. Every field + * falls back to the controller's own default; `tokenPricesService` defaults + * to a `CodefiTokenPricesServiceV2`. + */ +export type TokenRatesControllerInstanceOptions = Partial< + Omit, 'messenger' | 'state'> +>; + +/** + * Per-instance options for the wallet's `TokensController`. Every field falls + * back to the controller's own default; `tokenListService` defaults to a + * `TokenListService`. Without a `provider`, the selected network client's + * provider is used. + */ +export type TokensControllerInstanceOptions = Partial< + Omit, 'messenger' | 'state'> +>; + +/** + * Per-instance options for the wallet's `TokenSearchDiscoveryDataController`. + * `tokenPricesService` defaults to a `CodefiTokenPricesServiceV2`. + */ +export type TokenSearchDiscoveryDataControllerInstanceOptions = Partial< + Omit< + ConstructorOptions, + 'messenger' | 'state' + > +>; diff --git a/packages/wallet/src/initialization/instances/index.ts b/packages/wallet/src/initialization/instances/index.ts index 4055cad6ada..b1902207e4b 100644 --- a/packages/wallet/src/initialization/instances/index.ts +++ b/packages/wallet/src/initialization/instances/index.ts @@ -1,23 +1,33 @@ export { accountsController } from './accounts-controller/accounts-controller.js'; +export { accountTrackerController } from './assets-controllers/account-tracker-controller.js'; export { addressBookController } from './address-book-controller/address-book-controller.js'; export { analyticsController } from './analytics-controller/analytics-controller.js'; export { approvalController } from './approval-controller/approval-controller.js'; +export { assetsContractController } from './assets-controllers/assets-contract-controller.js'; export { claimsController } from './claims-controller/claims-controller.js'; export { claimsService } from './claims-service/claims-service.js'; export { clientController } from './client-controller/client-controller.js'; export { configRegistryApiService } from './config-registry-api-service/config-registry-api-service.js'; export { configRegistryController } from './config-registry-controller/config-registry-controller.js'; export { connectivityController } from './connectivity-controller/connectivity-controller.js'; +export { currencyRateController } from './assets-controllers/currency-rate-controller.js'; +export { deFiPositionsController } from './assets-controllers/defi-positions-controller.js'; export { gasFeeController } from './gas-fee-controller/gas-fee-controller.js'; export { geolocationApiService } from './geolocation-api-service/geolocation-api-service.js'; export { geolocationController } from './geolocation-controller/geolocation-controller.js'; export { keyringController } from './keyring-controller/keyring-controller.js'; export { loggingController } from './logging-controller/logging-controller.js'; +export { multichainAssetsController } from './assets-controllers/multichain-assets-controller.js'; +export { multichainAssetsRatesController } from './assets-controllers/multichain-assets-rates-controller.js'; +export { multichainBalancesController } from './assets-controllers/multichain-balances-controller.js'; export { networkController } from './network-controller/network-controller.js'; export { networkEnablementController } from './network-enablement-controller/network-enablement-controller.js'; +export { nftController } from './assets-controllers/nft-controller.js'; +export { nftDetectionController } from './assets-controllers/nft-detection-controller.js'; export { passkeyController } from './passkey-controller/passkey-controller.js'; export { permissionController } from './permission-controller/permission-controller.js'; export { subjectMetadataController } from './permission-controller/subject-metadata-controller.js'; +export { ratesController } from './assets-controllers/rates-controller.js'; export { remoteFeatureFlagController } from './remote-feature-flag-controller/remote-feature-flag-controller.js'; export { seedlessOnboardingController } from './seedless-onboarding-controller/seedless-onboarding-controller.js'; export { selectedNetworkController } from './selected-network-controller/selected-network-controller.js'; @@ -27,4 +37,10 @@ export { storageService } from './storage-service/storage-service.js'; export { subscriptionController } from './subscription-controller/subscription-controller.js'; export { subscriptionDelegationService } from './subscription-delegation-service/subscription-delegation-service.js'; export { subscriptionService } from './subscription-service/subscription-service.js'; +export { tokenBalancesController } from './assets-controllers/token-balances-controller.js'; +export { tokenDetectionController } from './assets-controllers/token-detection-controller.js'; +export { tokenListController } from './assets-controllers/token-list-controller.js'; +export { tokenRatesController } from './assets-controllers/token-rates-controller.js'; +export { tokensController } from './assets-controllers/tokens-controller.js'; +export { tokenSearchDiscoveryDataController } from './assets-controllers/token-search-discovery-data-controller.js'; export { transactionController } from './transaction-controller/transaction-controller.js'; diff --git a/packages/wallet/src/types.ts b/packages/wallet/src/types.ts index 5b058134ecc..26937d03c80 100644 --- a/packages/wallet/src/types.ts +++ b/packages/wallet/src/types.ts @@ -7,6 +7,24 @@ import type { } from './initialization/defaults.js'; import type { AnalyticsControllerInstanceOptions } from './initialization/instances/analytics-controller/types.js'; import type { ApprovalControllerInstanceOptions } from './initialization/instances/approval-controller/types.js'; +import type { + AccountTrackerControllerInstanceOptions, + AssetsContractControllerInstanceOptions, + CurrencyRateControllerInstanceOptions, + DeFiPositionsControllerInstanceOptions, + MultichainAssetsControllerInstanceOptions, + MultichainAssetsRatesControllerInstanceOptions, + MultichainBalancesControllerInstanceOptions, + NftControllerInstanceOptions, + NftDetectionControllerInstanceOptions, + RatesControllerInstanceOptions, + TokenBalancesControllerInstanceOptions, + TokenDetectionControllerInstanceOptions, + TokenListControllerInstanceOptions, + TokenRatesControllerInstanceOptions, + TokensControllerInstanceOptions, + TokenSearchDiscoveryDataControllerInstanceOptions, +} from './initialization/instances/assets-controllers/types.js'; import type { ClaimsServiceInstanceOptions } from './initialization/instances/claims-service/types.js'; import type { ConfigRegistryApiServiceInstanceOptions } from './initialization/instances/config-registry-api-service/types.js'; import type { ConfigRegistryControllerInstanceOptions } from './initialization/instances/config-registry-controller/types.js'; @@ -57,4 +75,20 @@ export type InstanceSpecificOptions = { selectedNetworkController: SelectedNetworkControllerInstanceOptions; shieldApiService?: ShieldApiServiceInstanceOptions; shieldController?: ShieldControllerInstanceOptions; + accountTrackerController?: AccountTrackerControllerInstanceOptions; + assetsContractController?: AssetsContractControllerInstanceOptions; + currencyRateController?: CurrencyRateControllerInstanceOptions; + deFiPositionsController?: DeFiPositionsControllerInstanceOptions; + multichainAssetsController?: MultichainAssetsControllerInstanceOptions; + multichainAssetsRatesController?: MultichainAssetsRatesControllerInstanceOptions; + multichainBalancesController?: MultichainBalancesControllerInstanceOptions; + nftController?: NftControllerInstanceOptions; + nftDetectionController?: NftDetectionControllerInstanceOptions; + ratesController?: RatesControllerInstanceOptions; + tokenBalancesController?: TokenBalancesControllerInstanceOptions; + tokenDetectionController?: TokenDetectionControllerInstanceOptions; + tokenListController?: TokenListControllerInstanceOptions; + tokenRatesController?: TokenRatesControllerInstanceOptions; + tokensController?: TokensControllerInstanceOptions; + tokenSearchDiscoveryDataController?: TokenSearchDiscoveryDataControllerInstanceOptions; }; diff --git a/packages/wallet/tsconfig.build.json b/packages/wallet/tsconfig.build.json index dfdc85cf60f..b984194bb02 100644 --- a/packages/wallet/tsconfig.build.json +++ b/packages/wallet/tsconfig.build.json @@ -85,6 +85,9 @@ }, { "path": "../geolocation-controller/tsconfig.build.json" + }, + { + "path": "../assets-controllers/tsconfig.build.json" } ], "include": ["../../types", "./src"] diff --git a/packages/wallet/tsconfig.json b/packages/wallet/tsconfig.json index d16557d7cd7..be49a9e7ca3 100644 --- a/packages/wallet/tsconfig.json +++ b/packages/wallet/tsconfig.json @@ -81,6 +81,9 @@ }, { "path": "../geolocation-controller" + }, + { + "path": "../assets-controllers" } ], "include": ["../../types", "./src"] diff --git a/packages/wallet/tsconfig.lint.json b/packages/wallet/tsconfig.lint.json index ae0727ede27..b7097da7deb 100644 --- a/packages/wallet/tsconfig.lint.json +++ b/packages/wallet/tsconfig.lint.json @@ -85,6 +85,9 @@ }, { "path": "../geolocation-controller/tsconfig.lint.json" + }, + { + "path": "../assets-controllers/tsconfig.lint.json" } ] } diff --git a/yarn.lock b/yarn.lock index d2921a9c333..54ae76c5c11 100644 --- a/yarn.lock +++ b/yarn.lock @@ -9051,6 +9051,7 @@ __metadata: "@metamask/address-book-controller": "npm:^8.0.0" "@metamask/analytics-controller": "npm:^4.1.0" "@metamask/approval-controller": "npm:^10.0.0" + "@metamask/assets-controllers": "npm:^113.1.1" "@metamask/auto-changelog": "npm:^7.1.0" "@metamask/base-controller": "npm:^10.1.0" "@metamask/browser-passworder": "npm:^6.0.0" From ea8cfb091d4e0fb828bb5ba8f391521b6541fd17 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 5 Nov 2026 10:18:58 +0000 Subject: [PATCH 4/4] chore: link changelog entries to #11314 Co-authored-by: Xiaoming Wang --- packages/assets-controllers/CHANGELOG.md | 10 +++++----- packages/wallet/CHANGELOG.md | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/packages/assets-controllers/CHANGELOG.md b/packages/assets-controllers/CHANGELOG.md index 068aa8dae7f..1b82bd501df 100644 --- a/packages/assets-controllers/CHANGELOG.md +++ b/packages/assets-controllers/CHANGELOG.md @@ -11,14 +11,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Add `serviceProfile` string option to `searchTokens`, sent as the `x-mm-service-profile` header on the `/tokens/search` request ([#11274](https://github.com/MetaMask/core/pull/11274)) - Defaults to `assets--trending-search`, so the header is sent on every search request -- Add `init` method to `TokensController`, `TokenBalancesController`, `TokenDetectionController`, `TokenRatesController`, `AccountTrackerController`, `NftController`, `MultichainBalancesController`, `MultichainAssetsRatesController`, `MultichainAssetsController` and `TokenListController` ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- Add `init` method to `TokensController`, `TokenBalancesController`, `TokenDetectionController`, `TokenRatesController`, `AccountTrackerController`, `NftController`, `MultichainBalancesController`, `MultichainAssetsRatesController`, `MultichainAssetsController` and `TokenListController` ([#11314](https://github.com/MetaMask/core/pull/11314)) - `init` reads the other controllers that the constructor used to read. Calling it more than once has no effect. - `TokenListController.init` calls `initialize` once. -- Expose `addNfts` through the `NftController` messenger ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- Expose `addNfts` through the `NftController` messenger ([#11314](https://github.com/MetaMask/core/pull/11314)) ### Changed -- **BREAKING:** The constructors of `TokensController`, `TokenBalancesController`, `TokenDetectionController`, `TokenRatesController`, `AccountTrackerController`, `NftController`, `MultichainBalancesController`, `MultichainAssetsRatesController` and `MultichainAssetsController` no longer call other controllers or start background work, so they can be constructed in any order ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- **BREAKING:** The constructors of `TokensController`, `TokenBalancesController`, `TokenDetectionController`, `TokenRatesController`, `AccountTrackerController`, `NftController`, `MultichainBalancesController`, `MultichainAssetsRatesController` and `MultichainAssetsController` no longer call other controllers or start background work, so they can be constructed in any order ([#11314](https://github.com/MetaMask/core/pull/11314)) - Call `init` on each of them once the controllers they read from are registered. Until then: - `TokensController` does not enrich persisted tokens from the token list, and reads the selected account on demand. - `TokenBalancesController`, `TokenDetectionController` and `AccountTrackerController` treat the keyring as locked, and `TokenBalancesController` knows of no tokens. @@ -29,8 +29,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `MultichainAssetsRatesController` uses `usd` as the current currency. - `MultichainAssetsController` does not start the periodic Blockaid re-scan. - `TokenDetectionController.init` reports a failure to read `PreferencesController:getState` through `messenger.captureException` instead of throwing, and takes the preference from the next `PreferencesController:stateChange` event. -- **BREAKING:** `TokensControllerMessenger` must allow the `NetworkController:getSelectedNetworkClient` action ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) -- `TokensController` no longer requires the `chainId` and `provider` options ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- **BREAKING:** `TokensControllerMessenger` must allow the `NetworkController:getSelectedNetworkClient` action ([#11314](https://github.com/MetaMask/core/pull/11314)) +- `TokensController` no longer requires the `chainId` and `provider` options ([#11314](https://github.com/MetaMask/core/pull/11314)) - When `provider` is omitted, the provider of the selected network client (`NetworkController:getSelectedNetworkClient`) is used. - Bump `uuid` from `^14.0.1` to `^14.0.2` ([#11305](https://github.com/MetaMask/core/pull/11305)) diff --git a/packages/wallet/CHANGELOG.md b/packages/wallet/CHANGELOG.md index e283778d41d..32a0adccdbe 100644 --- a/packages/wallet/CHANGELOG.md +++ b/packages/wallet/CHANGELOG.md @@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- **BREAKING:** Add the `@metamask/assets-controllers` controllers to the default initialization configurations ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- **BREAKING:** Add the `@metamask/assets-controllers` controllers to the default initialization configurations ([#11314](https://github.com/MetaMask/core/pull/11314)) - Adds `AccountTrackerController`, `AssetsContractController`, `CurrencyRateController`, `DeFiPositionsController`, `MultichainAssetsController`, `MultichainAssetsRatesController`, `MultichainBalancesController`, `NftController`, `NftDetectionController`, `RatesController`, `TokenBalancesController`, `TokenDetectionController`, `TokenListController`, `TokenRatesController`, `TokensController` and `TokenSearchDiscoveryDataController`. - Hosts that already register any of these controllers on the wallet root messenger must remove that registration before upgrading, or messenger registration will collide. - Their constructors call no other controller, so they can be constructed in any order. `Wallet.init()` calls their `init` methods, which read the other controllers and start the initial fetches. Polling is still started by the client. @@ -20,7 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Changed -- Add `@metamask/assets-controllers` `^113.1.1` as a dependency ([#PR_NUMBER](https://github.com/MetaMask/core/pull/PR_NUMBER)) +- Add `@metamask/assets-controllers` `^113.1.1` as a dependency ([#11314](https://github.com/MetaMask/core/pull/11314)) - Bump `@metamask/gas-fee-controller` from `^27.0.0` to `^27.1.0` ([#11289](https://github.com/MetaMask/core/pull/11289)) - Bump `@metamask/subscription-controller` from `^15.1.2` to `^15.2.0` ([#11289](https://github.com/MetaMask/core/pull/11289)) - Bump `@metamask/transaction-controller` from `^73.0.0` to `^73.1.1` ([#11289](https://github.com/MetaMask/core/pull/11289), [#11300](https://github.com/MetaMask/core/pull/11300))