import punycode from 'punycode/punycode'; import abi from 'human-standard-token-abi'; import BigNumber from 'bignumber.js'; import * as ethUtil from 'ethereumjs-util'; import { DateTime } from 'luxon'; import { util } from '@metamask/controllers'; import slip44 from '@metamask/slip44'; 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'; import { toChecksumHexAddress } from '../../../shared/modules/hexstring-utils'; import { TRUNCATED_ADDRESS_START_CHARS, TRUNCATED_NAME_CHAR_LIMIT, TRUNCATED_ADDRESS_END_CHARS, } from '../../../shared/constants/labels'; import { toBigNumber } from '../../../shared/modules/conversion.utils'; // formatData :: ( date: ) -> String export function formatDate(date, format = "M/d/y 'at' T") { if (!date) { return ''; } return DateTime.fromMillis(date).toFormat(format); } export function formatDateWithYearContext( date, formatThisYear = 'MMM d', fallback = 'MMM d, y', ) { if (!date) { return ''; } const dateTime = DateTime.fromMillis(date); const now = DateTime.local(); 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) { 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 ) { return true; } return false; } export function valuesFor(obj) { if (!obj) { return []; } return Object.keys(obj).map(function (key) { return obj[key]; }); } export function addressSummary( address, firstSegLength = 10, lastSegLength = 4, includeHex = true, ) { if (!address) { return ''; } let checked = toChecksumHexAddress(address); if (!includeHex) { checked = ethUtil.stripHexPrefix(checked); } return checked ? `${checked.slice(0, firstSegLength)}...${checked.slice( checked.length - lastSegLength, )}` : '...'; } 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) .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 export function numericBalance(balance) { if (!balance) { return new ethUtil.BN(0, 16); } const stripped = ethUtil.stripHexPrefix(balance); return new ethUtil.BN(stripped, 16); } // Takes hex, returns [beforeDecimal, afterDecimal] export function parseBalance(balance) { let afterDecimal; const wei = numericBalance(balance); const weiString = wei.toString(); const trailingZeros = /0+$/u; const beforeDecimal = weiString.length > 18 ? weiString.slice(0, weiString.length - 18) : '0'; afterDecimal = `000000000000000000${wei}` .slice(-18) .replace(trailingZeros, ''); if (afterDecimal === '') { afterDecimal = '0'; } return [beforeDecimal, afterDecimal]; } // Takes wei hex, returns an object with three properties. // Its "formatted" property is what we generally use to render values. 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'; 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}`; } } else { formatted = `${beforeDecimal}.${afterDecimal.slice(0, 3)} ${ticker}`; } } else { afterDecimal += Array(decimalsToKeep).join('0'); formatted = `${beforeDecimal}.${afterDecimal.slice( 0, decimalsToKeep, )} ${ticker}`; } return formatted; } export function getContractAtAddress(tokenAddress) { return global.eth.contract(abi).at(tokenAddress); } 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; } export function exportAsFile(filename, data, type = 'text/csv') { // eslint-disable-next-line no-param-reassign filename = filename || getRandomFileName(); // source: https://stackoverflow.com/a/33542499 by Ludovic Feltz const blob = new window.Blob([data], { type }); if (window.navigator.msSaveOrOpenBlob) { window.navigator.msSaveBlob(blob, filename); } 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); } } /** * 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. */ 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, )}`; } 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. */ export function stripHttpSchemes(urlString) { return urlString.replace(/^https?:\/\//u, ''); } /** * 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, ''); } /** * 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. */ 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 */ 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 */ export function toPrecisionWithoutTrailingZeros(n, precision) { return new BigNumber(n) .toPrecision(precision) .replace(/(\.[0-9]*[1-9])0*|(\.0*)/u, '$1'); } /** * Given and object where all values are strings, returns the same object with all values * now prefixed with '0x' * * @param obj */ export function addHexPrefixToObjectValues(obj) { return Object.keys(obj).reduce((newObj, key) => { return { ...newObj, [key]: addHexPrefix(obj[key]) }; }, {}); } /** * Given the standard set of information about a transaction, returns a transaction properly formatted for * publishing via JSON RPC and web3 * * @param {object} options * @param {boolean} [options.sendToken] - Indicates whether or not the transaciton is a token transaction * @param {string} options.data - A hex string containing the data to include in the transaction * @param {string} options.to - A hex address of the tx recipient address * @param options.amount * @param {string} options.from - A hex address of the tx sender address * @param {string} options.gas - A hex representation of the gas value for the transaction * @param {string} options.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 */ export function constructTxParams({ sendToken, data, to, amount, from, gas, gasPrice, }) { const txParams = { data, from, value: '0', gas, gasPrice, }; if (!sendToken) { txParams.value = amount; txParams.to = to; } return addHexPrefixToObjectValues(txParams); } 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(''); } 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; } export function roundToDecimalPlacesRemovingExtraZeroes( numberish, numberOfDecimalPlaces, ) { if (numberish === undefined || numberish === null) { return ''; } return toBigNumber .dec(toBigNumber.dec(numberish).toFixed(numberOfDecimalPlaces)) .toNumber(); } /** * Gets the name of the SLIP-44 protocol corresponding to the specified * `coin_type`. * * @param {string | number} coinType - The SLIP-44 `coin_type` value whose name * to retrieve. * @returns {string | undefined} The name of the protocol if found. */ export function coinTypeToProtocolName(coinType) { if (String(coinType) === '1') { return 'Test Networks'; } return slip44[coinType]?.name || undefined; } /** * Tests "nullishness". Used to guard a section of a component from being * rendered based on a value. * * @param {any} value - A value (literally anything). * @returns `true` if the value is null or undefined, `false` otherwise. */ export function isNullish(value) { return value === null || value === undefined; }