mirror of
https://github.com/kremalicious/metamask-extension.git
synced 2024-12-23 09:52:26 +01:00
f519fa1ed3
* add PermissionsController remove provider approval controller integrate rpc-cap create PermissionsController move provider approval functionality to permissions controller add permissions approval ui, settings page add permissions activity and history move some functionality to metamask-inpage-provider rename siteMetadata -> domainMetadata add accountsChange notification to inpage provider move functionality to inpage provider update inpage provider Remove 'Connections' settings page (#7369) add hooks for exposing accounts in settings rename unused messages in non-English locales Add external extension id to metadata (#7396) update inpage provider, rpc-cap add eth_requestAccounts handling to background prevent notifying connections if extension is locked update inpage provider Fix lint errors add migration review fixes transaction controller review updates removed unused messages * Login Per Site UI (#7368) * LoginPerSite original UI changes to keep * First commit * Get necessary connected tab info for redirect and icon display for permissioned sites * Fix up designs and add missing features * Some lint fixes * More lint fixes * Ensures the tx controller + tx-state-manager orders transactions in the order they are received * Code cleanup for LoginPerSite-ui * Update e2e tests to use new connection flow * Fix display of connect screen and app header after login when connect request present * Update metamask-responsive-ui.spec for new item in accounts dropdown * Fix approve container by replacing approvedOrigins with domainMetaData * Adds test/e2e/permissions.spec.js * Correctly handle cancellation of a permissions request * Redirect to home after disconnecting all sites / cancelling all permissions * Fix display of site icons in menu * Fix height of permissions page container * Remove unused locale messages * Set default values for openExternalTabs and tabIdOrigins in account-menu.container * More code cleanup for LoginPerSite-ui * Use extensions api to close tab in permissions-connect * Remove unnecessary change in domIsReady() in contentscript * Remove unnecessary private function markers and class methods (for background tab info) in metamask-controller. * Adds getOriginOfCurrentTab selector * Adds IconWithFallback component and substitutes for appropriate cases * Add and utilize font mixins * Remove unused method in disconnect-all.container.js * Simplify buttonSizeLarge code in page-container-footer.component.js * Add and utilize getAccountsWithLabels selector * Remove console.log in ui/app/store/actions.js * Change last connected time format to yyyy-M-d * Fix css associated with IconWithFallback change * Ensure tracked openNonMetamaskTabsIDs are correctly set to inactive on tab changes * Code cleanup for LoginPerSite-ui * Use reusable function for modifying openNonMetamaskTabsIDs in background.js * Enables automatic switching to connected account when connected domain is open * Prevent exploit of tabIdOriginMap in background.js * Remove unneeded code from contentscript.js * Simplify current tab origin and window opener logic using remotePort listener tabs.queryTabs * Design and styling fixes for LoginPerSite-ui * Fix permissionHistory and permission logging for eth_requestAccounts and eth_accounts * Front end changes to support display of lastConnected time in connected and permissions screens * Fix lint errors * Refactor structure of permissionsHistory * Fix default values and object modifications for domain and permissionsHistory related data * Fix connecting to new accounts from modal * Replace retweet.svg with connect-white.svg * Fix signature-request.spec * Update metamask-inpage-provider version * Fix permissions e2e tests * Remove unneeded delay from test/e2e/signature-request.spec.js * Add delay before attempting to retrieve network id in dapp in ethereum-on=.spec * Use requestAccountTabIds strategy for determining tab id that opened a given window * Improve default values for permissions requests * Add some message descriptions to app/_locales/en/messages.json * Code clean up in permission controller * Stopped deep cloning object in mapObjectValues * Bump metamask-inpage-provider version * Add missing description in app/_locales/en/messages.json * Return promises from queryTabs and switchToTab of extension.js * Remove unused getAllPermissions function * Use default props in icon-with-fallback.component.js * Stop passing to permissions controller * Delete no longer used clear-approved-origins modal code * Remove duplicate imports in ui/app/components/app/index.scss * Use URL instead of regex in getOriginFromUrl() * Add runtime error checking to platform, promise based extension.tab methods * Support permission requests from external extensions * Improve font size and colour of the domain origin on the permission confirmation screen * Add support for toggling permissions * Ensure getRenderablePermissionsDomains only returns domains with exposedAccount caveat permissions * Remove unused code from LoginPerSite-ui branch * Ensure modal closes on Enter press for new-account-modal.component.js * Lint fix * fixup! Login Per Site UI (#7368) * Some code cleanup for LoginPerSite * Adds UX for connecting to dapps via the connected sites screen (#7593) * Adds UX for connecting to dapps via the connected sites screen * Use openMetaMaskTabIds from background.js to determine if current active tab is MetaMask * Delete unused permissions controller methods * Fixes two small bugs in the LoginPerSite ui (#7595) * Restore `providerRequest` message translations (#7600) This message was removed, but it was replaced with a very similar message called `likeToConnect`. The only difference is that the new message has "MetaMask" in it. Preserving these messages without "MetaMask" is probably better than deleting them, so these messages have all been restored and renamed to `likeToConnect`. * Login per site no sitemetadata fix (#7610) * Support connected sites for which we have no site metadata. * Change property containing subtitle info often populated by origin to a more accurate of purpose name * Lint fix * Improve disconnection modal messages (#7612) * Improve disconnectAccountModalDescription and disconnectAllModalDescription messages * Update disconnectAccountModalDescription app/_locales/en/messages.json Co-Authored-By: Mark Stacey <markjstacey@gmail.com> * Improve disconnectAccount modal message clarity * Adds cancel button to the account selection screen of the permissions request flow (#7613) * Fix eth_accounts permission language & selectability (#7614) * fix eth_accounts language & selectability * fix MetaMask capitalization in all messages * Close sidebar when opening connected sites (#7611) The 'Connected Sites' button in the accounts details now closes the sidebar, if it is open. This was accomplished by pulling the click handler for that button up to the wallet view component, where another button already followed a similar pattern of closing the sidebar. It seemed confusing to me that one handler was in the `AccountsDetails` container component, and one was handed down from above, so I added PropTypes to the container component. I'm not sure that the WalletView component is the best place for this logic, but I've put it there for now to be consistent with the add token button. * Reject permissions request upon tab close (#7618) Permissions requests are now rejected when the page is closed. This only applies to the full-screen view, as that is the view permission requests should be handled in. The case where the user deals with the request through a different view is handled in #7617 * Handle tab update failure (#7619) `extension.tabs.update` can sometimes fail if the user interacts with the tabs directly around the same time. The redirect flow has been updated to ensure that the permissions tab is still closed in that case. The user is on their own to find the dapp tab again in that case. * Login per site tab popup fixes (#7617) * Handle redirect in response to state update in permissions-connect * Ensure origin is available to permissions-connect subcomponents during redirect * Hide app bar whenever on redirect route * Improvements to handling of redirects in permissions-connect * Ensure permission request id change handling only happens when page is not null * Lint fix * Decouple confirm transaction screen from the selected address (#7622) * Avoid race condtion that could prevent contextual account switching (#7623) There was a race condition in the logic responsible for switching the selected account based upon the active tab. It was asynchronously querying the active tab, then assuming it had been retrieved later. The active tab info itself was already in the redux store in another spot, one that is guaranteed to be set before the UI renders. The race condition was avoided by deleting the duplicate state, and using the other active tab state. * Only redirect back to dapp if current tab is active (#7621) The "redirect back to dapp" behaviour can be disruptive when the permissions connect tab is not active. The purpose of the redirect was to maintain context between the dapp and the permissions request, but if the user has already moved to another tab, that no longer applies. * Fix JSX style lint errors * Remove unused state
496 lines
20 KiB
JavaScript
496 lines
20 KiB
JavaScript
/**
|
|
* @file The entry point for the web extension singleton process.
|
|
*/
|
|
|
|
|
|
// these need to run before anything else
|
|
require('./lib/freezeGlobals')
|
|
require('./lib/setupFetchDebugging')()
|
|
|
|
// polyfills
|
|
import 'abortcontroller-polyfill/dist/polyfill-patch-fetch'
|
|
|
|
const endOfStream = require('end-of-stream')
|
|
const pump = require('pump')
|
|
const debounce = require('debounce-stream')
|
|
const log = require('loglevel')
|
|
const extension = require('extensionizer')
|
|
const LocalStore = require('./lib/local-store')
|
|
const storeTransform = require('obs-store/lib/transform')
|
|
const asStream = require('obs-store/lib/asStream')
|
|
const ExtensionPlatform = require('./platforms/extension')
|
|
const Migrator = require('./lib/migrator/')
|
|
const migrations = require('./migrations/')
|
|
const PortStream = require('extension-port-stream')
|
|
const createStreamSink = require('./lib/createStreamSink')
|
|
const NotificationManager = require('./lib/notification-manager.js')
|
|
const MetamaskController = require('./metamask-controller')
|
|
const rawFirstTimeState = require('./first-time-state')
|
|
const setupSentry = require('./lib/setupSentry')
|
|
const reportFailedTxToSentry = require('./lib/reportFailedTxToSentry')
|
|
const setupMetamaskMeshMetrics = require('./lib/setupMetamaskMeshMetrics')
|
|
const EdgeEncryptor = require('./edge-encryptor')
|
|
const getFirstPreferredLangCode = require('./lib/get-first-preferred-lang-code')
|
|
const getObjStructure = require('./lib/getObjStructure')
|
|
const setupEnsIpfsResolver = require('./lib/ens-ipfs/setup')
|
|
|
|
const {
|
|
ENVIRONMENT_TYPE_POPUP,
|
|
ENVIRONMENT_TYPE_NOTIFICATION,
|
|
ENVIRONMENT_TYPE_FULLSCREEN,
|
|
} = require('./lib/enums')
|
|
|
|
// METAMASK_TEST_CONFIG is used in e2e tests to set the default network to localhost
|
|
const firstTimeState = Object.assign({}, rawFirstTimeState, global.METAMASK_TEST_CONFIG)
|
|
|
|
const METAMASK_DEBUG = process.env.METAMASK_DEBUG
|
|
|
|
log.setDefaultLevel(process.env.METAMASK_DEBUG ? 'debug' : 'warn')
|
|
|
|
const platform = new ExtensionPlatform()
|
|
const notificationManager = new NotificationManager()
|
|
global.METAMASK_NOTIFIER = notificationManager
|
|
|
|
// setup sentry error reporting
|
|
const release = platform.getVersion()
|
|
const sentry = setupSentry({ release })
|
|
|
|
// browser check if it is Edge - https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
|
// Internet Explorer 6-11
|
|
const isIE = !!document.documentMode
|
|
// Edge 20+
|
|
const isEdge = !isIE && !!window.StyleMedia
|
|
|
|
let popupIsOpen = false
|
|
let notificationIsOpen = false
|
|
const openMetamaskTabsIDs = {}
|
|
const requestAccountTabIds = {}
|
|
|
|
// state persistence
|
|
const localStore = new LocalStore()
|
|
let versionedData
|
|
|
|
// initialization flow
|
|
initialize().catch(log.error)
|
|
|
|
// setup metamask mesh testing container
|
|
const { submitMeshMetricsEntry } = setupMetamaskMeshMetrics()
|
|
|
|
/**
|
|
* An object representing a transaction, in whatever state it is in.
|
|
* @typedef TransactionMeta
|
|
*
|
|
* @property {number} id - An internally unique tx identifier.
|
|
* @property {number} time - Time the tx was first suggested, in unix epoch time (ms).
|
|
* @property {string} status - The current transaction status (unapproved, signed, submitted, dropped, failed, rejected), as defined in `tx-state-manager.js`.
|
|
* @property {string} metamaskNetworkId - The transaction's network ID, used for EIP-155 compliance.
|
|
* @property {boolean} loadingDefaults - TODO: Document
|
|
* @property {Object} txParams - The tx params as passed to the network provider.
|
|
* @property {Object[]} history - A history of mutations to this TransactionMeta object.
|
|
* @property {boolean} gasPriceSpecified - True if the suggesting dapp specified a gas price, prevents auto-estimation.
|
|
* @property {boolean} gasLimitSpecified - True if the suggesting dapp specified a gas limit, prevents auto-estimation.
|
|
* @property {string} estimatedGas - A hex string represented the estimated gas limit required to complete the transaction.
|
|
* @property {string} origin - A string representing the interface that suggested the transaction.
|
|
* @property {Object} nonceDetails - A metadata object containing information used to derive the suggested nonce, useful for debugging nonce issues.
|
|
* @property {string} rawTx - A hex string of the final signed transaction, ready to submit to the network.
|
|
* @property {string} hash - A hex string of the transaction hash, used to identify the transaction on the network.
|
|
* @property {number} submittedTime - The time the transaction was submitted to the network, in Unix epoch time (ms).
|
|
*/
|
|
|
|
/**
|
|
* The data emitted from the MetaMaskController.store EventEmitter, also used to initialize the MetaMaskController. Available in UI on React state as state.metamask.
|
|
* @typedef MetaMaskState
|
|
* @property {boolean} isInitialized - Whether the first vault has been created.
|
|
* @property {boolean} isUnlocked - Whether the vault is currently decrypted and accounts are available for selection.
|
|
* @property {boolean} isAccountMenuOpen - Represents whether the main account selection UI is currently displayed.
|
|
* @property {boolean} isPopup - Returns true if the current view is an externally-triggered notification.
|
|
* @property {string} rpcTarget - DEPRECATED - The URL of the current RPC provider.
|
|
* @property {Object} identities - An object matching lower-case hex addresses to Identity objects with "address" and "name" (nickname) keys.
|
|
* @property {Object} unapprovedTxs - An object mapping transaction hashes to unapproved transactions.
|
|
* @property {Array} frequentRpcList - A list of frequently used RPCs, including custom user-provided ones.
|
|
* @property {Array} addressBook - A list of previously sent to addresses.
|
|
* @property {address} selectedTokenAddress - Used to indicate if a token is globally selected. Should be deprecated in favor of UI-centric token selection.
|
|
* @property {Object} tokenExchangeRates - Info about current token prices.
|
|
* @property {Array} tokens - Tokens held by the current user, including their balances.
|
|
* @property {Object} send - TODO: Document
|
|
* @property {Object} coinOptions - TODO: Document
|
|
* @property {boolean} useBlockie - Indicates preferred user identicon format. True for blockie, false for Jazzicon.
|
|
* @property {Object} featureFlags - An object for optional feature flags.
|
|
* @property {string} networkEndpointType - TODO: Document
|
|
* @property {boolean} welcomeScreen - True if welcome screen should be shown.
|
|
* @property {string} currentLocale - A locale string matching the user's preferred display language.
|
|
* @property {Object} provider - The current selected network provider.
|
|
* @property {string} provider.rpcTarget - The address for the RPC API, if using an RPC API.
|
|
* @property {string} provider.type - An identifier for the type of network selected, allows MetaMask to use custom provider strategies for known networks.
|
|
* @property {string} network - A stringified number of the current network ID.
|
|
* @property {Object} accounts - An object mapping lower-case hex addresses to objects with "balance" and "address" keys, both storing hex string values.
|
|
* @property {hex} currentBlockGasLimit - The most recently seen block gas limit, in a lower case hex prefixed string.
|
|
* @property {TransactionMeta[]} selectedAddressTxList - An array of transactions associated with the currently selected account.
|
|
* @property {Object} unapprovedMsgs - An object of messages associated with the currently selected account, mapping a unique ID to the options.
|
|
* @property {number} unapprovedMsgCount - The number of messages in unapprovedMsgs.
|
|
* @property {Object} unapprovedPersonalMsgs - An object of messages associated with the currently selected account, mapping a unique ID to the options.
|
|
* @property {number} unapprovedPersonalMsgCount - The number of messages in unapprovedPersonalMsgs.
|
|
* @property {Object} unapprovedTypedMsgs - An object of messages associated with the currently selected account, mapping a unique ID to the options.
|
|
* @property {number} unapprovedTypedMsgCount - The number of messages in unapprovedTypedMsgs.
|
|
* @property {string[]} keyringTypes - An array of unique keyring identifying strings, representing available strategies for creating accounts.
|
|
* @property {Keyring[]} keyrings - An array of keyring descriptions, summarizing the accounts that are available for use, and what keyrings they belong to.
|
|
* @property {string} currentAccountTab - A view identifying string for displaying the current displayed view, allows user to have a preferred tab in the old UI (between tokens and history).
|
|
* @property {string} selectedAddress - A lower case hex string of the currently selected address.
|
|
* @property {string} currentCurrency - A string identifying the user's preferred display currency, for use in showing conversion rates.
|
|
* @property {number} conversionRate - A number representing the current exchange rate from the user's preferred currency to Ether.
|
|
* @property {number} conversionDate - A unix epoch date (ms) for the time the current conversion rate was last retrieved.
|
|
* @property {Object} infuraNetworkStatus - An object of infura network status checks.
|
|
* @property {Block[]} recentBlocks - An array of recent blocks, used to calculate an effective but cheap gas price.
|
|
* @property {Array} shapeShiftTxList - An array of objects describing shapeshift exchange attempts.
|
|
* @property {boolean} forgottenPassword - Returns true if the user has initiated the password recovery screen, is recovering from seed phrase.
|
|
*/
|
|
|
|
/**
|
|
* @typedef VersionedData
|
|
* @property {MetaMaskState} data - The data emitted from MetaMask controller, or used to initialize it.
|
|
* @property {Number} version - The latest migration version that has been run.
|
|
*/
|
|
|
|
/**
|
|
* Initializes the MetaMask controller, and sets up all platform configuration.
|
|
* @returns {Promise} Setup complete.
|
|
*/
|
|
async function initialize () {
|
|
const initState = await loadStateFromPersistence()
|
|
const initLangCode = await getFirstPreferredLangCode()
|
|
await setupController(initState, initLangCode)
|
|
log.debug('MetaMask initialization complete.')
|
|
}
|
|
|
|
//
|
|
// State and Persistence
|
|
//
|
|
|
|
/**
|
|
* Loads any stored data, prioritizing the latest storage strategy.
|
|
* Migrates that data schema in case it was last loaded on an older version.
|
|
* @returns {Promise<MetaMaskState>} Last data emitted from previous instance of MetaMask.
|
|
*/
|
|
async function loadStateFromPersistence () {
|
|
// migrations
|
|
const migrator = new Migrator({ migrations })
|
|
|
|
// read from disk
|
|
// first from preferred, async API:
|
|
versionedData = (await localStore.get()) ||
|
|
migrator.generateInitialState(firstTimeState)
|
|
|
|
// check if somehow state is empty
|
|
// this should never happen but new error reporting suggests that it has
|
|
// for a small number of users
|
|
// https://github.com/metamask/metamask-extension/issues/3919
|
|
if (versionedData && !versionedData.data) {
|
|
// unable to recover, clear state
|
|
versionedData = migrator.generateInitialState(firstTimeState)
|
|
sentry.captureMessage('MetaMask - Empty vault found - unable to recover')
|
|
}
|
|
|
|
// report migration errors to sentry
|
|
migrator.on('error', (err) => {
|
|
// get vault structure without secrets
|
|
const vaultStructure = getObjStructure(versionedData)
|
|
sentry.captureException(err, {
|
|
// "extra" key is required by Sentry
|
|
extra: { vaultStructure },
|
|
})
|
|
})
|
|
|
|
// migrate data
|
|
versionedData = await migrator.migrateData(versionedData)
|
|
if (!versionedData) {
|
|
throw new Error('MetaMask - migrator returned undefined')
|
|
}
|
|
|
|
// write to disk
|
|
if (localStore.isSupported) {
|
|
localStore.set(versionedData)
|
|
} else {
|
|
// throw in setTimeout so as to not block boot
|
|
setTimeout(() => {
|
|
throw new Error('MetaMask - Localstore not supported')
|
|
})
|
|
}
|
|
|
|
// return just the data
|
|
return versionedData.data
|
|
}
|
|
|
|
/**
|
|
* Initializes the MetaMask Controller with any initial state and default language.
|
|
* Configures platform-specific error reporting strategy.
|
|
* Streams emitted state updates to platform-specific storage strategy.
|
|
* Creates platform listeners for new Dapps/Contexts, and sets up their data connections to the controller.
|
|
*
|
|
* @param {Object} initState - The initial state to start the controller with, matches the state that is emitted from the controller.
|
|
* @param {String} initLangCode - The region code for the language preferred by the current user.
|
|
* @returns {Promise} After setup is complete.
|
|
*/
|
|
function setupController (initState, initLangCode) {
|
|
//
|
|
// MetaMask Controller
|
|
//
|
|
|
|
const controller = new MetamaskController({
|
|
// User confirmation callbacks:
|
|
showUnconfirmedMessage: triggerUi,
|
|
showUnapprovedTx: triggerUi,
|
|
openPopup: openPopup,
|
|
closePopup: notificationManager.closePopup.bind(notificationManager),
|
|
// initial state
|
|
initState,
|
|
// initial locale code
|
|
initLangCode,
|
|
// platform specific api
|
|
platform,
|
|
encryptor: isEdge ? new EdgeEncryptor() : undefined,
|
|
getRequestAccountTabIds: () => {
|
|
return requestAccountTabIds
|
|
},
|
|
getOpenMetamaskTabsIds: () => {
|
|
return openMetamaskTabsIDs
|
|
},
|
|
})
|
|
|
|
const provider = controller.provider
|
|
setupEnsIpfsResolver({ provider })
|
|
|
|
// submit rpc requests to mesh-metrics
|
|
controller.networkController.on('rpc-req', (data) => {
|
|
submitMeshMetricsEntry({ type: 'rpc', data })
|
|
})
|
|
|
|
// report failed transactions to Sentry
|
|
controller.txController.on(`tx:status-update`, (txId, status) => {
|
|
if (status !== 'failed') {
|
|
return
|
|
}
|
|
const txMeta = controller.txController.txStateManager.getTx(txId)
|
|
try {
|
|
reportFailedTxToSentry({ sentry, txMeta })
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
})
|
|
|
|
// setup state persistence
|
|
pump(
|
|
asStream(controller.store),
|
|
debounce(1000),
|
|
storeTransform(versionifyData),
|
|
createStreamSink(persistData),
|
|
(error) => {
|
|
log.error('MetaMask - Persistence pipeline failed', error)
|
|
}
|
|
)
|
|
|
|
/**
|
|
* Assigns the given state to the versioned object (with metadata), and returns that.
|
|
* @param {Object} state - The state object as emitted by the MetaMaskController.
|
|
* @returns {VersionedData} The state object wrapped in an object that includes a metadata key.
|
|
*/
|
|
function versionifyData (state) {
|
|
versionedData.data = state
|
|
return versionedData
|
|
}
|
|
|
|
async function persistData (state) {
|
|
if (!state) {
|
|
throw new Error('MetaMask - updated state is missing', state)
|
|
}
|
|
if (!state.data) {
|
|
throw new Error('MetaMask - updated state does not have data', state)
|
|
}
|
|
if (localStore.isSupported) {
|
|
try {
|
|
await localStore.set(state)
|
|
} catch (err) {
|
|
// log error so we dont break the pipeline
|
|
log.error('error setting state in local store:', err)
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// connect to other contexts
|
|
//
|
|
extension.runtime.onConnect.addListener(connectRemote)
|
|
extension.runtime.onConnectExternal.addListener(connectExternal)
|
|
extension.runtime.onMessage.addListener(controller.onMessage.bind(controller))
|
|
|
|
const metamaskInternalProcessHash = {
|
|
[ENVIRONMENT_TYPE_POPUP]: true,
|
|
[ENVIRONMENT_TYPE_NOTIFICATION]: true,
|
|
[ENVIRONMENT_TYPE_FULLSCREEN]: true,
|
|
}
|
|
|
|
const metamaskBlacklistedPorts = [
|
|
'trezor-connect',
|
|
]
|
|
|
|
const isClientOpenStatus = () => {
|
|
return popupIsOpen || Boolean(Object.keys(openMetamaskTabsIDs).length) || notificationIsOpen
|
|
}
|
|
|
|
/**
|
|
* A runtime.Port object, as provided by the browser:
|
|
* @see https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/runtime/Port
|
|
* @typedef Port
|
|
* @type Object
|
|
*/
|
|
|
|
/**
|
|
* Connects a Port to the MetaMask controller via a multiplexed duplex stream.
|
|
* This method identifies trusted (MetaMask) interfaces, and connects them differently from untrusted (web pages).
|
|
* @param {Port} remotePort - The port provided by a new context.
|
|
*/
|
|
function connectRemote (remotePort) {
|
|
const processName = remotePort.name
|
|
const isMetaMaskInternalProcess = metamaskInternalProcessHash[processName]
|
|
|
|
if (metamaskBlacklistedPorts.includes(remotePort.name)) {
|
|
return false
|
|
}
|
|
|
|
if (isMetaMaskInternalProcess) {
|
|
const portStream = new PortStream(remotePort)
|
|
// communication with popup
|
|
controller.isClientOpen = true
|
|
// construct fake URL for identifying internal messages
|
|
const metamaskUrl = new URL(window.location)
|
|
metamaskUrl.hostname = 'metamask'
|
|
controller.setupTrustedCommunication(portStream, metamaskUrl)
|
|
|
|
if (processName === ENVIRONMENT_TYPE_POPUP) {
|
|
popupIsOpen = true
|
|
|
|
endOfStream(portStream, () => {
|
|
popupIsOpen = false
|
|
controller.isClientOpen = isClientOpenStatus()
|
|
})
|
|
}
|
|
|
|
if (processName === ENVIRONMENT_TYPE_NOTIFICATION) {
|
|
notificationIsOpen = true
|
|
|
|
endOfStream(portStream, () => {
|
|
notificationIsOpen = false
|
|
controller.isClientOpen = isClientOpenStatus()
|
|
})
|
|
}
|
|
|
|
if (processName === ENVIRONMENT_TYPE_FULLSCREEN) {
|
|
const tabId = remotePort.sender.tab.id
|
|
openMetamaskTabsIDs[tabId] = true
|
|
|
|
endOfStream(portStream, () => {
|
|
delete openMetamaskTabsIDs[tabId]
|
|
controller.isClientOpen = isClientOpenStatus()
|
|
})
|
|
}
|
|
} else {
|
|
if (remotePort.sender && remotePort.sender.tab && remotePort.sender.url) {
|
|
const tabId = remotePort.sender.tab.id
|
|
const url = new URL(remotePort.sender.url)
|
|
const origin = url.hostname
|
|
|
|
remotePort.onMessage.addListener(msg => {
|
|
if (msg.data && msg.data.method === 'eth_requestAccounts') {
|
|
requestAccountTabIds[origin] = tabId
|
|
}
|
|
})
|
|
}
|
|
connectExternal(remotePort)
|
|
}
|
|
}
|
|
|
|
// communication with page or other extension
|
|
function connectExternal (remotePort) {
|
|
const senderUrl = new URL(remotePort.sender.url)
|
|
let extensionId
|
|
if (remotePort.sender.id !== extension.runtime.id) {
|
|
extensionId = remotePort.sender.id
|
|
}
|
|
const portStream = new PortStream(remotePort)
|
|
controller.setupUntrustedCommunication(portStream, senderUrl, extensionId)
|
|
}
|
|
|
|
//
|
|
// User Interface setup
|
|
//
|
|
|
|
updateBadge()
|
|
controller.txController.on('update:badge', updateBadge)
|
|
controller.messageManager.on('updateBadge', updateBadge)
|
|
controller.personalMessageManager.on('updateBadge', updateBadge)
|
|
controller.typedMessageManager.on('updateBadge', updateBadge)
|
|
controller.permissionsController.permissions.subscribe(updateBadge)
|
|
|
|
/**
|
|
* Updates the Web Extension's "badge" number, on the little fox in the toolbar.
|
|
* The number reflects the current number of pending transactions or message signatures needing user approval.
|
|
*/
|
|
function updateBadge () {
|
|
let label = ''
|
|
const unapprovedTxCount = controller.txController.getUnapprovedTxCount()
|
|
const unapprovedMsgCount = controller.messageManager.unapprovedMsgCount
|
|
const unapprovedPersonalMsgs = controller.personalMessageManager.unapprovedPersonalMsgCount
|
|
const unapprovedTypedMsgs = controller.typedMessageManager.unapprovedTypedMessagesCount
|
|
const pendingPermissionRequests = Object.keys(controller.permissionsController.permissions.state.permissionsRequests).length
|
|
const count = unapprovedTxCount + unapprovedMsgCount + unapprovedPersonalMsgs + unapprovedTypedMsgs + pendingPermissionRequests
|
|
if (count) {
|
|
label = String(count)
|
|
}
|
|
extension.browserAction.setBadgeText({ text: label })
|
|
extension.browserAction.setBadgeBackgroundColor({ color: '#037DD6' })
|
|
}
|
|
|
|
return Promise.resolve()
|
|
}
|
|
|
|
//
|
|
// Etc...
|
|
//
|
|
|
|
/**
|
|
* Opens the browser popup for user confirmation
|
|
*/
|
|
function triggerUi () {
|
|
extension.tabs.query({ active: true }, tabs => {
|
|
const currentlyActiveMetamaskTab = Boolean(tabs.find(tab => openMetamaskTabsIDs[tab.id]))
|
|
if (!popupIsOpen && !currentlyActiveMetamaskTab && !notificationIsOpen) {
|
|
notificationManager.showPopup()
|
|
notificationIsOpen = true
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Opens the browser popup for user confirmation of watchAsset
|
|
* then it waits until user interact with the UI
|
|
*/
|
|
function openPopup () {
|
|
triggerUi()
|
|
return new Promise(
|
|
(resolve) => {
|
|
const interval = setInterval(() => {
|
|
if (!notificationIsOpen) {
|
|
clearInterval(interval)
|
|
resolve()
|
|
}
|
|
}, 1000)
|
|
}
|
|
)
|
|
}
|
|
|
|
// On first install, open a new tab with MetaMask
|
|
extension.runtime.onInstalled.addListener(({reason}) => {
|
|
if ((reason === 'install') && (!METAMASK_DEBUG)) {
|
|
platform.openExtensionInBrowser()
|
|
}
|
|
})
|