text: const ethUtil = require('ethereumjs-util')
  
  var 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',
  }
  var bnTable = {}
  for (var currency in valueTable) {
    bnTable[currency] = new ethUtil.BN(valueTable[currency], 10)
  }
  
  module.exports = {
    valuesFor: valuesFor,
    addressSummary: addressSummary,
    miniAddressSummary: miniAddressSummary,
    isAllOneCase: isAllOneCase,
    isValidAddress: isValidAddress,
    numericBalance: numericBalance,
    parseBalance: parseBalance,
    formatBalance: formatBalance,
    generateBalanceObject: generateBalanceObject,
    dataSize: dataSize,
    readableDate: readableDate,
    normalizeToWei: normalizeToWei,
    normalizeEthStringToWei: normalizeEthStringToWei,
    normalizeNumberToWei: normalizeNumberToWei,
    valueTable: valueTable,
    bnTable: bnTable,
    isHex: isHex,
    exportAsFile: exportAsFile,
    isInvalidChecksumAddress,
  }
  
  function valuesFor (obj) {
    if (!obj) return []
    return Object.keys(obj)
      .map(function (key) { return obj[key] })
  }
  
  function addressSummary (address, firstSegLength = 10, lastSegLength = 4, includeHex = true) {
    if (!address) return ''
    let checked = ethUtil.toChecksumAddress(address)
    if (!includeHex) {
      checked = ethUtil.stripHexPrefix(checked)
    }
    return checked ? checked.slice(0, firstSegLength) + '...' + checked.slice(checked.length - lastSegLength) : '...'
  }
  
  function miniAddressSummary (address) {
    if (!address) return ''
    var checked = ethUtil.toChecksumAddress(address)
    return checked ? checked.slice(0, 4) + '...' + checked.slice(-4) : '...'
  }
  
  function isValidAddress (address) {
    var prefixed = ethUtil.addHexPrefix(address)
    if (address === '0x0000000000000000000000000000000000000000') return false
    return (isAllOneCase(prefixed) && ethUtil.isValidAddress(prefixed)) || ethUtil.isValidChecksumAddress(prefixed)
  }
  
  function isInvalidChecksumAddress (address) {
    var prefixed = ethUtil.addHexPrefix(address)
    if (address === '0x0000000000000000000000000000000000000000') return false
    return !isAllOneCase(prefixed) && !ethUtil.isValidChecksumAddress(prefixed) && ethUtil.isValidAddress(prefixed)
  }
  
  function isAllOneCase (address) {
    if (!address) return true
    var lower = address.toLowerCase()
    var upper = address.toUpperCase()
    return address === lower || address === upper
  }
  
  // Takes wei Hex, returns wei BN, even if input is null
  function numericBalance (balance) {
    if (!balance) return new ethUtil.BN(0, 16)
    var stripped = ethUtil.stripHexPrefix(balance)
    return new ethUtil.BN(stripped, 16)
  }
  
  // Takes  hex, returns [beforeDecimal, afterDecimal]
  function parseBalance (balance) {
    var beforeDecimal, afterDecimal
    const wei = numericBalance(balance)
    var weiString = wei.toString()
    const trailingZeros = /0+$/
  
    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.
  function formatBalance (balance, decimalsToKeep, needsParse = true, network) {
    const isSokol = parseInt(network) === 77
    const isPOA = parseInt(network) === 99
    const coinName = isPOA ? 'POA' : isSokol ? 'SPOA' : 'ETH'
    var parsed = needsParse ? parseBalance(balance) : balance.split('.')
    var beforeDecimal = parsed[0]
    var afterDecimal = parsed[1]
    var formatted = 'None'
    if (decimalsToKeep === undefined) {
      if (beforeDecimal === '0') {
        if (afterDecimal !== '0') {
          var sigFigs = afterDecimal.match(/^0*(.{2})/) // default: grabs 2 most significant digits
          if (sigFigs) { afterDecimal = sigFigs[0] }
          formatted = '0.' + afterDecimal + ` ${coinName}`
        }
      } else {
        formatted = beforeDecimal + '.' + afterDecimal.slice(0, 3) + ` ${coinName}`
      }
    } else {
      afterDecimal += Array(decimalsToKeep).join('0')
      formatted = beforeDecimal + '.' + afterDecimal.slice(0, decimalsToKeep) + ` ${coinName}`
    }
    return formatted
  }
  
  
  function generateBalanceObject (formattedBalance, decimalsToKeep = 1) {
    var balance = formattedBalance.split(' ')[0]
    var label = formattedBalance.split(' ')[1]
    var beforeDecimal = balance.split('.')[0]
    var afterDecimal = balance.split('.')[1]
    var 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 }
  }
  
  function shortenBalance (balance, decimalsToKeep = 1) {
    var truncatedValue
    var 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) {
      var stringBalance = convertedBalance.toString()
      if (stringBalance.split('.')[1].length > 3) {
        return convertedBalance.toFixed(3)
      } else {
        return stringBalance
      }
    } else {
      return convertedBalance.toFixed(decimalsToKeep)
    }
  }
  
  function dataSize (data) {
    var size = data ? ethUtil.stripHexPrefix(data).length : 0
    return size + ' bytes'
  }
  
  // Takes a BN and an ethereum currency name,
  // returns a BN in wei
  function normalizeToWei (amount, currency) {
    try {
      return amount.mul(bnTable.wei).div(bnTable[currency])
    } catch (e) {}
    return amount
  }
  
  function normalizeEthStringToWei (str) {
    const parts = str.split('.')
    let eth = new ethUtil.BN(parts[0], 10).mul(bnTable.wei)
    if (parts[1]) {
      var decimal = parts[1]
      while (decimal.length < 18) {
        decimal += '0'
      }
      const decimalBN = new ethUtil.BN(decimal, 10)
      eth = eth.add(decimalBN)
    }
    return eth
  }
  
  var multiple = new ethUtil.BN('10000', 10)
  function normalizeNumberToWei (n, currency) {
    var enlarged = n * 10000
    var amount = new ethUtil.BN(String(enlarged), 10)
    return normalizeToWei(amount, currency).div(multiple)
  }
  
  function readableDate (ms) {
    var date = new Date(ms)
    var month = date.getMonth()
    var day = date.getDate()
    var year = date.getFullYear()
    var hours = date.getHours()
    var minutes = '0' + date.getMinutes()
    var seconds = '0' + date.getSeconds()
  
    var dateStr = `${month}/${day}/${year}`
    var time = `${hours}:${minutes.substr(-2)}:${seconds.substr(-2)}`
    return `${dateStr} ${time}`
  }
  
  function isHex (str) {
    return Boolean(str.match(/^(0x)?[0-9a-fA-F]+$/))
  }
  
  function exportAsFile (filename, data) {
    // source: https://stackoverflow.com/a/33542499 by Ludovic Feltz
    const blob = new Blob([data], {type: 'text/csv'})
    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)
    }
  }
  