import { inspect, isDeepStrictEqual, promisify } from 'util'; import { isMatch } from 'lodash'; import { v4 } from 'uuid'; import nock from 'nock'; import sinon from 'sinon'; import * as ethJsonRpcMiddlewareModule from '@metamask/eth-json-rpc-middleware'; import { BUILT_IN_NETWORKS } from '../../../../shared/constants/network'; import { EVENT } from '../../../../shared/constants/metametrics'; import NetworkController from './network-controller'; jest.mock('@metamask/eth-json-rpc-middleware', () => { return { __esModule: true, ...jest.requireActual('@metamask/eth-json-rpc-middleware'), }; }); jest.mock('uuid', () => { const actual = jest.requireActual('uuid'); return { ...actual, v4: jest.fn(), }; }); // Store this up front so it doesn't get lost when it is stubbed const originalSetTimeout = global.setTimeout; /** * @typedef {import('nock').Scope} NockScope * * A object returned by the `nock` function which holds all of the request mocks * for a network. */ /** * @typedef {{request: MockJsonResponseBody, response: { httpStatus?: number } & MockJsonResponseBody, error?: unknown, delay?: number; times?: number, beforeCompleting: () => void | Promise}} RpcMock * * Arguments to `mockRpcCall` which allow for specifying a canned response for a * particular RPC request. */ /** * @typedef {{id?: number; jsonrpc?: string, method: string, params?: unknown[]}} MockJsonRpcRequestBody * * A partial form of a prototypical JSON-RPC request body. */ /** * @typedef {{id?: number; jsonrpc?: string; result?: string; error?: string}} MockJsonResponseBody * * A partial form of a prototypical JSON-RPC response body. */ /** * A dummy block that matches the pre-EIP-1559 format (i.e. it doesn't have the * `baseFeePerGas` property). */ const PRE_1559_BLOCK = { difficulty: '0x0', extraData: '0x', gasLimit: '0x1c9c380', gasUsed: '0x598c9b', hash: '0xfb2086eb924ffce4061f94c3b65f303e0351f8e7deff185fe1f5e9001ff96f63', logsBloom: '0x7034820113921800018e8070900006316040002225c04a0624110010841018a2109040401004112a4c120f00220a2119020000714b143a04004106120130a8450080433129401068ed22000a54a48221a1020202524204045421b883882530009a1800b08a1309408008828403010d530440001a40003c0006240291008c0404c211610c690b00f1985e000009c02503240040010989c01cf2806840043815498e90012103e06084051542c0094002494008044c24a0a13281e0009601481073010800130402464202212202a8088210442a8ec81b080430075629e60a00a082005a3988400940a4009012a204011a0018a00903222a60420428888144210802', miner: '0xffee087852cb4898e6c3532e776e68bc68b1143b', mixHash: '0xb17ba50cd7261e77a213fb75704dcfd8a28fbcd78d100691a112b7cc2893efa2', nonce: '0x0000000000000000', number: '0x2', // number set to "2" to simplify tests parentHash: '0x31406d1bf1a2ca12371ce5b3ecb20568d6a8b9bf05b49b71b93ba33f317d5a82', receiptsRoot: '0x5ba97ece1afbac2a8fe0344f9022fe808342179b26ea3ecc2e0b8c4b46b7f8cd', sha3Uncles: '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347', size: '0x70f4', stateRoot: '0x36bfb7ca106d41c4458292669126e091011031c5af612dee1c2e6424ef92b080', timestamp: '0x639b6d9b', totalDifficulty: '0xc70d815d562d3cfa955', transactions: [ // reduced to a single transaction to make fixture less verbose '0x2761e939dc822f64141bd00bc7ef8cee16201af10e862469212396664cee81ce', ], transactionsRoot: '0x98bbdfbe1074bc3aa72a77a281f16d6ba7e723d68f15937d80954fb34d323369', uncles: [], }; /** * A dummy block that matches the pre-EIP-1559 format (i.e. it has the * `baseFeePerGas` property). */ const POST_1559_BLOCK = { ...PRE_1559_BLOCK, baseFeePerGas: '0x63c498a46', }; /** * An alias for `POST_1559_BLOCK`, for tests that don't care about which kind of * block they're looking for. */ const BLOCK = POST_1559_BLOCK; /** * A dummy value for the `projectId` option that `createInfuraClient` needs. * (Infura should not be hit during tests, but just in case, this should not * refer to a real project ID.) */ const DEFAULT_INFURA_PROJECT_ID = 'fake-infura-project-id'; /** * Despite the signature of its constructor, NetworkController must take an * Infura project ID. This object is mixed into the options first when a * NetworkController is instantiated in tests. */ const DEFAULT_CONTROLLER_OPTIONS = { infuraProjectId: DEFAULT_INFURA_PROJECT_ID, trackMetaMetricsEvent: jest.fn(), }; /** * The set of properties allowed in a valid JSON-RPC response object. */ const JSONRPC_RESPONSE_BODY_PROPERTIES = ['id', 'jsonrpc', 'result', 'error']; /** * The set of networks that, when specified, create an Infura provider as * opposed to a "standard" provider (one suited for a custom RPC endpoint). */ const INFURA_NETWORKS = [ { nickname: 'Mainnet', networkType: 'mainnet', chainId: '0x1', networkVersion: '1', ticker: 'ETH', }, { nickname: 'Goerli', networkType: 'goerli', chainId: '0x5', networkVersion: '5', ticker: 'GoerliETH', }, { nickname: 'Sepolia', networkType: 'sepolia', chainId: '0xaa36a7', networkVersion: '11155111', ticker: 'SepoliaETH', }, ]; /** * Handles mocking provider requests for a particular network. */ class NetworkCommunications { #networkClientOptions; /** * Builds an object for mocking provider requests. * * @param {object} args - The arguments. * @param {"infura" | "custom"} args.networkClientType - Specifies the * expected middleware stack that will represent the provider: "infura" for an * Infura network; "custom" for a custom RPC endpoint. * @param {object} args.networkClientOptions - Details about the network * client used to determine the base URL or URL path to mock. * @param {string} [args.networkClientOptions.infuraNetwork] - The name of the * Infura network being tested, assuming that `networkClientType` is "infura". * @param {string} [args.networkClientOptions.infuraProjectId] - The project * ID of the Infura network being tested, assuming that `networkClientType` is * "infura". * @param {string} [args.networkClientOptions.customRpcUrl] - The URL of the * custom RPC endpoint, assuming that `networkClientType` is "custom". * @returns {NockScope} The nock scope. */ constructor({ networkClientType, networkClientOptions: { infuraNetwork, infuraProjectId = DEFAULT_INFURA_PROJECT_ID, customRpcUrl, } = {}, }) { const networkClientOptions = { infuraNetwork, infuraProjectId, customRpcUrl, }; this.networkClientType = networkClientType; this.#networkClientOptions = networkClientOptions; this.infuraProjectId = infuraProjectId; const rpcUrl = networkClientType === 'infura' ? `https://${infuraNetwork}.infura.io` : customRpcUrl; this.nockScope = nock(rpcUrl); } /** * Constructs a new NetworkCommunications object using a different set of * options, using the options from this instance as a base. * * @param args - The same arguments that NetworkCommunications takes. */ with(args) { return new NetworkCommunications({ networkClientType: this.networkClientType, networkClientOptions: this.#networkClientOptions, ...args, }); } /** * Mocks the RPC calls that NetworkController makes internally. * * @param {object} args - The arguments. * @param {{number: string, baseFeePerGas?: string} | null} [args.latestBlock] - The * block object that will be used to mock `eth_blockNumber` and * `eth_getBlockByNumber`. If null, then both `eth_blockNumber` and * `eth_getBlockByNumber` will respond with null. * @param {RpcMock | Partial[] | null} [args.eth_blockNumber] - * Options for mocking the `eth_blockNumber` RPC method (see `mockRpcCall` for * valid properties). By default, the number from the `latestBlock` will be * used as the result. Use `null` to prevent this method from being mocked. * @param {RpcMock | Partial[] | null} [args.eth_getBlockByNumber] - * Options for mocking the `eth_getBlockByNumber` RPC method (see * `mockRpcCall` for valid properties). By default, the `latestBlock` will be * used as the result. Use `null` to prevent this method from being mocked. * @param {RpcMock | Partial[] | null} [args.net_version] - Options * for mocking the `net_version` RPC method (see `mockRpcCall` for valid * properties). By default, "1" will be used as the result. Use `null` to * prevent this method from being mocked. */ mockEssentialRpcCalls({ latestBlock = BLOCK, eth_blockNumber: ethBlockNumberMocks = [], eth_getBlockByNumber: ethGetBlockByNumberMocks = [], net_version: netVersionMocks = [], } = {}) { const latestBlockNumber = latestBlock === null ? null : latestBlock.number; if (latestBlock && latestBlock.number === undefined) { throw new Error('The latest block must have a `number`.'); } const defaultMocksByRpcMethod = { eth_blockNumber: { request: { method: 'eth_blockNumber', params: [], }, response: { result: latestBlockNumber, }, // When the provider is configured for an Infura network, // NetworkController makes a sentinel request for `eth_blockNumber`, so // we ensure that it is mocked by default. Conversely, when the provider // is configured for a custom RPC endpoint, we don't mock // `eth_blockNumber` at all unless specified. Admittedly, this is a bit // magical, but it saves us from having to think about this in tests // if we don't have to. times: this.networkClientType === 'infura' ? 1 : 0, }, eth_getBlockByNumber: { request: { method: 'eth_getBlockByNumber', params: [latestBlockNumber, false], }, response: { result: latestBlock, }, }, net_version: { request: { method: 'net_version', params: [], }, response: { result: '1', }, }, }; const providedMocksByRpcMethod = { eth_blockNumber: ethBlockNumberMocks, eth_getBlockByNumber: ethGetBlockByNumberMocks, net_version: netVersionMocks, }; const allMocks = []; Object.keys(defaultMocksByRpcMethod).forEach((rpcMethod) => { const defaultMock = defaultMocksByRpcMethod[rpcMethod]; const providedMockOrMocks = providedMocksByRpcMethod[rpcMethod]; const providedMocks = Array.isArray(providedMockOrMocks) ? providedMockOrMocks : [providedMockOrMocks]; if (providedMocks.length > 0) { providedMocks.forEach((providedMock) => { allMocks.push({ ...defaultMock, ...providedMock }); }); } else { allMocks.push(defaultMock); } }); // The request that the block tracker makes always occurs after any request // that the network controller makes (because such a request goes through // the block cache middleware and that is what spawns the block tracker). We // don't need to customize the block tracker request; we just need to ensure // that the block number it returns matches the same block number that // `eth_getBlockByNumber` uses. allMocks.push({ request: { method: 'eth_blockNumber', params: [], }, response: { result: latestBlockNumber, }, times: latestBlock === null ? 2 : 1, }); allMocks.forEach((mock) => { this.mockRpcCall(mock); }); } /** * Mocks a JSON-RPC request sent to the provider with the given response. * * @param {RpcMock} args - The arguments. * @param {MockJsonRpcRequestBody} args.request - The request data. Must * include a `method`. Note that EthQuery's `sendAsync` method implicitly uses * an empty array for `params` if it is not provided in the original request, * so make sure to include this. * @param {MockJsonResponseBody & { httpStatus?: number }} [args.response] - Information * concerning the response that the request should have. Takes one of two * forms. The simplest form is an object that represents the response body; * the second form allows you to specify the HTTP status, as well as a * potentially async function to generate the response body. * @param {unknown} [args.error] - An error to throw while * making the request. Takes precedence over `response`. * @param {number} [args.delay] - The amount of time that should * pass before the request resolves with the response. * @param {number} [args.times] - The number of times that the * request is expected to be made. * @param {() => void | Promise} [args.beforeCompleting] - Sometimes it is useful to do * something after the request is kicked off but before it ends (or, in terms * of a `fetch` promise, when the promise is initiated but before it is * resolved). You can pass an (async) function for this option to do this. * @returns {NockScope | null} The nock scope object that represents all of * the mocks for the network, or null if `times` is 0. */ mockRpcCall({ request, response, error, delay, times, beforeCompleting }) { if (times === 0) { return null; } const url = this.networkClientType === 'infura' ? `/v3/${this.infuraProjectId}` : '/'; const httpStatus = response?.httpStatus ?? 200; this.#validateMockResponseBody(response); const partialResponseBody = { jsonrpc: '2.0' }; JSONRPC_RESPONSE_BODY_PROPERTIES.forEach((prop) => { if (response[prop] !== undefined) { partialResponseBody[prop] = response[prop]; } }); let nockInterceptor = this.nockScope.post(url, (actualBody) => { const expectedPartialBody = { jsonrpc: '2.0', ...request }; return isMatch(actualBody, expectedPartialBody); }); if (delay !== undefined) { nockInterceptor = nockInterceptor.delay(delay); } if (times !== undefined) { nockInterceptor = nockInterceptor.times(times); } if (error !== undefined) { return nockInterceptor.replyWithError(error); } if (response !== undefined) { return nockInterceptor.reply(async (_uri, requestBody) => { if (beforeCompleting !== undefined) { await beforeCompleting(); } const completeResponseBody = { jsonrpc: '2.0', ...(requestBody.id === undefined ? {} : { id: requestBody.id }), ...partialResponseBody, }; return [httpStatus, completeResponseBody]; }); } throw new Error( 'Neither `response` nor `error` was given. Please specify one of them.', ); } #validateMockResponseBody(mockResponseBody) { const invalidProperties = Object.keys(mockResponseBody).filter( (key) => key !== 'httpStatus' && !JSONRPC_RESPONSE_BODY_PROPERTIES.includes(key), ); if (invalidProperties.length > 0) { throw new Error( `Mock response object ${inspect( mockResponseBody, )} has invalid properties: ${inspect(invalidProperties)}.`, ); } } } describe('NetworkController', () => { let clock; beforeEach(() => { // Disable all requests, even those to localhost nock.disableNetConnect(); // Faking timers ends up doing two things: // 1. Halting the block tracker (which depends on `setTimeout` to // periodically request the latest block) set up in // `eth-json-rpc-middleware` // 2. Halting the retry logic in `@metamask/eth-json-rpc-infura` (which // also depends on `setTimeout`) clock = sinon.useFakeTimers(); }); afterEach(() => { nock.enableNetConnect('localhost'); clock.restore(); nock.cleanAll(); }); describe('constructor', () => { const invalidInfuraIds = [undefined, null, {}, 1]; invalidInfuraIds.forEach((invalidId) => { it(`throws if an invalid Infura ID of "${inspect( invalidId, )}" is provided`, () => { expect(() => new NetworkController({ infuraId: invalidId })).toThrow( 'Invalid Infura project ID', ); }); }); it('accepts initial state', async () => { const exampleInitialState = { provider: { type: 'rpc', rpcUrl: 'http://example-custom-rpc.metamask.io', chainId: '0x9999', nickname: 'Test initial state', }, networkDetails: { EIPS: { 1559: false, }, }, }; await withController( { state: exampleInitialState, }, ({ controller }) => { expect(controller.store.getState()).toMatchInlineSnapshot(` { "network": "loading", "networkConfigurations": {}, "networkDetails": { "EIPS": { "1559": false, }, }, "previousProviderStore": { "chainId": "0x9999", "nickname": "Test initial state", "rpcUrl": "http://example-custom-rpc.metamask.io", "type": "rpc", }, "provider": { "chainId": "0x9999", "nickname": "Test initial state", "rpcUrl": "http://example-custom-rpc.metamask.io", "type": "rpc", }, } `); }, ); }); it('sets default state without initial state', async () => { await withController(({ controller }) => { expect(controller.store.getState()).toMatchInlineSnapshot(` { "network": "loading", "networkConfigurations": {}, "networkDetails": { "EIPS": { "1559": undefined, }, }, "previousProviderStore": { "chainId": "0x539", "nickname": "Localhost 8545", "rpcUrl": "http://localhost:8545", "ticker": "ETH", "type": "rpc", }, "provider": { "chainId": "0x539", "nickname": "Localhost 8545", "rpcUrl": "http://localhost:8545", "ticker": "ETH", "type": "rpc", }, } `); }); }); }); describe('destroy', () => { it('does not throw if called before the provider is initialized', async () => { const controller = new NetworkController(DEFAULT_CONTROLLER_OPTIONS); expect(await controller.destroy()).toBeUndefined(); }); it('stops the block tracker for the currently selected network as long as the provider has been initialized', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { times: 1, }, }); await controller.initializeProvider(); const { blockTracker } = controller.getProviderAndBlockTracker(); // The block tracker starts running after a listener is attached blockTracker.addListener('latest', () => { // do nothing }); expect(blockTracker.isRunning()).toBe(true); await controller.destroy(); expect(blockTracker.isRunning()).toBe(false); }); }); }); describe('initializeProvider', () => { it('throws if the provider configuration is invalid', async () => { const invalidProviderConfig = {}; await withController( { state: { provider: invalidProviderConfig, }, }, async ({ controller }) => { await expect(async () => { await controller.initializeProvider(); }).rejects.toThrow( 'NetworkController - _configureProvider - unknown type "undefined"', ); }, ); }); for (const { nickname, networkType, chainId, networkVersion, } of INFURA_NETWORKS) { describe(`when the type in the provider configuration is "${networkType}"`, () => { it(`initializes a provider pointed to the ${nickname} Infura network (chainId: ${chainId})`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe(chainId); }, ); }); it('emits infuraIsUnblocked (assuming that the request to eth_blockNumber responds successfully)', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.initializeProvider(); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); it(`persists "${networkVersion}" to state as the network version of ${nickname}`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); expect(controller.store.getState().network).toBe(networkVersion); }, ); }); it(`persists to state whether the network supports EIP-1559 (assuming that the request for eth_getBlockByNumber responds successfully)`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, networkDetails: { EIPS: {}, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await controller.initializeProvider(); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(true); }, ); }); }); } describe(`when the type in the provider configuration is "rpc"`, () => { it('initializes a provider pointed to the given RPC URL whose chain ID matches the configured chain ID', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); network.mockRpcCall({ request: { method: 'test', params: [], }, response: { result: 'test response', }, }); await controller.initializeProvider(); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: testResult } = await promisifiedSendAsync({ id: 99999, jsonrpc: '2.0', method: 'test', params: [], }); expect(testResult).toBe('test response'); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe('0xtest'); }, ); }); it('emits infuraIsUnblocked', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.initializeProvider(); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); it('persists the network version to state (assuming that the request for net_version responds successfully)', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ net_version: { response: { result: '42', }, }, }); await controller.initializeProvider(); expect(controller.store.getState().network).toBe('42'); }, ); }); it('persists to state whether the network supports EIP-1559 (assuming that the request for eth_getBlockByNumber responds successfully)', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await controller.initializeProvider(); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(true); }, ); }); }); }); describe('getProviderAndBlockTracker', () => { it('returns objects that proxy to the provider and block tracker as long as the provider has been initialized', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider, blockTracker } = controller.getProviderAndBlockTracker(); expect(provider).toHaveProperty('sendAsync'); expect(blockTracker).toHaveProperty('checkForLatestBlock'); }); }); it("returns null for both the provider and block tracker if the provider hasn't been initialized yet", async () => { await withController(async ({ controller }) => { const { provider, blockTracker } = controller.getProviderAndBlockTracker(); expect(provider).toBeNull(); expect(blockTracker).toBeNull(); }); }); for (const { nickname, networkType, chainId } of INFURA_NETWORKS) { describe(`when the type in the provider configuration is changed to "${networkType}"`, () => { it(`returns a provider object that was pointed to another network before the switch and is pointed to ${nickname} afterward`, async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', nickname: 'test-chain', ticker: 'TEST', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com', }, id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync1 = promisify(provider.sendAsync).bind( provider, ); const { result: oldChainIdResult } = await promisifiedSendAsync1({ method: 'eth_chainId', }); expect(oldChainIdResult).toBe('0x1337'); controller.setProviderType(networkType); const promisifiedSendAsync2 = promisify(provider.sendAsync).bind( provider, ); const { result: newChainIdResult } = await promisifiedSendAsync2({ method: 'eth_chainId', }); expect(newChainIdResult).toBe(chainId); }, ); }); }); } describe('when the type in the provider configuration is changed to "rpc"', () => { it('returns a provider object that was pointed to another network before the switch and is pointed to the new network', async () => { await withController( { state: { provider: { type: 'goerli', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync1 = promisify(provider.sendAsync).bind( provider, ); const { result: oldChainIdResult } = await promisifiedSendAsync1({ method: 'eth_chainId', }); expect(oldChainIdResult).toBe('0x5'); controller.setActiveNetwork('testNetworkConfigurationId'); const promisifiedSendAsync2 = promisify(provider.sendAsync).bind( provider, ); const { result: newChainIdResult } = await promisifiedSendAsync2({ method: 'eth_chainId', }); expect(newChainIdResult).toBe('0xtest'); }, ); }); }); }); describe('getEIP1559Compatibility', () => { describe('when the latest block has a baseFeePerGas property', () => { it('persists to state that the network supports EIP-1559', async () => { await withController( { state: { networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await controller.initializeProvider(); await controller.getEIP1559Compatibility(); expect(controller.store.getState().networkDetails.EIPS[1559]).toBe( true, ); }, ); }); it('returns true', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await controller.initializeProvider(); const supportsEIP1559 = await controller.getEIP1559Compatibility(); expect(supportsEIP1559).toBe(true); }); }); }); describe('when the latest block does not have a baseFeePerGas property', () => { it('persists to state that the network does not support EIP-1559', async () => { await withController( { state: { networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await controller.initializeProvider(); await controller.getEIP1559Compatibility(); expect(controller.store.getState().networkDetails.EIPS[1559]).toBe( false, ); }, ); }); it('returns false', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await controller.initializeProvider(); const supportsEIP1559 = await controller.getEIP1559Compatibility(); expect(supportsEIP1559).toBe(false); }); }); }); describe('when the request for the latest block responds with null', () => { it('persists null to state as whether the network supports EIP-1559', async () => { await withController( { state: { networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: null, }); await controller.initializeProvider(); await controller.getEIP1559Compatibility(); expect(controller.store.getState().networkDetails.EIPS[1559]).toBe( null, ); }, ); }); it('returns null', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: null, }); await controller.initializeProvider(); const supportsEIP1559 = await controller.getEIP1559Compatibility(); expect(supportsEIP1559).toBe(null); }); }); }); it('does not make multiple requests to eth_getBlockByNumber when called multiple times and the request to eth_getBlockByNumber succeeded the first time', async () => { await withController(async ({ controller, network }) => { // This mocks eth_getBlockByNumber once by default network.mockEssentialRpcCalls(); await withoutCallingGetEIP1559Compatibility({ controller, operation: async () => { await controller.initializeProvider(); }, }); await controller.getEIP1559Compatibility(); await controller.getEIP1559Compatibility(); expect(network.nockScope.isDone()).toBe(true); }); }); }); describe('lookupNetwork', () => { describe('if the provider has not been initialized', () => { it('does not update state in any way', async () => { const providerConfig = { type: 'rpc', rpcUrl: 'http://example-custom-rpc.metamask.io', chainId: '0x9999', nickname: 'Test initial state', }; const initialState = { provider: providerConfig, networkDetails: { EIPS: { 1559: true, }, }, }; await withController( { state: initialState, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const stateAfterConstruction = controller.store.getState(); await controller.lookupNetwork(); expect(controller.store.getState()).toStrictEqual( stateAfterConstruction, ); }, ); }); it('does not emit infuraIsUnblocked', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls(); const promiseForInfuraIsUnblocked = waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForInfuraIsUnblocked).toNeverResolve(); }); }); it('does not emit infuraIsBlocked', async () => { await withController(async ({ controller, network }) => { network.mockEssentialRpcCalls(); const promiseForInfuraIsBlocked = waitForEvent({ controller, eventName: 'infuraIsBlocked', operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForInfuraIsBlocked).toNeverResolve(); }); }); }); for (const { nickname, networkType, networkVersion } of INFURA_NETWORKS) { describe(`when the type in the provider configuration is "${networkType}"`, () => { describe('if the request for eth_blockNumber responds successfully', () => { it('emits infuraIsUnblocked as long as the network has not changed by the time the request ends', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { response: { result: '0x42', }, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.lookupNetwork(); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); it('does not emit infuraIsUnblocked if the network has changed by the time the request ends', async () => { const anotherNetwork = INFURA_NETWORKS.find( (network) => network.networkType !== networkType, ); /* eslint-disable-next-line jest/no-if */ if (!anotherNetwork) { throw new Error( "Could not find another network to use. You've probably commented out all INFURA_NETWORKS but one. Please uncomment another one.", ); } await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ eth_blockNumber: { response: { result: '0x42', }, beforeCompleting: async () => { await waitForEvent({ controller, eventName: 'networkDidChange', operation: async () => { await withoutCallingLookupNetwork({ controller, operation: () => { controller.setProviderType( anotherNetwork.networkType, ); }, }); }, }); }, }, }); const network2 = network1.with({ networkClientOptions: { infuraNetwork: anotherNetwork.networkType, }, }); network2.mockEssentialRpcCalls(); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); const promiseForInfuraIsUnblocked = waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForInfuraIsUnblocked).toNeverResolve(); }, ); }); }); describe('if the request for eth_blockNumber responds with a "countryBlocked" error', () => { it('emits infuraIsBlocked as long as the network has not changed by the time the request ends', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { response: { httpStatus: 500, error: 'countryBlocked', }, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); const infuraIsBlocked = await waitForEvent({ controller, eventName: 'infuraIsBlocked', operation: async () => { await controller.lookupNetwork(); }, }); expect(infuraIsBlocked).toBe(true); }, ); }); it('does not emit infuraIsBlocked if the network has changed by the time the request ends', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ eth_blockNumber: { response: { httpStatus: 500, error: 'countryBlocked', }, beforeCompleting: async () => { await withoutCallingLookupNetwork({ controller, operation: async () => { await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.setActiveNetwork( 'testNetworkConfigurationId', ); }, }); }, }); }, }, }); const network2 = new NetworkCommunications({ networkClientType: 'rpc', networkClientOptions: { customRpcUrl: 'http://some-rpc-url', }, }); network2.mockEssentialRpcCalls(); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); const promiseForInfuraIsBlocked = waitForEvent({ controller, eventName: 'infuraIsBlocked', operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForInfuraIsBlocked).toNeverResolve(); }, ); }); }); describe('if the request for eth_blockNumber responds with a generic error', () => { it('does not emit infuraIsUnblocked', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID // of the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { response: { httpStatus: 500, error: 'oops', }, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); const promiseForInfuraIsUnblocked = waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForInfuraIsUnblocked).toNeverResolve(); }, ); }); }); it(`persists "${networkVersion}" to state as the network version of ${nickname}`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); expect(controller.store.getState().network).toBe(networkVersion); }, ); }); it(`does not update the network state if it is already set to "${networkVersion}"`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { times: 2, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); const promiseForStateChanges = waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForStateChanges).toNeverResolve(); }, ); }); describe('if the request for eth_getBlockByNumber responds successfully', () => { it('persists to state that the network supports EIP-1559 when baseFeePerGas is in the block header', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await controller.initializeProvider(); await controller.getEIP1559Compatibility(); expect( controller.store.getState().networkDetails.EIPS[1559], ).toBe(true); }, ); }); it('persists to state that the network does not support EIP-1559 when baseFeePerGas is not in the block header', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await controller.initializeProvider(); await controller.getEIP1559Compatibility(); expect( controller.store.getState().networkDetails.EIPS[1559], ).toBe(false); }, ); }); }); describe('if the request for eth_getBlockByNumber responds with an error', () => { it('does not update the network details in any way', async () => { const intentionalErrorMessage = 'intentional error from eth_getBlockByNumber'; await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_getBlockByNumber: { response: { error: intentionalErrorMessage, }, }, }); await withoutCallingGetEIP1559Compatibility({ controller, operation: async () => { await controller.initializeProvider(); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], count: 0, operation: async () => { try { await controller.getEIP1559Compatibility(); } catch (error) { if (error !== intentionalErrorMessage) { console.error(error); } } }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); }, ); }); }); describe('if the network was switched after the net_version request started but before it completed', () => { it(`persists to state the network version of the newly switched network, not the initial one for ${nickname}`, async () => { const oldNetworkVersion = networkVersion; const newChainName = 'goerli'; const newNetworkVersion = '5'; await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller }) => { let netVersionCallCount = 0; const fakeProviders = [ { sendAsync(request, callback) { if (request.method === 'net_version') { netVersionCallCount += 1; if (netVersionCallCount === 1) { waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.setProviderType(newChainName); }, }) .then(() => { callback(null, { id: request.id, jsonrpc: '2.0', result: oldNetworkVersion, }); }) .catch((error) => { throw error; }); return; } throw new Error( "net_version shouldn't be called more than once", ); } if (request.method === 'eth_getBlockByNumber') { callback(null, { id: request.id, jsonrpc: '2.0', result: BLOCK, }); return; } throw new Error( `Mock not found for method ${request.method}`, ); }, }, { sendAsync(request, callback) { if (request.method === 'net_version') { callback(null, { id: request.id, jsonrpc: '2.0', result: newNetworkVersion, }); return; } if (request.method === 'eth_getBlockByNumber') { callback(null, { id: request.id, jsonrpc: '2.0', result: BLOCK, }); return; } throw new Error( `Mock not found for method ${request.method}`, ); }, }, ]; jest .spyOn(ethJsonRpcMiddlewareModule, 'providerFromEngine') .mockImplementationOnce(() => fakeProviders[0]) .mockImplementationOnce(() => fakeProviders[1]); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); expect(controller.store.getState().network).toBe( newNetworkVersion, ); }, ); }); it(`persists to state the EIP-1559 support for the newly switched network, not the initial one for ${nickname}`, async () => { const oldNetworkVersion = networkVersion; const newChainName = 'goerli'; const newNetworkVersion = '5'; await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller }) => { let netVersionCallCount = 0; const fakeProviders = [ { sendAsync(request, callback) { if (request.method === 'net_version') { netVersionCallCount += 1; if (netVersionCallCount === 1) { waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.setProviderType(newChainName); }, }) .then(() => { callback(null, { id: request.id, jsonrpc: '2.0', result: oldNetworkVersion, }); }) .catch((error) => { throw error; }); return; } throw new Error( "net_version shouldn't be called more than once", ); } if (request.method === 'eth_getBlockByNumber') { callback(null, { id: request.id, jsonrpc: '2.0', result: POST_1559_BLOCK, }); return; } throw new Error( `Mock not found for method ${request.method}`, ); }, }, { sendAsync(request, callback) { if (request.method === 'net_version') { callback(null, { id: request.id, jsonrpc: '2.0', result: newNetworkVersion, }); return; } if (request.method === 'eth_getBlockByNumber') { callback(null, { id: request.id, jsonrpc: '2.0', result: PRE_1559_BLOCK, }); return; } throw new Error( `Mock not found for method ${request.method}`, ); }, }, ]; jest .spyOn(ethJsonRpcMiddlewareModule, 'providerFromEngine') .mockImplementationOnce(() => fakeProviders[0]) .mockImplementationOnce(() => fakeProviders[1]); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], operation: async () => { await controller.lookupNetwork(); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(false); }, ); }); }); }); } describe(`when the type in the provider configuration is "rpc"`, () => { it('emits infuraIsUnblocked', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: async () => { await controller.lookupNetwork(); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); describe('if the request for net_version responds successfully', () => { it('persists the network version to state', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ net_version: { response: { result: '42', }, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); expect(controller.store.getState().network).toBe('42'); }, ); }); it('does not persist the result of net_version if it matches what is already in state', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ net_version: { times: 2, }, eth_blockNumber: { times: 2, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); const promiseForStateChanges = waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); await expect(promiseForStateChanges).toNeverResolve(); }, ); }); describe('if the request for eth_getBlockByNumber responds successfully', () => { it('persists to state that the network supports EIP-1559 when baseFeePerGas is in the block header', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await controller.lookupNetwork(); expect( controller.store.getState().networkDetails.EIPS[1559], ).toBe(true); }, ); }); it('persists to state that the network does not support EIP-1559 when baseFeePerGas is not in the block header', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'TEST2', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'TEST2', id: 'testNetworkConfigurationId', }, }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await controller.lookupNetwork(); expect( controller.store.getState().networkDetails.EIPS[1559], ).toBe(false); }, ); }); }); describe('if the request for eth_getBlockByNumber responds with an error', () => { it('does not update the network details in any way', async () => { const intentionalErrorMessage = 'intentional error from eth_getBlockByNumber'; await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_getBlockByNumber: { response: { error: intentionalErrorMessage, }, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], count: 0, operation: async () => { try { await controller.lookupNetwork(); } catch (error) { if ( !('data' in error) || error.data !== intentionalErrorMessage ) { console.error(error); } } }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); }, ); }); }); }); describe('if the request for net_version responds with an error', () => { it('resets the network status to "loading"', async () => { const intentionalErrorMessage = 'intentional error from net_version'; await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ net_version: [ { response: { result: '42', }, }, { response: { error: intentionalErrorMessage, }, }, ], }); await controller.initializeProvider(); expect(controller.store.getState().network).toBe('42'); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { try { await controller.lookupNetwork(); } catch (error) { if (error !== intentionalErrorMessage) { console.error(error); } } }, }); expect(controller.store.getState().network).toBe('loading'); }, ); }); it('removes from state whether the network supports EIP-1559', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, net_version: [ { response: { result: '42', }, }, { response: { error: 'oops', }, }, ], }); await controller.initializeProvider(); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], operation: async () => { await controller.lookupNetwork(); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, ); }); }); describe('if the network was switched after the net_version request started but before it completed', () => { it('persists to state the network version of the newly switched network, not the initial network', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, networkDetails: { EIPS: {}, }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ net_version: { response: { result: '111', }, beforeCompleting: async () => { await waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.setActiveNetwork( 'testNetworkConfigurationId1', ); }, }); }, }, }); const network2 = network1.with({ networkClientOptions: { customRpcUrl: 'https://mock-rpc-url-1', }, }); network2.mockEssentialRpcCalls({ net_version: { response: { result: '222', }, }, }); await withoutCallingLookupNetwork({ controller, operation: async () => { await controller.initializeProvider(); }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: async () => { await controller.lookupNetwork(); }, }); expect(controller.store.getState().network).toBe('222'); }, ); }); it('persists to state the EIP-1559 support for the newly switched network, not the initial one', async () => { const nonEip1559RpcUrl = 'https://mock-rpc-url-1'; await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, networkDetails: { EIPS: {}, }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: nonEip1559RpcUrl, chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ net_version: { response: { result: '111', }, beforeCompleting: async () => { await waitForStateChanges({ controller, propertyPath: ['networkDetails'], operation: () => { controller.setActiveNetwork( 'testNetworkConfigurationId1', ); }, }); }, }, eth_getBlockByNumber: { response: { result: POST_1559_BLOCK, }, }, }); const network2 = network1.with({ networkClientOptions: { customRpcUrl: nonEip1559RpcUrl, }, }); network2.mockEssentialRpcCalls({ net_version: { response: { result: '222', }, }, eth_getBlockByNumber: { response: { result: PRE_1559_BLOCK, }, }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { await controller.initializeProvider(); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(false); }, ); }); }); }); }); describe('setActiveNetwork', () => { it('throws if the given networkConfigurationId does not match one in networkConfigurations', async () => { await withController( { state: { networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); expect(() => controller.setActiveNetwork('invalid-network-configuration-id'), ).toThrow( new Error( 'networkConfigurationId invalid-network-configuration-id does not match a configured networkConfiguration', ), ); }, ); }); it('captures the current provider configuration before overwriting it', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x9999', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'https://mock-rpc-url-2', chainId: '0x9999', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url-2', }, }); network.mockEssentialRpcCalls(); controller.setActiveNetwork('testNetworkConfigurationId1'); expect( controller.store.getState().previousProviderStore, ).toStrictEqual({ type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x9999', ticker: 'RPC', id: 'testNetworkConfigurationId2', }); }, ); }); it('overwrites the provider configuration given a networkConfigurationId that matches a configured networkConfiguration', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'http://example-custom-rpc.metamask.io', chainId: '0x9999', ticker: 'RPC', id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', type: 'rpc', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://example-custom-rpc.metamask.io', chainId: '0x9999', ticker: 'RPC', type: 'rpc', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls(); controller.setActiveNetwork('testNetworkConfigurationId1'); expect(controller.store.getState().provider).toStrictEqual({ type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }); }, ); }); it('emits networkWillChange before making any changes to the network store', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'http://example-custom-rpc.metamask.io', chainId: '0xtest2', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://example-custom-rpc.metamask.io', chainId: '0xtest2', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ net_version: { response: { result: '42', }, }, }); const network2 = network1.with({ networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls({ net_version: { response: { result: '99', }, }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { await controller.initializeProvider(); }, }); const initialNetwork = controller.store.getState().network; expect(initialNetwork).toBe('42'); const networkWillChange = await waitForEvent({ controller, eventName: 'networkWillChange', operation: () => { controller.setActiveNetwork('testNetworkConfigurationId2'); }, beforeResolving: () => { expect(controller.store.getState().network).toBe(initialNetwork); }, }); expect(networkWillChange).toBe(true); }, ); }); it('resets the network state to "loading" before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ net_version: { response: { result: '255', }, }, }); await controller.initializeProvider(); expect(controller.store.getState().network).toBe('255'); await waitForStateChanges({ controller, propertyPath: ['network'], // We only care about the first state change, because it happens // before networkDidChange count: 1, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId1'); }, }); expect(controller.store.getState().network).toBe('loading'); }, ); }); it('resets EIP support for the network before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url-2', }, }); network2.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await controller.initializeProvider(); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], // We only care about the first state change, because it happens // before networkDidChange count: 1, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId1'); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, ); }); it('initializes a provider pointed to the given RPC URL whose chain ID matches the configured chain ID', async () => { await withController( { state: { networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls(); network.mockRpcCall({ request: { method: 'test', params: [], }, response: { result: 'test response', }, }); controller.setActiveNetwork('testNetworkConfigurationId'); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: testResult } = await promisifiedSendAsync({ id: 99999, jsonrpc: '2.0', method: 'test', params: [], }); expect(testResult).toBe('test response'); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe('0xtest'); }, ); }); it('replaces the provider object underlying the provider proxy without creating a new instance of the proxy itself', async () => { await withController( { state: { networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider: providerBefore } = controller.getProviderAndBlockTracker(); controller.setActiveNetwork('testNetworkConfigurationId'); const { provider: providerAfter } = controller.getProviderAndBlockTracker(); expect(providerBefore).toBe(providerAfter); }, ); }); it('emits networkDidChange', async () => { await withController( { state: { networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls(); const networkDidChange = await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(networkDidChange).toBe(true); }, ); }); it('emits infuraIsUnblocked', async () => { await withController( { state: { networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls(); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); it('persists the network version to state (assuming that the request for net_version responds successfully)', async () => { await withController( { state: { networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls({ net_version: { response: { result: '42', }, }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(controller.store.getState().network).toBe('42'); }, ); }); it('persists to state whether the network supports EIP-1559 (assuming that the request for eth_getBlockByNumber responds successfully)', async () => { await withController( { state: { networkDetails: { EIPS: {}, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], count: 2, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(controller.store.getState().networkDetails.EIPS['1559']).toBe( true, ); }, ); }); }); describe('setProviderType', () => { for (const { nickname, networkType, chainId, networkVersion, ticker, } of INFURA_NETWORKS) { describe(`given a type of "${networkType}"`, () => { it('captures the current provider configuration before overwriting it', async () => { await withController( { state: { provider: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', nickname: 'test-chain', ticker: 'TEST', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com', }, id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); controller.setProviderType(networkType); expect( controller.store.getState().previousProviderStore, ).toStrictEqual({ rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }); }, ); }); it(`overwrites the provider configuration using type: "${networkType}", chainId: "${chainId}", and ticker "${ticker}", clearing rpcUrl and nickname, and removing rpcPrefs`, async () => { await withController( { state: { provider: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', nickname: 'test-chain', ticker: 'TEST', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com', }, id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); controller.setProviderType(networkType); expect(controller.store.getState().provider).toStrictEqual({ type: networkType, rpcUrl: '', chainId, ticker, nickname: '', rpcPrefs: { blockExplorerUrl: BUILT_IN_NETWORKS[networkType].blockExplorerUrl, }, }); }, ); }); it('emits networkWillChange', async () => { await withController(async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); const networkWillChange = await waitForEvent({ controller, eventName: 'networkWillChange', operation: () => { controller.setProviderType(networkType); }, }); expect(networkWillChange).toBe(true); }); }); it('resets the network state to "loading" before emitting networkDidChange', async () => { await withController( { state: { provider: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', type: 'rpc', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ net_version: { response: { result: '255', }, }, }); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network2.mockEssentialRpcCalls(); await controller.initializeProvider(); expect(controller.store.getState().network).toBe('255'); await waitForStateChanges({ controller, propertyPath: ['network'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.setProviderType(networkType); }, }); expect(controller.store.getState().network).toBe('loading'); }, ); }); it('resets EIP support for the network before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network2.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await controller.initializeProvider(); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.setProviderType(networkType); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, ); }); it(`initializes a provider pointed to the ${nickname} Infura network (chainId: ${chainId})`, async () => { await withController(async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); controller.setProviderType(networkType); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe(chainId); }); }); it('replaces the provider object underlying the provider proxy without creating a new instance of the proxy itself', async () => { await withController(async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider: providerBefore } = controller.getProviderAndBlockTracker(); controller.setProviderType(networkType); const { provider: providerAfter } = controller.getProviderAndBlockTracker(); expect(providerBefore).toBe(providerAfter); }); }); it('emits networkDidChange', async () => { await withController(async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); const networkDidChange = await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.setProviderType(networkType); }, }); expect(networkDidChange).toBe(true); }); }); it('emits infuraIsUnblocked (assuming that the request for eth_blockNumber responds successfully)', async () => { await withController(async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: () => { controller.setProviderType(networkType); }, }); expect(infuraIsUnblocked).toBe(true); }); }); it(`persists "${networkVersion}" to state as the network version of ${nickname}`, async () => { await withController(async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls(); await waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.setProviderType(networkType); }, }); expect(controller.store.getState().network).toBe(networkVersion); }); }); it('persists to state whether the network supports EIP-1559 (assuming that the request for eth_getBlockByNumber responds successfully)', async () => { await withController( { state: { networkDetails: { EIPS: {}, }, }, }, async ({ controller }) => { const network = new NetworkCommunications({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: networkType, }, }); network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], count: 2, operation: () => { controller.setProviderType(networkType); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(true); }, ); }); }); } describe('given a type of "rpc"', () => { it('throws', async () => { await withController(async ({ controller }) => { expect(() => controller.setProviderType('rpc')).toThrow( new Error( 'NetworkController - cannot call "setProviderType" with type "rpc". Use "setActiveNetwork"', ), ); }); }); }); describe('given an invalid Infura network name', () => { it('throws', async () => { await withController(async ({ controller }) => { expect(() => controller.setProviderType('sadlflaksdj')).toThrow( new Error('Unknown Infura provider type "sadlflaksdj".'), ); }); }); }); }); describe('resetConnection', () => { for (const { nickname, networkType, chainId, networkVersion, } of INFURA_NETWORKS) { describe(`when the type in the provider configuration is "${networkType}"`, () => { it('emits networkWillChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const networkWillChange = await waitForEvent({ controller, eventName: 'networkWillChange', operation: () => { controller.resetConnection(); }, }); expect(networkWillChange).toBe(true); }, ); }); it('resets the network state to "loading" before emitting networkDidChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { times: 2, }, }); await controller.initializeProvider(); expect(controller.store.getState().network).toBe(networkVersion); await waitForStateChanges({ controller, propertyPath: ['network'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.resetConnection(); }, }); expect(controller.store.getState().network).toBe('loading'); }, ); }); it('resets EIP support for the network before emitting networkDidChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, eth_blockNumber: { times: 2, }, }); await controller.initializeProvider(); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.resetConnection(); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, ); }); it(`initializes a new provider object pointed to the current Infura network (name: ${nickname}, chain ID: ${chainId})`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); controller.resetConnection(); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe(chainId); }, ); }); it('replaces the provider object underlying the provider proxy without creating a new instance of the proxy itself', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider: providerBefore } = controller.getProviderAndBlockTracker(); controller.resetConnection(); const { provider: providerAfter } = controller.getProviderAndBlockTracker(); expect(providerBefore).toBe(providerAfter); }, ); }); it('emits networkDidChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const networkDidChange = await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.resetConnection(); }, }); expect(networkDidChange).toBe(true); }, ); }); it('emits infuraIsUnblocked (assuming that the request for eth_blockNumber responds successfully)', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: () => { controller.resetConnection(); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); it(`ensures that the network version in state is set to "${networkVersion}"`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.resetConnection(); }, }); expect(controller.store.getState().network).toBe(networkVersion); }, ); }); it('does not ensure that EIP-1559 support for the current network is up to date', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); controller.resetConnection(); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); }, ); }); }); } describe(`when the type in the provider configuration is "rpc"`, () => { it('emits networkWillChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const networkWillChange = await waitForEvent({ controller, eventName: 'networkWillChange', operation: () => { controller.resetConnection(); }, }); expect(networkWillChange).toBe(true); }, ); }); it('resets the network state to "loading" before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ eth_blockNumber: { times: 2, }, net_version: { response: { result: '255', }, }, }); await controller.initializeProvider(); expect(controller.store.getState().network).toBe('255'); await waitForStateChanges({ controller, propertyPath: ['network'], // We only care about the first state change, because it happens // before networkDidChange count: 1, operation: () => { controller.resetConnection(); }, }); expect(controller.store.getState().network).toBe('loading'); }, ); }); it('resets EIP support for the network before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, eth_blockNumber: { times: 2, }, }); await controller.initializeProvider(); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForStateChanges({ controller, propertyPath: ['networkDetails'], // We only care about the first state change, because it happens // before networkDidChange count: 1, operation: () => { controller.resetConnection(); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, ); }); it('initializes a new provider object pointed to the same RPC URL as the current network and using the same chain ID', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); controller.resetConnection(); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe('0x1337'); }, ); }); it('replaces the provider object underlying the provider proxy without creating a new instance of the proxy itself', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); await controller.initializeProvider(); const { provider: providerBefore } = controller.getProviderAndBlockTracker(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.resetConnection(); }, }); const { provider: providerAfter } = controller.getProviderAndBlockTracker(); expect(providerBefore).toBe(providerAfter); }, ); }); it('emits networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const networkDidChange = await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.resetConnection(); }, }); expect(networkDidChange).toBe(true); }, ); }); it('emits infuraIsUnblocked', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls(); const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: () => { controller.resetConnection(); }, }); expect(infuraIsUnblocked).toBe(true); }, ); }); it('ensures that the network version in state is up to date', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ net_version: { response: { result: '42', }, }, }); await waitForStateChanges({ controller, propertyPath: ['network'], operation: () => { controller.resetConnection(); }, }); expect(controller.store.getState().network).toBe('42'); }, ); }); it('does not ensure that EIP-1559 support for the current network is up to date', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network }) => { network.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); controller.resetConnection(); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBeUndefined(); }, ); }); }); }); describe('rollbackToPreviousProvider', () => { for (const { nickname, networkType, chainId, networkVersion, } of INFURA_NETWORKS) { describe(`if the previous provider configuration had a type of "${networkType}"`, () => { it('overwrites the the current provider configuration with the previous provider configuration', async () => { await withController( { state: { provider: { type: networkType, rpcUrl: '', chainId: BUILT_IN_NETWORKS[networkType].chainId, nickname: '', ticker: BUILT_IN_NETWORKS[networkType].ticker, rpcPrefs: { blockExplorerUrl: BUILT_IN_NETWORKS[networkType].blockExplorerUrl, }, }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', nickname: 'test-chain', ticker: 'TEST', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com', }, id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'http://mock-rpc-url-2', chainId: '0xtest2', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, }, networkDetails: { EIPS: {}, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId1'); }, }); expect(controller.store.getState().provider).toStrictEqual({ rpcUrl: 'https://mock-rpc-url-1', chainId: '0xtest', nickname: 'test-chain', ticker: 'TEST', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com', }, id: 'testNetworkConfigurationId1', type: 'rpc', }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(controller.store.getState().provider).toStrictEqual({ type: networkType, rpcUrl: '', chainId: BUILT_IN_NETWORKS[networkType].chainId, ticker: BUILT_IN_NETWORKS[networkType].ticker, nickname: '', rpcPrefs: { blockExplorerUrl: BUILT_IN_NETWORKS[networkType].blockExplorerUrl, }, }); }, ); }); it('emits networkWillChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { const networkWillChange = await waitForEvent({ controller, eventName: 'networkWillChange', operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(networkWillChange).toBe(true); }, }); }, ); }); it('resets the network state to "loading" before emitting networkDidChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls({ net_version: { response: { result: '255', }, }, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(controller.store.getState().network).toBe('255'); await waitForLookupNetworkToComplete({ controller, operation: async () => { await waitForStateChanges({ controller, propertyPath: ['network'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(controller.store.getState().network).toBe('loading'); }, }); }, ); }); it('resets EIP support for the network before emitting networkDidChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { await waitForStateChanges({ controller, propertyPath: ['networkDetails'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect( controller.store.getState().networkDetails, ).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, }); }, ); }); it(`initializes a provider pointed to the ${nickname} Infura network (chainId: ${chainId})`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe(chainId); }, ); }); it('replaces the provider object underlying the provider proxy without creating a new instance of the proxy itself', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); const { provider: providerBefore } = controller.getProviderAndBlockTracker(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); const { provider: providerAfter } = controller.getProviderAndBlockTracker(); expect(providerBefore).toBe(providerAfter); }, ); }); it('emits networkDidChange', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { const networkDidChange = await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(networkDidChange).toBe(true); }, }); }, ); }); it('emits infuraIsUnblocked (assuming that the request for eth_blockNumber responds successfully)', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(infuraIsUnblocked).toBe(true); }, }); }, ); }); it(`persists "${networkVersion}" to state as the network version of ${nickname}`, async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls({ net_version: { response: { result: '255', }, }, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect(controller.store.getState().network).toBe('255'); await waitForLookupNetworkToComplete({ controller, numberOfNetworkDetailsChanges: 2, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(controller.store.getState().network).toBe(networkVersion); }, ); }); it('persists to state whether the network supports EIP-1559 (assuming that the request for eth_getBlockByNumber responds successfully)', async () => { await withController( { state: { provider: { type: networkType, // NOTE: This doesn't need to match the logical chain ID of // the network selected, it just needs to exist chainId: '0x9999999', }, networkConfigurations: { testNetworkConfigurationId: { id: 'testNetworkConfigurationId', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); const network2 = network1.with({ networkClientType: 'custom', networkClientOptions: { customRpcUrl: 'https://mock-rpc-url', }, }); network2.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, net_version: { response: { result: '99999', }, }, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setActiveNetwork('testNetworkConfigurationId'); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(false); await waitForLookupNetworkToComplete({ controller, numberOfNetworkDetailsChanges: 2, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(true); }, ); }); }); } describe(`if the previous provider configuration had a type of "rpc"`, () => { it('overwrites the the current provider configuration with the previous provider configuration', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, networkDetails: { EIPS: { 1559: false, }, }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', nickname: 'test-chain', ticker: 'TEST', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com', }, id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); expect(controller.store.getState().provider).toStrictEqual({ type: 'goerli', rpcUrl: '', chainId: '0x5', ticker: 'GoerliETH', nickname: '', rpcPrefs: { blockExplorerUrl: 'https://goerli.etherscan.io', }, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(controller.store.getState().provider).toStrictEqual({ type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', nickname: 'test-chain-2', ticker: 'TEST2', rpcPrefs: { blockExplorerUrl: 'test-block-explorer-2.com', }, id: 'testNetworkConfigurationId2', }); }, ); }); it('emits networkWillChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, networkConfigurations: { testNetworkConfigurationId1: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId1', }, testNetworkConfigurationId2: { rpcUrl: 'https://mock-rpc-url-2', chainId: '0x1337', ticker: 'TEST2', id: 'testNetworkConfigurationId2', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { const networkWillChange = await waitForEvent({ controller, eventName: 'networkWillChange', operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(networkWillChange).toBe(true); }, }); }, ); }); it('resets the network state to "loading" before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); expect(controller.store.getState().network).toBe('5'); await waitForLookupNetworkToComplete({ controller, operation: async () => { await waitForStateChanges({ controller, propertyPath: ['network'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(controller.store.getState().network).toBe('loading'); }, }); }, ); }); it('resets EIP support for the network before emitting networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); expect(controller.store.getState().networkDetails).toStrictEqual({ EIPS: { 1559: true, }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { await waitForStateChanges({ controller, propertyPath: ['networkDetails'], // We only care about the first state change, because it // happens before networkDidChange count: 1, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect( controller.store.getState().networkDetails, ).toStrictEqual({ EIPS: { 1559: undefined, }, }); }, }); }, ); }); it('initializes a provider pointed to the given RPC URL whose chain ID matches the previously configured chain ID', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0x1337', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); const { provider } = controller.getProviderAndBlockTracker(); const promisifiedSendAsync = promisify(provider.sendAsync).bind( provider, ); const { result: chainIdResult } = await promisifiedSendAsync({ method: 'eth_chainId', }); expect(chainIdResult).toBe('0x1337'); }, ); }); it('replaces the provider object underlying the provider proxy without creating a new instance of the proxy itself', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); const { provider: providerBefore } = controller.getProviderAndBlockTracker(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); const { provider: providerAfter } = controller.getProviderAndBlockTracker(); expect(providerBefore).toBe(providerAfter); }, ); }); it('emits networkDidChange', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { const networkDidChange = await waitForEvent({ controller, eventName: 'networkDidChange', operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(networkDidChange).toBe(true); }, }); }, ); }); it('emits infuraIsUnblocked', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls(); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); await waitForLookupNetworkToComplete({ controller, operation: async () => { const infuraIsUnblocked = await waitForEvent({ controller, eventName: 'infuraIsUnblocked', operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(infuraIsUnblocked).toBe(true); }, }); }, ); }); it('persists the network version to state (assuming that the request for net_version responds successfully)', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ net_version: { response: { result: '42', }, }, }); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls(); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); expect(controller.store.getState().network).toBe('5'); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect(controller.store.getState().network).toBe('42'); }, ); }); it('persists to state whether the network supports EIP-1559 (assuming that the request for eth_getBlockByNumber responds successfully)', async () => { await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller, network: network1 }) => { network1.mockEssentialRpcCalls({ latestBlock: POST_1559_BLOCK, net_version: { response: { result: '99999', }, }, }); const network2 = network1.with({ networkClientType: 'infura', networkClientOptions: { infuraNetwork: 'goerli', }, }); network2.mockEssentialRpcCalls({ latestBlock: PRE_1559_BLOCK, }); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.setProviderType('goerli'); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(false); await waitForLookupNetworkToComplete({ controller, operation: () => { controller.rollbackToPreviousProvider(); }, }); expect( controller.store.getState().networkDetails.EIPS['1559'], ).toBe(true); }, ); }); }); }); describe('upsertNetworkConfiguration', () => { it('throws if the given chain ID is not a 0x-prefixed hex number', async () => { const invalidChainId = '1'; await withController(async ({ controller }) => { expect(() => controller.upsertNetworkConfiguration( { chainId: invalidChainId, nickname: 'RPC', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com' }, rpcUrl: 'rpc_url', ticker: 'RPC', }, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }, ), ).toThrow( new Error( `Invalid chain ID "${invalidChainId}": invalid hex string.`, ), ); }); }); it('throws if the given chain ID is greater than the maximum allowed ID', async () => { await withController(async ({ controller }) => { expect(() => controller.upsertNetworkConfiguration( { chainId: '0xFFFFFFFFFFFFFFFF', nickname: 'RPC', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com' }, rpcUrl: 'rpc_url', ticker: 'RPC', }, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }, ), ).toThrow( new Error( 'Invalid chain ID "0xFFFFFFFFFFFFFFFF": numerical value greater than max safe value.', ), ); }); }); it('throws if the no (or a falsy) rpcUrl is passed', async () => { await withController(async ({ controller }) => { expect(() => controller.upsertNetworkConfiguration( { chainId: '0x9999', nickname: 'RPC', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com' }, ticker: 'RPC', }, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }, ), ).toThrow( new Error( 'An rpcUrl is required to add or update network configuration', ), ); }); }); it('throws if rpcUrl passed is not a valid Url', async () => { await withController(async ({ controller }) => { expect(() => controller.upsertNetworkConfiguration( { chainId: '0x9999', nickname: 'RPC', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com' }, ticker: 'RPC', rpcUrl: 'test', }, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }, ), ).toThrow(new Error('rpcUrl must be a valid URL')); }); }); it('throws if the no (or a falsy) ticker is passed', async () => { await withController(async ({ controller }) => { expect(() => controller.upsertNetworkConfiguration( { chainId: '0x5', nickname: 'RPC', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com' }, rpcUrl: 'https://mock-rpc-url', }, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }, ), ).toThrow( new Error( 'A ticker is required to add or update networkConfiguration', ), ); }); }); it('throws if an options object is not passed as a second argument', async () => { await withController(async ({ controller }) => { expect(() => controller.upsertNetworkConfiguration({ chainId: '0x5', nickname: 'RPC', rpcPrefs: { blockExplorerUrl: 'test-block-explorer.com' }, rpcUrl: 'https://mock-rpc-url', }), ).toThrow( new Error( "Cannot read properties of undefined (reading 'setActive')", ), ); }); }); it('should add the given network if all required properties are present but nither rpcPrefs nor nickname properties are passed', async () => { v4.mockImplementationOnce(() => 'networkConfigurationId'); await withController( { state: { networkConfigurations: {}, }, }, async ({ controller }) => { const rpcUrlNetwork = { chainId: '0x1', rpcUrl: 'https://test-rpc-url', ticker: 'test_ticker', }; controller.upsertNetworkConfiguration(rpcUrlNetwork, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual( expect.arrayContaining([ { ...rpcUrlNetwork, nickname: undefined, rpcPrefs: undefined, id: 'networkConfigurationId', }, ]), ); }, ); }); it('adds new networkConfiguration to networkController store, but only adds valid properties (rpcUrl, chainId, ticker, nickname, rpcPrefs) and fills any missing properties from this list as undefined', async function () { v4.mockImplementationOnce(() => 'networkConfigurationId'); await withController( { state: { networkConfigurations: {}, }, }, async ({ controller }) => { const rpcUrlNetwork = { chainId: '0x1', rpcUrl: 'https://test-rpc-url', ticker: 'test_ticker', invalidKey: 'new-chain', invalidKey2: {}, }; controller.upsertNetworkConfiguration(rpcUrlNetwork, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual( expect.arrayContaining([ { chainId: '0x1', rpcUrl: 'https://test-rpc-url', ticker: 'test_ticker', nickname: undefined, rpcPrefs: undefined, id: 'networkConfigurationId', }, ]), ); }, ); }); it('should add the given network configuration if its rpcURL does not match an existing configuration without changing or overwriting other configurations', async () => { v4.mockImplementationOnce(() => 'networkConfigurationId2'); await withController( { state: { networkConfigurations: { networkConfigurationId: { rpcUrl: 'https://test-rpc-url', ticker: 'ticker', nickname: 'nickname', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '0x1', id: 'networkConfigurationId', }, }, }, }, async ({ controller }) => { const rpcUrlNetwork = { chainId: '0x1', nickname: 'RPC', rpcPrefs: undefined, rpcUrl: 'https://test-rpc-url-2', ticker: 'RPC', }; controller.upsertNetworkConfiguration(rpcUrlNetwork, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual( expect.arrayContaining([ { rpcUrl: 'https://test-rpc-url', ticker: 'ticker', nickname: 'nickname', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '0x1', id: 'networkConfigurationId', }, { ...rpcUrlNetwork, id: 'networkConfigurationId2' }, ]), ); }, ); }); it('should use the given configuration to update an existing network configuration that has a matching rpcUrl', async () => { await withController( { state: { networkConfigurations: { networkConfigurationId: { rpcUrl: 'https://test-rpc-url', ticker: 'old_rpc_ticker', nickname: 'old_rpc_chainName', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '0x1', id: 'networkConfigurationId', }, }, }, }, async ({ controller }) => { const updatedConfiguration = { rpcUrl: 'https://test-rpc-url', ticker: 'new_rpc_ticker', nickname: 'new_rpc_chainName', rpcPrefs: { blockExplorerUrl: 'alternativetestchainscan.io' }, chainId: '0x1', }; controller.upsertNetworkConfiguration(updatedConfiguration, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual([ { rpcUrl: 'https://test-rpc-url', nickname: 'new_rpc_chainName', ticker: 'new_rpc_ticker', rpcPrefs: { blockExplorerUrl: 'alternativetestchainscan.io' }, chainId: '0x1', id: 'networkConfigurationId', }, ]); }, ); }); it('should use the given configuration to update an existing network configuration that has a matching rpcUrl without changing or overwriting other networkConfigurations', async () => { await withController( { state: { networkConfigurations: { networkConfigurationId: { rpcUrl: 'https://test-rpc-url', ticker: 'ticker', nickname: 'nickname', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '0x1', id: 'networkConfigurationId', }, networkConfigurationId2: { rpcUrl: 'https://test-rpc-url-2', ticker: 'ticker-2', nickname: 'nickname-2', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '0x9999', id: 'networkConfigurationId2', }, }, }, }, async ({ controller }) => { controller.upsertNetworkConfiguration( { rpcUrl: 'https://test-rpc-url', ticker: 'new-ticker', nickname: 'new-nickname', rpcPrefs: { blockExplorerUrl: 'alternativetestchainscan.io' }, chainId: '0x1', }, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }, ); expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual([ { rpcUrl: 'https://test-rpc-url', ticker: 'new-ticker', nickname: 'new-nickname', rpcPrefs: { blockExplorerUrl: 'alternativetestchainscan.io' }, chainId: '0x1', id: 'networkConfigurationId', }, { rpcUrl: 'https://test-rpc-url-2', ticker: 'ticker-2', nickname: 'nickname-2', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '0x9999', id: 'networkConfigurationId2', }, ]); }, ); }); it('should add the given network and not set it to active if the setActive option is not passed (or a falsy value is passed)', async () => { v4.mockImplementationOnce(() => 'networkConfigurationId'); const originalProvider = { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }; await withController( { state: { provider: originalProvider, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller }) => { const rpcUrlNetwork = { chainId: '0x1', rpcUrl: 'https://test-rpc-url', ticker: 'test_ticker', }; controller.upsertNetworkConfiguration(rpcUrlNetwork, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect(controller.store.getState().provider).toStrictEqual( originalProvider, ); }, ); }); it('should add the given network and set it to active if the setActive option is passed as true', async () => { v4.mockImplementationOnce(() => 'networkConfigurationId'); await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, }, async ({ controller }) => { const rpcUrlNetwork = { chainId: '0x1', rpcUrl: 'https://test-rpc-url', ticker: 'test_ticker', }; controller.upsertNetworkConfiguration(rpcUrlNetwork, { setActive: true, referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect(controller.store.getState().provider).toStrictEqual({ ...rpcUrlNetwork, nickname: undefined, rpcPrefs: undefined, type: 'rpc', id: 'networkConfigurationId', }); }, ); }); it('adds new networkConfiguration to networkController store and calls to the metametrics event tracking with the correct values', async () => { v4.mockImplementationOnce(() => 'networkConfigurationId'); const trackEventSpy = jest.fn(); await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, trackMetaMetricsEvent: trackEventSpy, }, async ({ controller }) => { const newNetworkConfiguration = { rpcUrl: 'https://new-chain-rpc-url', chainId: '0x9999', ticker: 'NEW', nickname: 'new-chain', rpcPrefs: { blockExplorerUrl: 'https://block-explorer' }, }; controller.upsertNetworkConfiguration(newNetworkConfiguration, { referrer: 'https://test-dapp.com', source: EVENT.SOURCE.NETWORK.DAPP, }); expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual([ { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, { ...newNetworkConfiguration, id: 'networkConfigurationId', }, ]); expect(trackEventSpy).toHaveBeenCalledWith({ event: 'Custom Network Added', category: 'Network', referrer: { url: 'https://test-dapp.com', }, properties: { chain_id: '0x9999', symbol: 'NEW', source: 'dapp', }, }); }, ); }); it('throws if referrer and source arguments are not passed', async () => { v4.mockImplementationOnce(() => 'networkConfigurationId'); const trackEventSpy = jest.fn(); await withController( { state: { provider: { type: 'rpc', rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, networkConfigurations: { testNetworkConfigurationId: { rpcUrl: 'https://mock-rpc-url', chainId: '0xtest', ticker: 'TEST', id: 'testNetworkConfigurationId', }, }, }, trackMetaMetricsEvent: trackEventSpy, }, async ({ controller }) => { const newNetworkConfiguration = { rpcUrl: 'https://new-chain-rpc-url', chainId: '0x9999', ticker: 'NEW', nickname: 'new-chain', rpcPrefs: { blockExplorerUrl: 'https://block-explorer' }, }; expect(() => controller.upsertNetworkConfiguration(newNetworkConfiguration, {}), ).toThrow( 'referrer and source are required arguments for adding or updating a network configuration', ); }, ); }); }); describe('removeNetworkConfigurations', () => { it('should remove a network configuration', async () => { const networkConfigurationId = 'networkConfigurationId'; await withController( { state: { networkConfigurations: { [networkConfigurationId]: { rpcUrl: 'https://test-rpc-url', ticker: 'old_rpc_ticker', nickname: 'old_rpc_chainName', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '1', }, }, }, }, async ({ controller }) => { expect( Object.values(controller.store.getState().networkConfigurations), ).toStrictEqual([ { rpcUrl: 'https://test-rpc-url', ticker: 'old_rpc_ticker', nickname: 'old_rpc_chainName', rpcPrefs: { blockExplorerUrl: 'testchainscan.io' }, chainId: '1', }, ]); controller.removeNetworkConfiguration(networkConfigurationId); expect( controller.store.getState().networkConfigurations, ).toStrictEqual({}); }, ); }); }); }); /** * Builds a controller based on the given options, and calls the given function * with that controller. * * @param args - Either a function, or an options bag + a function. The options * bag is the same that NetworkController takes; the function will be called * with the built controller as well as an object that can be used to mock * requests. * @returns Whatever the callback returns. */ async function withController(...args) { const [givenConstructorOptions, fn] = args.length === 2 ? args : [{}, args[0]]; const constructorOptions = { ...DEFAULT_CONTROLLER_OPTIONS, ...givenConstructorOptions, }; const controller = new NetworkController(constructorOptions); const providerConfig = controller.store.getState().provider; const networkClientType = providerConfig.type === 'rpc' ? 'custom' : 'infura'; const { infuraProjectId } = constructorOptions; const infuraNetwork = networkClientType === 'infura' ? providerConfig.type : undefined; const customRpcUrl = networkClientType === 'custom' ? providerConfig.rpcUrl : undefined; const network = new NetworkCommunications({ networkClientType, networkClientOptions: { infuraProjectId, infuraNetwork, customRpcUrl }, }); try { return await fn({ controller, network }); } finally { await controller.destroy(); } } /** * For each kind of way that the provider can be set, `lookupNetwork` is always * called. This can cause difficulty when testing the behavior of * `lookupNetwork` itself, as extra requests then have to be mocked. * This function takes a function that presumably sets the provider, * stubbing `lookupNetwork` before the function and releasing the stub * afterward. * * @param {object} args - The arguments. * @param {NetworkController} args.controller - The network controller. * @param {() => void | Promise} args.operation - The function that * presumably involves `lookupNetwork`. */ async function withoutCallingLookupNetwork({ controller, operation }) { const spy = jest .spyOn(controller, 'lookupNetwork') .mockResolvedValue(undefined); await operation(); spy.mockRestore(); } /** * For each kind of way that the provider can be set, `getEIP1559Compatibility` * is always called. This can cause difficulty when testing the behavior of * `getEIP1559Compatibility` itself, as extra requests then have to be * mocked. This function takes a function that presumably sets the provider, * stubbing `getEIP1559Compatibility` before the function and releasing the stub * afterward. * * @param {object} args - The arguments. * @param {NetworkController} args.controller - The network controller. * @param {() => void | Promise} args.operation - The function that * presumably involves `getEIP1559Compatibility`. */ async function withoutCallingGetEIP1559Compatibility({ controller, operation, }) { const spy = jest .spyOn(controller, 'getEIP1559Compatibility') .mockResolvedValue(undefined); await operation(); spy.mockRestore(); } /** * Waits for changes to the primary observable store of a controller to occur * before proceeding. May be called with a function, in which case waiting will * occur after the function is called; or may be called standalone if you want * to assert that no state changes occurred. * * @param {object} [args] - The arguments. * @param {NetworkController} args.controller - The network controller. * @param {string[]} [args.propertyPath] - The path of the property you * expect the state changes to concern. * @param {number | null} [args.count] - The number of events you expect to * occur. If null, this function will wait until no events have occurred in * `wait` number of milliseconds. Default: 1. * @param {number} [args.duration] - The amount of time in milliseconds to * wait for the expected number of filtered state changes to occur before * resolving the promise that this function returns (default: 150). * @param {() => void | Promise} [args.operation] - A function to run * that will presumably produce the state changes in question. * @returns A promise that resolves to an array of state objects (that is, the * contents of the store) when the specified number of filtered state changes * have occurred, or all of them if no number has been specified. */ async function waitForStateChanges({ controller, propertyPath, count: expectedInterestingStateCount = 1, duration: timeBeforeAssumingNoMoreStateChanges = 150, operation = () => { // do nothing }, }) { const initialState = { ...controller.store.getState() }; let isTimerRunning = false; const getPropertyFrom = (state) => { return propertyPath === undefined ? state : propertyPath.reduce((finalValue, part) => finalValue[part], state); }; const isStateChangeInteresting = (newState, prevState) => { return !isDeepStrictEqual( getPropertyFrom(newState, propertyPath), getPropertyFrom(prevState, propertyPath), ); }; const promiseForStateChanges = new Promise((resolve, reject) => { // We need to declare this variable first, then assign it later, so that // ESLint won't complain that resetTimer is referring to this variable // before it's declared. And we need to use let so that we can assign it // below. /* eslint-disable-next-line prefer-const */ let eventListener; let timer; const allStates = []; const interestingStates = []; const stopTimer = () => { if (timer) { clearTimeout(timer); } isTimerRunning = false; }; const end = () => { stopTimer(); controller.store.unsubscribe(eventListener); const shouldEnd = expectedInterestingStateCount === null ? interestingStates.length > 0 : interestingStates.length === expectedInterestingStateCount; if (shouldEnd) { resolve(interestingStates); } else { // Using a string instead of an Error leads to better backtraces. /* eslint-disable-next-line prefer-promise-reject-errors */ const expectedInterestingStateCountFragment = expectedInterestingStateCount === null ? 'any number of' : expectedInterestingStateCount; const propertyPathFragment = propertyPath === undefined ? '' : ` on \`${propertyPath.join('.')}\``; const actualInterestingStateCountFragment = expectedInterestingStateCount === null ? 'none' : interestingStates.length; const primaryMessage = `Expected to receive ${expectedInterestingStateCountFragment} state change(s)${propertyPathFragment}, but received ${actualInterestingStateCountFragment} after ${timeBeforeAssumingNoMoreStateChanges}ms.`; reject( [ primaryMessage, 'Initial state:', inspect(initialState, { depth: null }), 'All state changes (without filtering):', inspect(allStates, { depth: null }), 'Filtered state changes:', inspect(interestingStates, { depth: null }), ].join('\n\n'), ); } }; const resetTimer = () => { stopTimer(); timer = originalSetTimeout(() => { if (isTimerRunning) { end(); } }, timeBeforeAssumingNoMoreStateChanges); isTimerRunning = true; }; eventListener = (newState) => { const isInteresting = isStateChangeInteresting( newState, allStates.length > 0 ? allStates[allStates.length - 1] : initialState, ); allStates.push({ ...newState }); if (isInteresting) { interestingStates.push(newState); if (interestingStates.length === expectedInterestingStateCount) { end(); } else { resetTimer(); } } }; controller.store.subscribe(eventListener); resetTimer(); }); await operation(); return await promiseForStateChanges; } /** * Waits for an event to occur on the controller before proceeding. * * @param {{controller: NetworkController, eventName: string, operation: (() => void | Promise), beforeResolving?: (() => void | Promise)}} args - The arguments. * @param {NetworkController} args.controller - The network controller * @param {string} args.eventName - The name of the event. * @param {() => void | Promise} args.operation - A function that will * presumably produce the event in question. * @param {() => void | Promise} [args.beforeResolving] - In some tests, * state updates happen so fast, we need to make an assertion immediately after * the event in question occurs. However, if we wait until the promise this * function returns resolves to do so, some other state update to the same * property may have happened. This option allows you to make an assertion * _before_ the promise resolves. This has the added benefit of allowing you to * maintain the "arrange, act, assert" ordering in your test, meaning that * you can still call the method that kicks off the event and then make the * assertion afterward instead of the other way around. * @returns {Promise} */ async function waitForEvent({ controller, eventName, operation, beforeResolving = async () => { // do nothing }, }) { const promise = new Promise((resolve) => { controller.once(eventName, () => { Promise.resolve(beforeResolving()).then(() => { resolve(true); }); }); }); await operation(); return await promise; } /** * `lookupNetwork` is a method in NetworkController which is called internally * by a few methods. `lookupNetwork` is asynchronous as it makes network * requests under the hood, but unfortunately, the method is not awaited after * being called. Hence, if it is called during a test, even if the network * requests are initiated within the test, they may complete after that test * ends. This is a problem because it may cause Nock mocks set up in a later * test to get used up prematurely, causing failures. * * To fix this, we need to wait for `lookupNetwork` to fully finish before * continuing. Since the latest thing that happens in `lookupNetwork` is to * update EIP-1559 compatibility in state, we can wait for the `networkDetails` * state to get updated specifically. Unfortunately, we don't know how many * times this will happen, so this function does incur some time when it's used. * To speed up tests, you can pass `numberOfNetworkDetailsChanges`. * * * @param {object} args - The arguments. * @param {NetworkController} args.controller - The network controller. * @param {count} [args.numberOfNetworkDetailsChanges] - The number of times * that `networkDetails` is expected to be updated. * @param {() => void | Promise} [args.operation] - The function that * presumably involves `lookupNetwork`. */ async function waitForLookupNetworkToComplete({ controller, numberOfNetworkDetailsChanges = null, operation, }) { await waitForStateChanges({ controller, propertyPath: ['networkDetails'], operation, count: numberOfNetworkDetailsChanges, }); }