1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/* Currency Conversion Utility
* This utility function can be used for converting currency related values within metamask.
* The caller should be able to pass it a value, along with information about the value's
* numeric base, denomination and currency, and the desired numeric base, denomination and
* currency. It should return a single value.
*
* @param {(number | string | BN)} value The value to convert.
* @param {Object} [options] Options to specify details of the conversion
* @param {string} [options.fromCurrency = 'ETH' | 'USD'] The currency of the passed value
* @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
* @param {number} [options.ethToUSDRate] If present, a second conversion - at ethToUSDRate - happens after conversionRate is applied.
* @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)
const invertConversionRate = conversionRate => () => new BigNumber(1.0).div(conversionRate)
// 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 toSpecifiedDenomination = {
WEI: bigNumber => bigNumber.times(BIG_NUMBER_WEI_MULTIPLIER).round()
}
const baseChange = {
hex: n => n.toString(16),
dec: n => Number(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 valuePropertyLens = R.over(R.lensProp('value'))
const conversionRateLens = R.over(R.lensProp('conversionRate'))
// conditional conversionRate setting wrapper
const whenPredSetCRWithPropAndSetter = (pred, prop, setter) => R.when(
pred,
R.converge(
conversionRateLens,
[R.pipe(R.prop(prop), setter), R.identity]
)
)
// conditional 'value' setting wrappers
const whenPredSetWithPropAndSetter = (pred, prop, setter) => R.when(
pred,
R.converge(
valuePropertyLens,
[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(
whenPredSetCRWithPropAndSetter(R.prop('invertConversionRate'), 'conversionRate', invertConversionRate),
whenPropApplySetterMap('fromNumericBase', toBigNumber),
whenPropApplySetterMap('fromDenomination', toNormalizedDenomination),
whenPredSetWithPropAndSetter(fromAndToCurrencyPropsNotEqual, 'conversionRate', convert),
whenPropApplySetterMap('toDenomination', toSpecifiedDenomination),
whenPredSetWithPropAndSetter(R.prop('ethToUSDRate'), 'ethToUSDRate', 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,
toDenomination,
numberOfDecimals,
conversionRate,
ethToUSDRate,
invertConversionRate,
}) => converter({
fromCurrency,
toCurrency,
fromNumericBase,
toNumericBase,
fromDenomination,
toDenomination,
numberOfDecimals,
conversionRate,
ethToUSDRate,
invertConversionRate,
value,
});
const addCurrencies = (a, b, { toNumericBase, numberOfDecimals }) => {
const value = (new BigNumber(a)).add(b);
return converter({
value,
toNumericBase,
numberOfDecimals,
})
}
const conversionGreaterThan = (
{ value, fromNumericBase },
{ value: compareToValue, fromNumericBase: compareToBase },
) => {
const firstValue = converter({ value, fromNumericBase })
const secondValue = converter({
value: compareToValue,
fromNumericBase: compareToBase,
})
return firstValue.gt(secondValue)
}
module.exports = {
conversionUtil,
addCurrencies,
conversionGreaterThan,
}
|
