mirror of
https://github.com/kremalicious/metamask-extension.git
synced 2024-12-23 09:52:26 +01:00
ed3cc404f2
The `network` store of the network controller crams two types of data into one place. It roughly tracks whether we have enough information to make requests to the network and whether the network is capable of receiving requests, but it also stores the ID of the network (as obtained via `net_version`). Generally we shouldn't be using the network ID for anything, as it has been completely replaced by chain ID, which all custom RPC endpoints have been required to support for over a year now. However, as the network ID is used in various places within the extension codebase, removing it entirely would be a non-trivial effort. So, minimally, this commit splits `network` into two stores: `networkId` and `networkStatus`. But it also expands the concept of network status. Previously, the network was in one of two states: "loading" and "not-loading". But now it can be in one of four states: - `available`: The network is able to receive and respond to requests. - `unavailable`: The network is not able to receive and respond to requests for unknown reasons. - `blocked`: The network is actively blocking requests based on the user's geolocation. (This is specific to Infura.) - `unknown`: We don't know whether the network can receive and respond to requests, either because we haven't checked or we tried to check and were unsuccessful. This commit also changes how the network status is determined — specifically, how many requests are used to determine that status, when they occur, and whether they are awaited. Previously, the network controller would make 2 to 3 requests during the course of running `lookupNetwork`. * First, if it was an Infura network, it would make a request for `eth_blockNumber` to determine whether Infura was blocking requests or not, then emit an appropriate event. This operation was not awaited. * Then, regardless of the network, it would fetch the network ID via `net_version`. This operation was awaited. * Finally, regardless of the network, it would fetch the latest block via `eth_getBlockByNumber`, then use the result to determine whether the network supported EIP-1559. This operation was awaited. Now: * One fewer request is made, specifically `eth_blockNumber`, as we don't need to make an extra request to determine whether Infura is blocking requests; we can reuse `eth_getBlockByNumber`; * All requests are awaited, which makes `lookupNetwork` run fully in-band instead of partially out-of-band; and * Both requests for `net_version` and `eth_getBlockByNumber` are performed in parallel to make `lookupNetwork` run slightly faster.
250 lines
7.0 KiB
JavaScript
250 lines
7.0 KiB
JavaScript
import copyToClipboard from 'copy-to-clipboard';
|
|
import log from 'loglevel';
|
|
import { clone } from 'lodash';
|
|
import React from 'react';
|
|
import { render } from 'react-dom';
|
|
import browser from 'webextension-polyfill';
|
|
|
|
import { getEnvironmentType } from '../app/scripts/lib/util';
|
|
import { AlertTypes } from '../shared/constants/alerts';
|
|
import { maskObject } from '../shared/modules/object.utils';
|
|
import { SENTRY_STATE } from '../app/scripts/lib/setupSentry';
|
|
import { ENVIRONMENT_TYPE_POPUP } from '../shared/constants/app';
|
|
import switchDirection from '../shared/lib/switch-direction';
|
|
import { setupLocale } from '../shared/lib/error-utils';
|
|
import * as actions from './store/actions';
|
|
import configureStore from './store/store';
|
|
import {
|
|
getPermittedAccountsForCurrentTab,
|
|
getSelectedAddress,
|
|
} from './selectors';
|
|
import { ALERT_STATE } from './ducks/alerts';
|
|
import {
|
|
getUnconnectedAccountAlertEnabledness,
|
|
getUnconnectedAccountAlertShown,
|
|
} from './ducks/metamask/metamask';
|
|
import Root from './pages';
|
|
import txHelper from './helpers/utils/tx-helper';
|
|
import { _setBackgroundConnection } from './store/action-queue';
|
|
|
|
log.setLevel(global.METAMASK_DEBUG ? 'debug' : 'warn');
|
|
|
|
let reduxStore;
|
|
|
|
/**
|
|
* Method to update backgroundConnection object use by UI
|
|
*
|
|
* @param backgroundConnection - connection object to background
|
|
*/
|
|
export const updateBackgroundConnection = (backgroundConnection) => {
|
|
_setBackgroundConnection(backgroundConnection);
|
|
backgroundConnection.onNotification((data) => {
|
|
if (data.method === 'sendUpdate') {
|
|
reduxStore.dispatch(actions.updateMetamaskState(data.params[0]));
|
|
} else {
|
|
throw new Error(
|
|
`Internal JSON-RPC Notification Not Handled:\n\n ${JSON.stringify(
|
|
data,
|
|
)}`,
|
|
);
|
|
}
|
|
});
|
|
};
|
|
|
|
export default function launchMetamaskUi(opts, cb) {
|
|
const { backgroundConnection } = opts;
|
|
///: BEGIN:ONLY_INCLUDE_IN(flask)
|
|
let desktopEnabled = false;
|
|
|
|
backgroundConnection.getDesktopEnabled(function (err, result) {
|
|
if (err) {
|
|
return;
|
|
}
|
|
|
|
desktopEnabled = result;
|
|
});
|
|
///: END:ONLY_INCLUDE_IN
|
|
|
|
// check if we are unlocked first
|
|
backgroundConnection.getState(function (err, metamaskState) {
|
|
if (err) {
|
|
cb(
|
|
err,
|
|
{
|
|
...metamaskState,
|
|
///: BEGIN:ONLY_INCLUDE_IN(flask)
|
|
desktopEnabled,
|
|
///: END:ONLY_INCLUDE_IN
|
|
},
|
|
backgroundConnection,
|
|
);
|
|
return;
|
|
}
|
|
startApp(metamaskState, backgroundConnection, opts).then((store) => {
|
|
setupDebuggingHelpers(store);
|
|
cb(
|
|
null,
|
|
store,
|
|
///: BEGIN:ONLY_INCLUDE_IN(flask)
|
|
backgroundConnection,
|
|
///: END:ONLY_INCLUDE_IN
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
async function startApp(metamaskState, backgroundConnection, opts) {
|
|
// parse opts
|
|
if (!metamaskState.featureFlags) {
|
|
metamaskState.featureFlags = {};
|
|
}
|
|
|
|
const { currentLocaleMessages, enLocaleMessages } = await setupLocale(
|
|
metamaskState.currentLocale,
|
|
);
|
|
|
|
if (metamaskState.textDirection === 'rtl') {
|
|
await switchDirection('rtl');
|
|
}
|
|
|
|
const draftInitialState = {
|
|
activeTab: opts.activeTab,
|
|
|
|
// metamaskState represents the cross-tab state
|
|
metamask: metamaskState,
|
|
|
|
// appState represents the current tab's popup state
|
|
appState: {},
|
|
|
|
localeMessages: {
|
|
currentLocale: metamaskState.currentLocale,
|
|
current: currentLocaleMessages,
|
|
en: enLocaleMessages,
|
|
},
|
|
};
|
|
|
|
updateBackgroundConnection(backgroundConnection);
|
|
|
|
if (getEnvironmentType() === ENVIRONMENT_TYPE_POPUP) {
|
|
const { origin } = draftInitialState.activeTab;
|
|
const permittedAccountsForCurrentTab =
|
|
getPermittedAccountsForCurrentTab(draftInitialState);
|
|
const selectedAddress = getSelectedAddress(draftInitialState);
|
|
const unconnectedAccountAlertShownOrigins =
|
|
getUnconnectedAccountAlertShown(draftInitialState);
|
|
const unconnectedAccountAlertIsEnabled =
|
|
getUnconnectedAccountAlertEnabledness(draftInitialState);
|
|
|
|
if (
|
|
origin &&
|
|
unconnectedAccountAlertIsEnabled &&
|
|
!unconnectedAccountAlertShownOrigins[origin] &&
|
|
permittedAccountsForCurrentTab.length > 0 &&
|
|
!permittedAccountsForCurrentTab.includes(selectedAddress)
|
|
) {
|
|
draftInitialState[AlertTypes.unconnectedAccount] = {
|
|
state: ALERT_STATE.OPEN,
|
|
};
|
|
actions.setUnconnectedAccountAlertShown(origin);
|
|
}
|
|
}
|
|
|
|
const store = configureStore(draftInitialState);
|
|
reduxStore = store;
|
|
|
|
// if unconfirmed txs, start on txConf page
|
|
const unapprovedTxsAll = txHelper(
|
|
metamaskState.unapprovedTxs,
|
|
metamaskState.unapprovedMsgs,
|
|
metamaskState.unapprovedPersonalMsgs,
|
|
metamaskState.unapprovedDecryptMsgs,
|
|
metamaskState.unapprovedEncryptionPublicKeyMsgs,
|
|
metamaskState.unapprovedTypedMessages,
|
|
metamaskState.networkId,
|
|
metamaskState.provider.chainId,
|
|
);
|
|
const numberOfUnapprovedTx = unapprovedTxsAll.length;
|
|
if (numberOfUnapprovedTx > 0) {
|
|
store.dispatch(
|
|
actions.showConfTxPage({
|
|
id: unapprovedTxsAll[0].id,
|
|
}),
|
|
);
|
|
}
|
|
|
|
// global metamask api - used by tooling
|
|
global.metamask = {
|
|
updateCurrentLocale: (code) => {
|
|
store.dispatch(actions.updateCurrentLocale(code));
|
|
},
|
|
setProviderType: (type) => {
|
|
store.dispatch(actions.setProviderType(type));
|
|
},
|
|
setFeatureFlag: (key, value) => {
|
|
store.dispatch(actions.setFeatureFlag(key, value));
|
|
},
|
|
};
|
|
|
|
// start app
|
|
render(<Root store={store} />, opts.container);
|
|
|
|
return store;
|
|
}
|
|
|
|
function setupDebuggingHelpers(store) {
|
|
/**
|
|
* The following stateHook is a method intended to throw an error, used in
|
|
* our E2E test to ensure that errors are attempted to be sent to sentry.
|
|
*/
|
|
window.stateHooks.throwTestError = async function () {
|
|
const error = new Error('Test Error');
|
|
error.name = 'TestError';
|
|
throw error;
|
|
};
|
|
window.stateHooks.getCleanAppState = async function () {
|
|
const state = clone(store.getState());
|
|
state.version = global.platform.getVersion();
|
|
state.browser = window.navigator.userAgent;
|
|
state.completeTxList = await actions.getTransactions({
|
|
filterToCurrentNetwork: false,
|
|
});
|
|
return state;
|
|
};
|
|
window.stateHooks.getSentryState = function () {
|
|
const fullState = store.getState();
|
|
const debugState = maskObject(fullState, SENTRY_STATE);
|
|
return {
|
|
browser: window.navigator.userAgent,
|
|
store: debugState,
|
|
version: global.platform.getVersion(),
|
|
};
|
|
};
|
|
}
|
|
|
|
window.logStateString = async function (cb) {
|
|
const state = await window.stateHooks.getCleanAppState();
|
|
browser.runtime
|
|
.getPlatformInfo()
|
|
.then((platform) => {
|
|
state.platform = platform;
|
|
const stateString = JSON.stringify(state, null, 2);
|
|
cb(null, stateString);
|
|
})
|
|
.catch((err) => {
|
|
cb(err);
|
|
});
|
|
};
|
|
|
|
window.logState = function (toClipboard) {
|
|
return window.logStateString((err, result) => {
|
|
if (err) {
|
|
console.error(err.message);
|
|
} else if (toClipboard) {
|
|
copyToClipboard(result);
|
|
console.log('State log copied');
|
|
} else {
|
|
console.log(result);
|
|
}
|
|
});
|
|
};
|