1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-23 09:52:26 +01:00
metamask-extension/ui/helpers/utils/util.js

561 lines
16 KiB
JavaScript
Raw Normal View History

import punycode from 'punycode/punycode';
import abi from 'human-standard-token-abi';
import BigNumber from 'bignumber.js';
2021-04-16 17:05:13 +02:00
import * as ethUtil from 'ethereumjs-util';
import { DateTime } from 'luxon';
import { util } from '@metamask/controllers';
import { addHexPrefix } from '../../../app/scripts/lib/util';
import {
GOERLI_CHAIN_ID,
KOVAN_CHAIN_ID,
LOCALHOST_CHAIN_ID,
MAINNET_CHAIN_ID,
RINKEBY_CHAIN_ID,
ROPSTEN_CHAIN_ID,
} from '../../../shared/constants/network';
2021-05-17 23:19:39 +02:00
import { toChecksumHexAddress } from '../../../shared/modules/hexstring-utils';
import {
TRUNCATED_ADDRESS_START_CHARS,
TRUNCATED_NAME_CHAR_LIMIT,
TRUNCATED_ADDRESS_END_CHARS,
} from '../../../shared/constants/labels';
// formatData :: ( date: <Unix Timestamp> ) -> String
2020-11-03 00:41:28 +01:00
export function formatDate(date, format = "M/d/y 'at' T") {
if (!date) {
return '';
}
return DateTime.fromMillis(date).toFormat(format);
}
2020-11-03 00:41:28 +01:00
export function formatDateWithYearContext(
date,
formatThisYear = 'MMM d',
fallback = 'MMM d, y',
) {
if (!date) {
return '';
}
const dateTime = DateTime.fromMillis(date);
const now = DateTime.local();
2020-11-03 00:41:28 +01:00
return dateTime.toFormat(
now.year === dateTime.year ? formatThisYear : fallback,
);
}
/**
* Determines if the provided chainId is a default MetaMask chain
* @param {string} chainId - chainId to check
*/
export function isDefaultMetaMaskChain(chainId) {
2020-11-03 00:41:28 +01:00
if (
!chainId ||
chainId === MAINNET_CHAIN_ID ||
chainId === ROPSTEN_CHAIN_ID ||
chainId === RINKEBY_CHAIN_ID ||
chainId === KOVAN_CHAIN_ID ||
chainId === GOERLI_CHAIN_ID ||
chainId === LOCALHOST_CHAIN_ID
2020-11-03 00:41:28 +01:00
) {
return true;
}
return false;
}
// Both inputs should be strings. This method is currently used to compare tokenAddress hex strings.
export function isEqualCaseInsensitive(value1, value2) {
if (typeof value1 !== 'string' || typeof value2 !== 'string') return false;
return value1.toLowerCase() === value2.toLowerCase();
}
2020-11-03 00:41:28 +01:00
export function valuesFor(obj) {
if (!obj) {
return [];
}
2020-11-03 00:41:28 +01:00
return Object.keys(obj).map(function (key) {
return obj[key];
});
}
2020-11-03 00:41:28 +01:00
export function addressSummary(
address,
firstSegLength = 10,
lastSegLength = 4,
includeHex = true,
) {
if (!address) {
return '';
}
2021-05-17 23:19:39 +02:00
let checked = toChecksumHexAddress(address);
2016-07-07 02:58:46 +02:00
if (!includeHex) {
checked = ethUtil.stripHexPrefix(checked);
2016-07-07 02:58:46 +02:00
}
2020-11-03 00:41:28 +01:00
return checked
? `${checked.slice(0, firstSegLength)}...${checked.slice(
checked.length - lastSegLength,
)}`
: '...';
2016-07-07 02:58:46 +02:00
}
2020-11-03 00:41:28 +01:00
export function isValidDomainName(address) {
const match = punycode
.toASCII(address)
.toLowerCase()
// Checks that the domain consists of at least one valid domain pieces separated by periods, followed by a tld
// Each piece of domain name has only the characters a-z, 0-9, and a hyphen (but not at the start or end of chunk)
// A chunk has minimum length of 1, but minimum tld is set to 2 for now (no 1-character tlds exist yet)
2020-11-03 00:41:28 +01:00
.match(
/^(?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)+[a-z0-9][-a-z0-9]*[a-z0-9]$/u,
);
return match !== null;
}
export function isOriginContractAddress(to, sendTokenAddress) {
if (!to || !sendTokenAddress) {
return false;
}
return to.toLowerCase() === sendTokenAddress.toLowerCase();
}
// Takes wei Hex, returns wei BN, even if input is null
2020-11-03 00:41:28 +01:00
export function numericBalance(balance) {
if (!balance) {
return new ethUtil.BN(0, 16);
}
const stripped = ethUtil.stripHexPrefix(balance);
return new ethUtil.BN(stripped, 16);
}
2016-05-18 22:41:08 +02:00
// Takes hex, returns [beforeDecimal, afterDecimal]
2020-11-03 00:41:28 +01:00
export function parseBalance(balance) {
let afterDecimal;
const wei = numericBalance(balance);
const weiString = wei.toString();
const trailingZeros = /0+$/u;
2020-11-03 00:41:28 +01:00
const beforeDecimal =
weiString.length > 18 ? weiString.slice(0, weiString.length - 18) : '0';
2020-11-03 00:41:28 +01:00
afterDecimal = `000000000000000000${wei}`
.slice(-18)
.replace(trailingZeros, '');
if (afterDecimal === '') {
afterDecimal = '0';
}
return [beforeDecimal, afterDecimal];
2016-05-18 22:41:08 +02:00
}
2016-07-07 06:32:36 +02:00
// Takes wei hex, returns an object with three properties.
// Its "formatted" property is what we generally use to render values.
2020-11-03 00:41:28 +01:00
export function formatBalance(
balance,
decimalsToKeep,
needsParse = true,
ticker = 'ETH',
) {
const parsed = needsParse ? parseBalance(balance) : balance.split('.');
const beforeDecimal = parsed[0];
let afterDecimal = parsed[1];
let formatted = 'None';
2016-07-07 20:20:02 +02:00
if (decimalsToKeep === undefined) {
if (beforeDecimal === '0') {
if (afterDecimal !== '0') {
const sigFigs = afterDecimal.match(/^0*(.{2})/u); // default: grabs 2 most significant digits
if (sigFigs) {
afterDecimal = sigFigs[0];
}
formatted = `0.${afterDecimal} ${ticker}`;
2016-07-07 20:20:02 +02:00
}
} else {
formatted = `${beforeDecimal}.${afterDecimal.slice(0, 3)} ${ticker}`;
}
2016-06-21 22:18:32 +02:00
} else {
afterDecimal += Array(decimalsToKeep).join('0');
2020-11-03 00:41:28 +01:00
formatted = `${beforeDecimal}.${afterDecimal.slice(
0,
decimalsToKeep,
)} ${ticker}`;
}
return formatted;
}
2020-11-03 00:41:28 +01:00
export function getContractAtAddress(tokenAddress) {
return global.eth.contract(abi).at(tokenAddress);
}
2017-09-18 20:28:10 +02:00
2020-11-03 00:41:28 +01:00
export function getRandomFileName() {
let fileName = '';
const charBank = [
...'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
];
const fileNameLength = Math.floor(Math.random() * 7 + 6);
for (let i = 0; i < fileNameLength; i++) {
fileName += charBank[Math.floor(Math.random() * charBank.length)];
}
return fileName;
}
2020-11-03 00:41:28 +01:00
export function exportAsFile(filename, data, type = 'text/csv') {
// eslint-disable-next-line no-param-reassign
filename = filename || getRandomFileName();
2017-09-12 01:22:20 +02:00
// source: https://stackoverflow.com/a/33542499 by Ludovic Feltz
const blob = new window.Blob([data], { type });
2017-09-12 01:22:20 +02:00
if (window.navigator.msSaveOrOpenBlob) {
window.navigator.msSaveBlob(blob, filename);
2017-09-12 01:22:20 +02:00
} else {
const elem = window.document.createElement('a');
elem.target = '_blank';
elem.href = window.URL.createObjectURL(blob);
elem.download = filename;
document.body.appendChild(elem);
elem.click();
document.body.removeChild(elem);
2017-09-12 01:22:20 +02:00
}
}
/**
* Shortens an Ethereum address for display, preserving the beginning and end.
* Returns the given address if it is no longer than 10 characters.
* Shortened addresses are 13 characters long.
*
* Example output: 0xabcd...1234
*
* @param {string} address - The address to shorten.
* @returns {string} The shortened address, or the original if it was no longer
* than 10 characters.
*/
2020-11-03 00:41:28 +01:00
export function shortenAddress(address = '') {
if (address.length < TRUNCATED_NAME_CHAR_LIMIT) {
return address;
}
return `${address.slice(0, TRUNCATED_ADDRESS_START_CHARS)}...${address.slice(
-TRUNCATED_ADDRESS_END_CHARS,
)}`;
}
2020-11-03 00:41:28 +01:00
export function getAccountByAddress(accounts = [], targetAddress) {
return accounts.find(({ address }) => address === targetAddress);
}
/**
* Strips the following schemes from URL strings:
* - http
* - https
*
* @param {string} urlString - The URL string to strip the scheme from.
* @returns {string} The URL string, without the scheme, if it was stripped.
*/
2020-11-03 00:41:28 +01:00
export function stripHttpSchemes(urlString) {
return urlString.replace(/^https?:\/\//u, '');
}
2021-02-22 17:20:42 +01:00
/**
* Strips the following schemes from URL strings:
* - https
*
* @param {string} urlString - The URL string to strip the scheme from.
* @returns {string} The URL string, without the scheme, if it was stripped.
*/
export function stripHttpsScheme(urlString) {
return urlString.replace(/^https:\/\//u, '');
}
Permission System 2.0 (#12243) # Permission System 2.0 ## Background This PR migrates the extension permission system to [the new `PermissionController`](https://github.com/MetaMask/snaps-skunkworks/tree/main/packages/controllers/src/permissions). The original permission system, based on [`rpc-cap`](https://github.com/MetaMask/rpc-cap), introduced [`ZCAP-LD`](https://w3c-ccg.github.io/zcap-ld/)-like permissions to our JSON-RPC stack. We used it to [implement](https://github.com/MetaMask/metamask-extension/pull/7004) what we called "LoginPerSite" in [version 7.7.0](https://github.com/MetaMask/metamask-extension/releases/tag/v7.7.0) of the extension, which enabled the user to choose which accounts, if any, should be exposed to each dapp. While that was a worthwhile feature in and of itself, we wanted a permission _system_ in order to enable everything we are going to with Snaps. Unfortunately, the original permission system was difficult to use, and necessitated the creation of the original `PermissionsController` (note the "s"), which was more or less a wrapper for `rpc-cap`. With this PR, we shake off the yoke of the original permission system, in favor of the modular, self-contained, ergonomic, and more mature permission system 2.0. Note that [the `PermissionController` readme](https://github.com/MetaMask/snaps-skunkworks/tree/main/packages/controllers/src/permissions/README.md) explains how the new permission system works. The `PermissionController` and `SubjectMetadataController` are currently shipped via `@metamask/snap-controllers`. This is a temporary state of affairs, and we'll move them to `@metamask/controllers` once they've landed in prod. ## Changes in Detail First, the changes in this PR are not as big as they seem. Roughly half of the additions in this PR are fixtures in the test for the new migration (number 68), and a significant portion of the remaining ~2500 lines are due to find-and-replace changes in other test fixtures and UI files. - The extension `PermissionsController` has been deleted, and completely replaced with the new `PermissionController` from [`@metamask/snap-controllers`](https://www.npmjs.com/package/@metamask/snap-controllers). - The original `PermissionsController` "domain metadata" functionality is now managed by the new `SubjectMetadataController`, also from [`@metamask/snap-controllers`](https://www.npmjs.com/package/@metamask/snap-controllers). - The permission activity and history log controller has been renamed `PermissionLogController` and has its own top-level state key, but is otherwise functionally equivalent to the existing implementation. - Migration number 68 has been added to account for the new state changes. - The tests in `app/scripts/controllers/permissions` have been migrated from `mocha` to `jest`. Reviewers should focus their attention on the following files: - `app/scripts/` - `metamask-controller.js` - This is where most of the integration work for the new `PermissionController` occurs. Some functions that were internal to the original controller were moved here. - `controllers/permissions/` - `selectors.js` - These selectors are for `ControllerMessenger` selector subscriptions. The actual subscriptions occur in `metamask-controller.js`. See the `ControllerMessenger` implementation for details. - `specifications.js` - The caveat and permission specifications are required by the new `PermissionController`, and are used to specify the `eth_accounts` permission and its JSON-RPC method implementation. See the `PermissionController` readme for details. - `migrations/068.js` - The new state should be cross-referenced with the controllers that manage it. The accompanying tests should also be thoroughly reviewed. Some files may appear new but have just moved and/or been renamed: - `app/scripts/lib/rpc-method-middleware/handlers/request-accounts.js` - This was previously implemented in `controllers/permissions/permissionsMethodMiddleware.js`. - `test/mocks/permissions.js` - A truncated version of `test/mocks/permission-controller.js`. Co-authored-by: Mark Stacey <markjstacey@gmail.com>
2021-12-07 04:16:49 +01:00
/**
* Strips `https` schemes from URL strings, if the URL does not have a port.
* This is useful
*
* @param {string} urlString - The URL string to strip the scheme from.
* @returns {string} The URL string, without the scheme, if it was stripped.
*/
export function stripHttpsSchemeWithoutPort(urlString) {
if (getURL(urlString).port) {
return urlString;
}
return stripHttpsScheme(urlString);
}
/**
* Checks whether a URL-like value (object or string) is an extension URL.
*
* @param {string | URL | object} urlLike - The URL-like value to test.
* @returns {boolean} Whether the URL-like value is an extension URL.
*/
2020-11-03 00:41:28 +01:00
export function isExtensionUrl(urlLike) {
const EXT_PROTOCOLS = ['chrome-extension:', 'moz-extension:'];
if (typeof urlLike === 'string') {
for (const protocol of EXT_PROTOCOLS) {
if (urlLike.startsWith(protocol)) {
return true;
}
}
}
if (urlLike?.protocol) {
return EXT_PROTOCOLS.includes(urlLike.protocol);
}
return false;
}
/**
* Checks whether an address is in a passed list of objects with address properties. The check is performed on the
* lowercased version of the addresses.
*
* @param {string} address - The hex address to check
* @param {Array} list - The array of objects to check
* @returns {boolean} Whether or not the address is in the list
*/
2020-11-03 00:41:28 +01:00
export function checkExistingAddresses(address, list = []) {
if (!address) {
return false;
}
const matchesAddress = (obj) => {
return obj.address.toLowerCase() === address.toLowerCase();
};
return list.some(matchesAddress);
}
/**
* Given a number and specified precision, returns that number in base 10 with a maximum of precision
* significant digits, but without any trailing zeros after the decimal point To be used when wishing
* to display only as much digits to the user as necessary
*
* @param {string | number | BigNumber} n - The number to format
* @param {number} precision - The maximum number of significant digits in the return value
* @returns {string} The number in decimal form, with <= precision significant digits and no decimal trailing zeros
*/
2020-11-03 00:41:28 +01:00
export function toPrecisionWithoutTrailingZeros(n, precision) {
return new BigNumber(n)
.toPrecision(precision)
.replace(/(\.[0-9]*[1-9])0*|(\.0*)/u, '$1');
}
2020-10-06 20:28:38 +02:00
/**
2020-11-03 00:41:28 +01:00
* Given and object where all values are strings, returns the same object with all values
* now prefixed with '0x'
*/
export function addHexPrefixToObjectValues(obj) {
2020-10-06 20:28:38 +02:00
return Object.keys(obj).reduce((newObj, key) => {
return { ...newObj, [key]: addHexPrefix(obj[key]) };
}, {});
2020-10-06 20:28:38 +02:00
}
/**
* Given the standard set of information about a transaction, returns a transaction properly formatted for
* publishing via JSON RPC and web3
*
* @param {boolean} [sendToken] - Indicates whether or not the transaciton is a token transaction
2020-10-06 20:28:38 +02:00
* @param {string} data - A hex string containing the data to include in the transaction
* @param {string} to - A hex address of the tx recipient address
* @param {string} from - A hex address of the tx sender address
* @param {string} gas - A hex representation of the gas value for the transaction
* @param {string} gasPrice - A hex representation of the gas price for the transaction
* @returns {Object} An object ready for submission to the blockchain, with all values appropriately hex prefixed
2020-10-06 20:28:38 +02:00
*/
2020-11-03 00:41:28 +01:00
export function constructTxParams({
sendToken,
data,
to,
amount,
from,
gas,
gasPrice,
}) {
2020-10-06 20:28:38 +02:00
const txParams = {
data,
from,
value: '0',
gas,
gasPrice,
};
2020-10-06 20:28:38 +02:00
if (!sendToken) {
txParams.value = amount;
txParams.to = to;
2020-10-06 20:28:38 +02:00
}
return addHexPrefixToObjectValues(txParams);
2020-10-06 20:28:38 +02:00
}
export function bnGreaterThan(a, b) {
if (a === null || a === undefined || b === null || b === undefined) {
return null;
}
return new BigNumber(a, 10).gt(b, 10);
}
export function bnLessThan(a, b) {
if (a === null || a === undefined || b === null || b === undefined) {
return null;
}
return new BigNumber(a, 10).lt(b, 10);
}
export function bnGreaterThanEqualTo(a, b) {
if (a === null || a === undefined || b === null || b === undefined) {
return null;
}
return new BigNumber(a, 10).gte(b, 10);
}
export function bnLessThanEqualTo(a, b) {
if (a === null || a === undefined || b === null || b === undefined) {
return null;
}
return new BigNumber(a, 10).lte(b, 10);
}
export function getURL(url) {
try {
return new URL(url);
} catch (err) {
return '';
}
}
export function getURLHost(url) {
return getURL(url)?.host || '';
}
export function getURLHostName(url) {
return getURL(url)?.hostname || '';
}
// Once we reach this threshold, we switch to higher unit
const MINUTE_CUTOFF = 90 * 60;
const SECOND_CUTOFF = 90;
export const toHumanReadableTime = (t, milliseconds) => {
if (milliseconds === undefined || milliseconds === null) return '';
const seconds = Math.ceil(milliseconds / 1000);
if (seconds <= SECOND_CUTOFF) {
return t('gasTimingSecondsShort', [seconds]);
}
if (seconds <= MINUTE_CUTOFF) {
return t('gasTimingMinutesShort', [Math.ceil(seconds / 60)]);
}
return t('gasTimingHoursShort', [Math.ceil(seconds / 3600)]);
};
export function clearClipboard() {
window.navigator.clipboard.writeText('');
}
"eth_signTypedData" presents fields that do not appear in 'types' filed (#12905) * Premilimary Sanitize data logic. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * sanitizeData v2 Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * sanitizeData: take 3 Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Sanitize Data take 4 Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Lint fixes Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Check that version is v4 before sanitizing. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * sanitize arrays. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Tests to check that typeless data are not shwon Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Lint Fixes Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Do not check value types, Iterate through the message, and ensure each property of the message is declared as a type Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Check that if data type is not defined, it is a solidity type. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Lint Fixes Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Code cleanup Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Move sanitizeData to utils Tests for sanitizeData in utils Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Lint fixes Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Fix unit tests for signaturerequest Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Remove unused type include fixedMxN and ufixedMxN checks. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * move fixtures to before each Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * invert if condition to avoid indentations. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Lint fixes Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * We should exclude types with [] at the beginning or middle as well: Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * cache nestedType Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Throw error for undefined/invalid types definition Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com> * Throw if base type and types are not defined. Signed-off-by: Akintayo A. Olusegun <akintayo.segun@gmail.com>
2021-12-08 21:56:09 +01:00
const solidityTypes = () => {
const types = [
'bool',
'address',
'string',
'bytes',
'int',
'uint',
'fixed',
'ufixed',
];
const ints = Array.from(new Array(32)).map(
(_, index) => `int${(index + 1) * 8}`,
);
const uints = Array.from(new Array(32)).map(
(_, index) => `uint${(index + 1) * 8}`,
);
const bytes = Array.from(new Array(32)).map(
(_, index) => `bytes${index + 1}`,
);
/**
* fixed and ufixed
* This value type also can be declared keywords such as ufixedMxN and fixedMxN.
* The M represents the amount of bits that the type takes,
* with N representing the number of decimal points that are available.
* M has to be divisible by 8, and a number from 8 to 256.
* N has to be a value between 0 and 80, also being inclusive.
*/
const fixedM = Array.from(new Array(32)).map(
(_, index) => `fixed${(index + 1) * 8}`,
);
const ufixedM = Array.from(new Array(32)).map(
(_, index) => `ufixed${(index + 1) * 8}`,
);
const fixed = Array.from(new Array(80)).map((_, index) =>
fixedM.map((aFixedM) => `${aFixedM}x${index + 1}`),
);
const ufixed = Array.from(new Array(80)).map((_, index) =>
ufixedM.map((auFixedM) => `${auFixedM}x${index + 1}`),
);
return [
...types,
...ints,
...uints,
...bytes,
...fixed.flat(),
...ufixed.flat(),
];
};
export const sanitizeMessage = (msg, baseType, types) => {
if (!types) {
throw new Error(`Invalid types definition`);
}
const baseTypeDefinitions = types[baseType];
if (!baseTypeDefinitions) {
throw new Error(`Invalid primary type definition`);
}
const sanitizedMessage = {};
const msgKeys = Object.keys(msg);
msgKeys.forEach((msgKey) => {
const definedType = Object.values(baseTypeDefinitions).find(
(baseTypeDefinition) => baseTypeDefinition.name === msgKey,
);
if (!definedType) {
return;
}
// key has a type. check if the definedType is also a type
const nestedType = definedType.type.replace(/\[\]$/u, '');
const nestedTypeDefinition = types[nestedType];
if (nestedTypeDefinition) {
if (definedType.type.endsWith('[]') > 0) {
// nested array
sanitizedMessage[msgKey] = msg[msgKey].map((value) =>
sanitizeMessage(value, nestedType, types),
);
} else {
// nested object
sanitizedMessage[msgKey] = sanitizeMessage(
msg[msgKey],
definedType.type,
types,
);
}
} else {
// check if it's a valid solidity type
const isSolidityType = solidityTypes().includes(nestedType);
if (isSolidityType) {
sanitizedMessage[msgKey] = msg[msgKey];
}
}
});
return sanitizedMessage;
};
export function getAssetImageURL(image, ipfsGateway) {
if (!image || !ipfsGateway || typeof image !== 'string') {
return '';
}
if (image.startsWith('ipfs://')) {
return util.getFormattedIpfsUrl(ipfsGateway, image, true);
}
return image;
}