import { forOwn } from 'lodash' import { CAVEAT_NAMES } from '../../../shared/constants/permissions' import { getMetaMaskAccountsOrdered, getOriginOfCurrentTab, getSelectedAddress, } from '.' // selectors /** * Get the permission domains object. * * @param {Object} state - The current state. * @returns {Object} The permissions domains object. */ export function getPermissionDomains(state) { return state.metamask.domains || {} } /** * Get the permission domains metadata object. * * @param {Object} state - The current state. * @returns {Object} The permission domains metadata object. */ export function getPermissionDomainsMetadata(state) { return state.metamask.domainMetadata || {} } /** * Selects the permitted accounts from the eth_accounts permission given state * and an origin. * * @param {Object} state - The current state. * @param {string} origin - The origin/domain to get the permitted accounts for. * @returns {Array} An empty array or an array of accounts. */ export function getPermittedAccounts(state, origin) { return getAccountsFromPermission( getAccountsPermissionFromDomain(domainSelector(state, origin)), ) } /** * Selects the permitted accounts from the eth_accounts permission for the * origin of the current tab. * * @param {Object} state - The current state. * @returns {Array} An empty array or an array of accounts. */ export function getPermittedAccountsForCurrentTab(state) { return getPermittedAccounts(state, getOriginOfCurrentTab(state)) } /** * Returns a map of permitted accounts by origin for all origins. * * @param {Object} state - The current state. * @returns {Object} Permitted accounts by origin. */ export function getPermittedAccountsByOrigin(state) { const domains = getPermissionDomains(state) return Object.keys(domains).reduce((acc, domainKey) => { const accounts = getAccountsFromPermission( getAccountsPermissionFromDomain(domains[domainKey]), ) if (accounts.length > 0) { acc[domainKey] = accounts } return acc }, {}) } /** * Returns an array of connected domain objects, with the following properties: * - extensionId * - key (i.e. origin) * - name * - icon * * @param {Object} state - The current state. * @returns {Array} An array of connected domain objects. */ export function getConnectedDomainsForSelectedAddress(state) { const { selectedAddress } = state.metamask const domains = getPermissionDomains(state) const domainMetadata = getPermissionDomainsMetadata(state) const connectedDomains = [] forOwn(domains, (domainValue, domainKey) => { const exposedAccounts = getAccountsFromDomain(domainValue) if (!exposedAccounts.includes(selectedAddress)) { return } const { extensionId, name, icon, host } = domainMetadata[domainKey] || {} connectedDomains.push({ extensionId, origin: domainKey, name, icon, host, }) }) return connectedDomains } /** * Returns an object mapping addresses to objects mapping origins to connected * domain info. Domain info objects have the following properties: * - icon * - name * * @param {Object} state - The current state. * @returns {Object} A mapping of addresses to a mapping of origins to * connected domain info. */ export function getAddressConnectedDomainMap(state) { const domainMetadata = getPermissionDomainsMetadata(state) const accountsMap = getPermittedAccountsByOrigin(state) const addressConnectedIconMap = {} Object.keys(accountsMap).forEach((domainKey) => { const { icon, name } = domainMetadata[domainKey] || {} accountsMap[domainKey].forEach((address) => { const nameToRender = name || domainKey addressConnectedIconMap[address] = addressConnectedIconMap[address] ? { ...addressConnectedIconMap[address], [domainKey]: { icon, name: nameToRender }, } : { [domainKey]: { icon, name: nameToRender } } }) }) return addressConnectedIconMap } // selector helpers function getAccountsFromDomain(domain) { return getAccountsFromPermission(getAccountsPermissionFromDomain(domain)) } function getAccountsPermissionFromDomain(domain = {}) { return Array.isArray(domain.permissions) ? domain.permissions.find( (perm) => perm.parentCapability === 'eth_accounts', ) : {} } function getAccountsFromPermission(accountsPermission) { const accountsCaveat = getAccountsCaveatFromPermission(accountsPermission) return accountsCaveat && Array.isArray(accountsCaveat.value) ? accountsCaveat.value : [] } function getAccountsCaveatFromPermission(accountsPermission = {}) { return ( Array.isArray(accountsPermission.caveats) && accountsPermission.caveats.find( (c) => c.name === CAVEAT_NAMES.exposedAccounts, ) ) } function domainSelector(state, origin) { return origin && state.metamask.domains?.[origin] } export function getAccountToConnectToActiveTab(state) { const selectedAddress = getSelectedAddress(state) const connectedAccounts = getPermittedAccountsForCurrentTab(state) const { metamask: { identities }, } = state const numberOfAccounts = Object.keys(identities).length if ( connectedAccounts.length && connectedAccounts.length !== numberOfAccounts ) { if ( connectedAccounts.findIndex((address) => address === selectedAddress) === -1 ) { return identities[selectedAddress] } } return undefined } export function getOrderedConnectedAccountsForActiveTab(state) { const { activeTab, metamask: { permissionsHistory }, } = state const permissionsHistoryByAccount = // eslint-disable-next-line camelcase permissionsHistory[activeTab.origin]?.eth_accounts?.accounts const orderedAccounts = getMetaMaskAccountsOrdered(state) const connectedAccounts = getPermittedAccountsForCurrentTab(state) return orderedAccounts .filter((account) => connectedAccounts.includes(account.address)) .map((account) => ({ ...account, lastActive: permissionsHistoryByAccount?.[account.address], })) .sort( ({ lastSelected: lastSelectedA }, { lastSelected: lastSelectedB }) => { if (lastSelectedA === lastSelectedB) { return 0 } else if (lastSelectedA === undefined) { return 1 } else if (lastSelectedB === undefined) { return -1 } return lastSelectedB - lastSelectedA }, ) } export function getPermissionsForActiveTab(state) { const { activeTab, metamask } = state const { domains = {} } = metamask return domains[activeTab.origin]?.permissions?.map(({ parentCapability }) => { return { key: parentCapability, } }) } export function activeTabHasPermissions(state) { const { activeTab, metamask } = state const { domains = {} } = metamask return Boolean(domains[activeTab.origin]?.permissions?.length > 0) } export function getLastConnectedInfo(state) { const { permissionsHistory = {} } = state.metamask return Object.keys(permissionsHistory).reduce((acc, origin) => { const ethAccountsHistory = JSON.parse( JSON.stringify(permissionsHistory[origin].eth_accounts), ) return { ...acc, [origin]: ethAccountsHistory, } }, {}) } export function getPermissionsMetadataHostCounts(state) { const metadata = getPermissionDomainsMetadata(state) return Object.values(metadata).reduce((counts, { host }) => { if (host) { if (counts[host]) { counts[host] += 1 } else { counts[host] = 1 } } return counts }, {}) } export function getPermissionsRequests(state) { return state.metamask.permissionsRequests || [] } export function getPermissionsRequestCount(state) { const permissionsRequests = getPermissionsRequests(state) return permissionsRequests.length } export function getFirstPermissionRequest(state) { const requests = getPermissionsRequests(state) return requests && requests[0] ? requests[0] : null }