1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-23 09:52:26 +01:00
metamask-extension/ui/selectors/permissions.js
2021-04-28 14:53:59 -05:00

289 lines
7.8 KiB
JavaScript

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<string>} 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<string>} 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<Object>} 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 getFirstPermissionRequest(state) {
const requests = getPermissionsRequests(state);
return requests && requests[0] ? requests[0] : null;
}