m/metamask-extension
1
0
Fork 0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-10-22 11:22:43 +02:00
Code

Support hex and number net_version responses (#19156)

Browse Source 
Hex and number responses from the `net_version` request are now
accepted. While most chains return decimal strings for this request,
some chains were returning hex responses instead and failing our
validation for this request (which was added in v10.30.0). This
resolves that problem.

Support for number responses was added because it likely worked in
older versions as well, so support is maintained to avoid similar
problems.

Fixes #19151
This commit is contained in:
Mark Stacey 2023-05-15 18:56:22 -02:30 committed by GitHub
parent 4bd74c5059
commit 05715dd981
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 70 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
app/scripts/controllers/network/network-controller.test.ts
View File

@ -5,6 +5,7 @@ import { v4 } from 'uuid';
import nock from 'nock';
import { ControllerMessenger } from '@metamask/base-controller';
import { SafeEventEmitterProvider } from '@metamask/eth-json-rpc-provider';
import { toHex } from '@metamask/controller-utils';
import { when, resetAllWhenMocks } from 'jest-when';
import { ethErrors } from 'eth-rpc-errors';
import { NETWORK_TYPES } from '../../../../shared/constants/network';
@ -6320,55 +6321,62 @@ function lookupNetworkTests({
operation: (controller: NetworkController) => Promise<void>;
}) {
describe('if the network ID and network details requests resolve successfully', () => {
describe('if the current network is different from the network in state', () => {
it('updates the network in state to match', async () => {
await withController(
{
state: initialState,
},
async ({ controller }) => {
await setFakeProvider(controller, {
stubs: [
{
request: { method: 'net_version' },
response: { result: '12345' },
},
],
stubLookupNetworkWhileSetting: true,
});
const validNetworkIds = [12345, '12345', toHex(12345)];
for (const networkId of validNetworkIds) {
describe(`with a network id of '${networkId}'`, () => {
describe('if the current network is different from the network in state', () => {
it('updates the network in state to match', async () => {
await withController(
{
state: initialState,
},
async ({ controller }) => {
await setFakeProvider(controller, {
stubs: [
{
request: { method: 'net_version' },
response: { result: networkId },
},
],
stubLookupNetworkWhileSetting: true,
});
await operation(controller);
await operation(controller);
expect(controller.store.getState().networkId).toBe('12345');
},
);
expect(controller.store.getState().networkId).toBe('12345');
},
);
});
});
describe('if the version of the current network is the same as that in state', () => {
it('does not change network ID in state', async () => {
await withController(
{
state: initialState,
},
async ({ controller }) => {
await setFakeProvider(controller, {
stubs: [
{
request: { method: 'net_version' },
response: { result: networkId },
},
],
stubLookupNetworkWhileSetting: true,
});
await operation(controller);
await expect(controller.store.getState().networkId).toBe(
'12345',
);
},
);
});
});
});
});
describe('if the version of the current network is the same as that in state', () => {
it('does not change network ID in state', async () => {
await withController(
{
state: initialState,
},
async ({ controller }) => {
await setFakeProvider(controller, {
stubs: [
{
request: { method: 'net_version' },
response: { result: '12345' },
},
],
stubLookupNetworkWhileSetting: true,
});
await operation(controller);
await expect(controller.store.getState().networkId).toBe('12345');
},
);
});
});
}
describe('if the network details of the current network are different from the network details in state', () => {
it('updates the network in state to match', async () => {

25
app/scripts/controllers/network/network-controller.ts
View File

@ -10,10 +10,11 @@ import {
import EthQuery from 'eth-query';
import { RestrictedControllerMessenger } from '@metamask/base-controller';
import { v4 as uuid } from 'uuid';
import { Hex, isPlainObject } from '@metamask/utils';
import { Hex, isPlainObject, isStrictHexString } from '@metamask/utils';
import { errorCodes } from 'eth-rpc-errors';
import { SafeEventEmitterProvider } from '@metamask/eth-json-rpc-provider';
import { PollingBlockTracker } from 'eth-block-tracker';
import { hexToDecimal } from '../../../../shared/modules/conversion.utils';
import {
INFURA_PROVIDER_TYPES,
INFURA_BLOCKED_KEY,
@ -301,15 +302,22 @@ function isErrorWithCode(error: unknown): error is { code: string | number } {
}
/**
* Asserts that the given value is a network ID, i.e., that it is a decimal
* number represented as a string.
* Convert the given value into a valid network ID. The ID is accepted
* as either a number, a decimal string, or a 0x-prefixed hex string.
*
* @param value - The value to check.
* @param value - The network ID to convert, in an unknown format.
* @returns A valid network ID (as a decimal string)
* @throws If the given value cannot be safely parsed.
*/
function assertNetworkId(value: any): asserts value is NetworkId {
if (!/^\d+$/u.test(value) || Number.isNaN(Number(value))) {
throw new Error('value is not a number');
function convertNetworkId(value: unknown): NetworkId {
if (typeof value === 'number' && !Number.isNaN(value)) {
return `${value}`;
} else if (isStrictHexString(value)) {
return hexToDecimal(value) as NetworkId;
} else if (typeof value === 'string' && /^\d+$/u.test(value)) {
return value as NetworkId;
}
throw new Error(`Cannot parse as a valid network ID: '${value}'`);
}
/**
@ -618,8 +626,7 @@ export class NetworkController extends EventEmitter {
this.#determineEIP1559Compatibility(provider),
]);
const possibleNetworkId = results[0];
assertNetworkId(possibleNetworkId);
networkId = possibleNetworkId;
networkId = convertNetworkId(possibleNetworkId);
supportsEIP1559 = results[1];
networkStatus = NetworkStatus.Available;
} catch (error) {