You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
449 lines
14 KiB
449 lines
14 KiB
import punycode from 'punycode/punycode'
|
|
import abi from 'human-standard-token-abi'
|
|
import BigNumber from 'bignumber.js'
|
|
import ethUtil from 'ethereumjs-util'
|
|
import { DateTime } from 'luxon'
|
|
|
|
// formatData :: ( date: <Unix Timestamp> ) -> String
|
|
export function formatDate (date, format = 'M/d/y \'at\' T') {
|
|
return DateTime.fromMillis(date).toFormat(format)
|
|
}
|
|
|
|
export function formatDateWithYearContext (date, formatThisYear = 'MMM d', fallback = 'MMM d, y') {
|
|
const dateTime = DateTime.fromMillis(date)
|
|
const now = DateTime.local()
|
|
return dateTime.toFormat(now.year === dateTime.year ? formatThisYear : fallback)
|
|
}
|
|
|
|
const valueTable = {
|
|
wei: '1000000000000000000',
|
|
kwei: '1000000000000000',
|
|
mwei: '1000000000000',
|
|
gwei: '1000000000',
|
|
szabo: '1000000',
|
|
finney: '1000',
|
|
ether: '1',
|
|
kether: '0.001',
|
|
mether: '0.000001',
|
|
gether: '0.000000001',
|
|
tether: '0.000000000001',
|
|
}
|
|
const bnTable = {}
|
|
Object.keys(valueTable).forEach((currency) => {
|
|
bnTable[currency] = new ethUtil.BN(valueTable[currency], 10)
|
|
})
|
|
|
|
export function isEthNetwork (netId) {
|
|
if (!netId || netId === '1' || netId === '3' || netId === '4' || netId === '42' || netId === '1337') {
|
|
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 = checksumAddress(address)
|
|
if (!includeHex) {
|
|
checked = ethUtil.stripHexPrefix(checked)
|
|
}
|
|
return checked ? `${checked.slice(0, firstSegLength)}...${checked.slice(checked.length - lastSegLength)}` : '...'
|
|
}
|
|
|
|
export function isValidAddress (address) {
|
|
if (!address || address === '0x0000000000000000000000000000000000000000') {
|
|
return false
|
|
}
|
|
const prefixed = address.startsWith('0X') ? address : ethUtil.addHexPrefix(address)
|
|
return (isAllOneCase(prefixed.slice(2)) && ethUtil.isValidAddress(prefixed)) || ethUtil.isValidChecksumAddress(prefixed)
|
|
}
|
|
|
|
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 isAllOneCase (address) {
|
|
if (!address) {
|
|
return true
|
|
}
|
|
const lower = address.toLowerCase()
|
|
const upper = address.toUpperCase()
|
|
return address === lower || address === upper
|
|
}
|
|
|
|
// 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 generateBalanceObject (formattedBalance, decimalsToKeep = 1) {
|
|
let balance = formattedBalance.split(' ')[0]
|
|
const label = formattedBalance.split(' ')[1]
|
|
const beforeDecimal = balance.split('.')[0]
|
|
const afterDecimal = balance.split('.')[1]
|
|
const shortBalance = shortenBalance(balance, decimalsToKeep)
|
|
|
|
if (beforeDecimal === '0' && afterDecimal.substr(0, 5) === '00000') {
|
|
// eslint-disable-next-line eqeqeq
|
|
if (afterDecimal == 0) {
|
|
balance = '0'
|
|
} else {
|
|
balance = '<1.0e-5'
|
|
}
|
|
} else if (beforeDecimal !== '0') {
|
|
balance = `${beforeDecimal}.${afterDecimal.slice(0, decimalsToKeep)}`
|
|
}
|
|
|
|
return { balance, label, shortBalance }
|
|
}
|
|
|
|
export function shortenBalance (balance, decimalsToKeep = 1) {
|
|
let truncatedValue
|
|
const convertedBalance = parseFloat(balance)
|
|
if (convertedBalance > 1000000) {
|
|
truncatedValue = (balance / 1000000).toFixed(decimalsToKeep)
|
|
return `${truncatedValue}m`
|
|
} else if (convertedBalance > 1000) {
|
|
truncatedValue = (balance / 1000).toFixed(decimalsToKeep)
|
|
return `${truncatedValue}k`
|
|
} else if (convertedBalance === 0) {
|
|
return '0'
|
|
} else if (convertedBalance < 0.001) {
|
|
return '<0.001'
|
|
} else if (convertedBalance < 1) {
|
|
const stringBalance = convertedBalance.toString()
|
|
if (stringBalance.split('.')[1].length > 3) {
|
|
return convertedBalance.toFixed(3)
|
|
}
|
|
return stringBalance
|
|
}
|
|
return convertedBalance.toFixed(decimalsToKeep)
|
|
}
|
|
|
|
// Takes a BN and an ethereum currency name,
|
|
// returns a BN in wei
|
|
export function normalizeToWei (amount, currency) {
|
|
try {
|
|
return amount.mul(bnTable.wei).div(bnTable[currency])
|
|
} catch (e) {
|
|
return amount
|
|
}
|
|
}
|
|
|
|
export function normalizeEthStringToWei (str) {
|
|
const parts = str.split('.')
|
|
let eth = new ethUtil.BN(parts[0], 10).mul(bnTable.wei)
|
|
if (parts[1]) {
|
|
let decimal = parts[1]
|
|
while (decimal.length < 18) {
|
|
decimal += '0'
|
|
}
|
|
if (decimal.length > 18) {
|
|
decimal = decimal.slice(0, 18)
|
|
}
|
|
const decimalBN = new ethUtil.BN(decimal, 10)
|
|
eth = eth.add(decimalBN)
|
|
}
|
|
return eth
|
|
}
|
|
|
|
const multiple = new ethUtil.BN('10000', 10)
|
|
export function normalizeNumberToWei (n, currency) {
|
|
const enlarged = n * 10000
|
|
const amount = new ethUtil.BN(String(enlarged), 10)
|
|
return normalizeToWei(amount, currency).div(multiple)
|
|
}
|
|
|
|
export function isHex (str) {
|
|
return Boolean(str.match(/^(0x)?[0-9a-fA-F]+$/u))
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Safely checksumms a potentially-null address
|
|
*
|
|
* @param {string} [address] - address to checksum
|
|
* @returns {string} - checksummed address
|
|
*
|
|
*/
|
|
export function checksumAddress (address) {
|
|
const checksummed = address ? ethUtil.toChecksumAddress(address) : ''
|
|
return checksummed
|
|
}
|
|
|
|
/**
|
|
* 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 < 11) {
|
|
return address
|
|
}
|
|
|
|
return `${address.slice(0, 6)}...${address.slice(-4)}`
|
|
}
|
|
|
|
export function isValidAddressHead (address) {
|
|
const addressLengthIsLessThanFull = address.length < 42
|
|
const addressIsHex = isHex(address)
|
|
|
|
return addressLengthIsLessThanFull && addressIsHex
|
|
}
|
|
|
|
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, '')
|
|
}
|
|
|
|
/**
|
|
* 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'
|
|
*/
|
|
export function addHexPrefixToObjectValues (obj) {
|
|
return Object.keys(obj).reduce((newObj, key) => {
|
|
return { ...newObj, [key]: ethUtil.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 {boolean} [sendToken] - Indicates whether or not the transaciton is a token transaction
|
|
* @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
|
|
*/
|
|
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)
|
|
}
|
|
|
|
/**
|
|
* Makes a JSON RPC request to the given URL, with the given RPC method and params.
|
|
*
|
|
* @param {string} rpcUrl - The RPC endpoint URL to target.
|
|
* @param {string} rpcMethod - The RPC method to request.
|
|
* @param {Array<unknown>} [rpcParams] - The RPC method params.
|
|
* @returns {Promise<unknown|undefined>} Returns the result of the RPC method call,
|
|
* or throws an error in case of failure.
|
|
*/
|
|
export async function jsonRpcRequest (rpcUrl, rpcMethod, rpcParams = []) {
|
|
const jsonRpcResponse = await window.fetch(rpcUrl, {
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
id: Date.now().toString(),
|
|
jsonrpc: '2.0',
|
|
method: rpcMethod,
|
|
params: rpcParams,
|
|
}),
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
cache: 'default',
|
|
})
|
|
.then((httpResponse) => httpResponse.json())
|
|
|
|
if (
|
|
!jsonRpcResponse ||
|
|
Array.isArray(jsonRpcResponse) ||
|
|
typeof jsonRpcResponse !== 'object'
|
|
) {
|
|
throw new Error(`RPC endpoint ${rpcUrl} returned non-object response.`)
|
|
}
|
|
const { error, result } = jsonRpcResponse
|
|
|
|
if (error) {
|
|
throw new Error(error?.message || error)
|
|
}
|
|
return result
|
|
}
|
|
|