Reapply conversion utility changes and fix calls to utility in pending-tx.

package.json

@@ -53,6 +53,7 @@
     "async": "^2.5.0",
     "await-semaphore": "^0.1.1",
     "babel-runtime": "^6.23.0",
+    "bignumber.js": "^4.0.4",
     "bip39": "^2.2.0",
     "bluebird": "^3.5.0",
     "bn.js": "^4.11.7",
@@ -117,6 +118,7 @@
     "pump": "^1.0.2",
     "pumpify": "^1.3.4",
     "qrcode-npm": "0.0.3",
+    "ramda": "^0.24.1",
     "react": "^15.0.2",
     "react-addons-css-transition-group": "^15.6.0",
     "react-dom": "^15.5.4",

ui/app/components/pending-tx.js

@@ -74,18 +74,24 @@ PendingTx.prototype.getTotal = function () {
   const { params = [] } = decodedData || {}
   const { name, value } = params[1] || {}
   const amountBn = name === '_value'
-    ? new BN(value)
+    ? value
-    : hexToBn(txParams.value)
+    : txParams.value
   
   const USD = conversionUtil(amountBn, {
-    fromFormat: 'BN',
+    fromNumericBase: 'hex',
+    toNumericBase: 'dec',
+    fromCurrency: 'ETH',
     toCurrency: 'USD',
+    numberOfDecimals: 2,
     conversionRate,
   })
   const ETH = conversionUtil(amountBn, {
-    fromFormat: 'BN',
+    fromNumericBase: 'hex',
+    toNumericBase: 'dec',
+    fromCurrency: 'ETH',
     toCurrency: 'ETH',
     conversionRate,
+    numberOfDecimals: 6,
   })
 
   return {
@@ -109,15 +115,21 @@ PendingTx.prototype.getGasFee = function () {
   const txFeeBn = gasBn.mul(gasPriceBn)
 
   const USD = conversionUtil(txFeeBn, {
-    fromFormat: 'BN',
+    fromNumericBase: 'BN',
-    fromCurrency: 'GWEI',
+    toNumericBase: 'dec',
+    fromDenomination: 'WEI',
+    fromCurrency: 'ETH',
     toCurrency: 'USD',
+    numberOfDecimals: 2,
     conversionRate,
   })
   const ETH = conversionUtil(txFeeBn, {
-    fromFormat: 'BN',
+    fromNumericBase: 'BN',
-    fromCurrency: 'GWEI',
+    toNumericBase: 'dec',
+    fromDenomination: 'WEI',
+    fromCurrency: 'ETH',
     toCurrency: 'ETH',
+    numberOfDecimals: 6,
     conversionRate,
   })
 

ui/app/conversion-util.js

@@ -1,49 +1,108 @@
-const {
+/* Currency Conversion Utility
-  numericBalance,
+* This utility function can be used for converting currency related values within metamask.
-  parseBalance,
+* The caller should be able to pass it a value, along with information about the value's
-  formatBalance,
+* numeric base, denomination and currency, and the desired numeric base, denomination and
-  normalizeToWei,
+* currency. It should return a single value.
-  valueTable,
+*
-} = require('./util')
+* @param {(number | string | BN)} value The value to convert.
-const hexToBn = require('../../app/scripts/lib/hex-to-bn')
+* @param {Object} [options] Options to specify details of the conversion
-const { BN } = require('ethereumjs-util')
+* @param {string} [options.fromCurrency = 'ETH' | 'USD'] The currency of the passed value
-const GWEI_MULTIPLIER = normalizeToWei(hexToBn(valueTable.gwei.toString(16)), 'gwei');
+* @param {string} [options.toCurrency = 'ETH' | 'USD'] The desired currency of the result
+* @param {string} [options.fromNumericBase = 'hex' | 'dec' | 'BN'] The numeric basic of the passed value.
+* @param {string} [options.toNumericBase = 'hex' | 'dec' | 'BN'] The desired numeric basic of the result.
+* @param {string} [options.fromDenomination = 'WEI'] The denomination of the passed value
+* @param {number} [options.numberOfDecimals] The desired number of in the result
+* @param {number} [options.conversionRate] The rate to use to make the fromCurrency -> toCurrency conversion
+* @returns {(number | string | BN)}
+*
+* The utility passes value along with the options as a single object to the `converter` function.
+* `converter` uses Ramda.js to apply a composition of conditional setters to the `value` property, depending
+* on the accompanying options. Some of these conditional setters are selected via key-value maps, where
+* the keys are specified in the options parameters and the values are setter functions.
+*/
+
+const BigNumber = require('bignumber.js')
+const R = require('ramda')
+const { stripHexPrefix } = require('ethereumjs-util')
+
+BigNumber.config({
+  ROUNDING_MODE: BigNumber.ROUND_HALF_DOWN,
+})
+
+// Big Number Constants
+const BIG_NUMBER_WEI_MULTIPLIER = new BigNumber('1000000000000000000')
+
+// Individual Setters
+const convert = R.invoker(1, 'times')
+const round = R.invoker(2, 'toFormat')(R.__, BigNumber.ROUND_DOWN)
+
+// Setter Maps
+const toBigNumber = {
+  hex: n => new BigNumber(stripHexPrefix(n), 16),
+  dec: n => new BigNumber(n, 10),
+  BN: n => new BigNumber(n.toString(16), 16),
+}
+const toNormalizedDenomination = {
+  WEI: bigNumber => bigNumber.div(BIG_NUMBER_WEI_MULTIPLIER)
+}
+const baseChange = {
+  hex: n => n.toString(16),
+  dec: n => n.toString(10),
+  BN: n => new BN(n.toString(16)),
+}
+
+// Predicates
+const fromAndToCurrencyPropsNotEqual = R.compose(
+  R.not,
+  R.eqBy(R.__, 'fromCurrency', 'toCurrency'),
+  R.flip(R.prop)
+)
+
+// Lens
+const valuePropertyLense = R.over(R.lensProp('value'))
+
+// conditional 'value' setting wrappers
+const whenPredSetWithPropAndSetter = (pred, prop, setter) => R.when(
+  pred,
+  R.converge(
+    valuePropertyLense,
+    [R.pipe(R.prop(prop), setter), R.identity]
+  )
+)
+const whenPropApplySetterMap = (prop, setterMap) => whenPredSetWithPropAndSetter(
+  R.prop(prop),
+  prop,
+  R.prop(R.__, setterMap)
+)
+
+// Conversion utility function
+const converter = R.pipe(
+  whenPropApplySetterMap('fromNumericBase', toBigNumber),
+  whenPropApplySetterMap('fromDenomination', toNormalizedDenomination),
+  whenPredSetWithPropAndSetter(fromAndToCurrencyPropsNotEqual, 'conversionRate', convert),
+  whenPredSetWithPropAndSetter(R.prop('numberOfDecimals'), 'numberOfDecimals', round),
+  whenPropApplySetterMap('toNumericBase', baseChange),
+  R.view(R.lensProp('value'))
+);
 
 const conversionUtil = (value, {
+  fromCurrency = null,
+  toCurrency = fromCurrency,
+  fromNumericBase,
+  toNumericBase,
+  fromDenomination,
+  numberOfDecimals,
+  conversionRate,
+}) => converter({
   fromCurrency,
   toCurrency,
-  fromFormat,
+  fromNumericBase,
-  toFormat,
+  toNumericBase,
-  precision = 2,
+  fromDenomination,
+  numberOfDecimals,
   conversionRate,
-}) => {
+  value,
-  let result;
+});
-  
-  if (fromFormat === 'BN') {
-    if (fromCurrency !== 'GWEI') {
-      result = normalizeToWei(value, 'gwei')
-    }
-    else {
-      result = value
-    }
-
-    result = result.toString(16)
-    result = formatBalance(result, 9)
-    result = result.split(' ')
-    result = Number(result[0]) * 1000000000
-  }
-
-  if (fromCurrency === 'GWEI') {
-    result = result / 1000000000
-  }
-
-  if (toCurrency === 'USD') {
-    result = result * conversionRate
-    result = result.toFixed(precision)
-  }
-
-  return result
-};
 
 module.exports = {
   conversionUtil,