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/assets-controllers/CHANGELOG.md b/packages/assets-controllers/CHANGELOG.md index 431e193bb0e..1b82bd501df 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` ([#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 ([#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 ([#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. + - `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 ([#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)) ## [113.1.1] diff --git a/packages/assets-controllers/src/AccountTrackerController.test.ts b/packages/assets-controllers/src/AccountTrackerController.test.ts index c0c4835540a..07b4c6798bb 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,112 @@ 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 unknown 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 +2575,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 unknown 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, diff --git a/packages/wallet/CHANGELOG.md b/packages/wallet/CHANGELOG.md index 8f4cebbb835..32a0adccdbe 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 ([#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. + - 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 ([#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)) 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"