From f29683cc0a4779708286e0f1b129a72518b26471 Mon Sep 17 00:00:00 2001 From: Brad Decker Date: Tue, 24 Jan 2023 12:49:26 -0600 Subject: [PATCH 1/2] Complete level 36 migration of TypeScript by converting conversion.utils.js and deprecate old conversion util (#17262) --- shared/modules/conversion.utils.js | 452 ------------------------ shared/modules/conversion.utils.test.js | 215 +---------- shared/modules/conversion.utils.ts | 172 +++++++++ 3 files changed, 182 insertions(+), 657 deletions(-) delete mode 100644 shared/modules/conversion.utils.js create mode 100644 shared/modules/conversion.utils.ts diff --git a/shared/modules/conversion.utils.js b/shared/modules/conversion.utils.js deleted file mode 100644 index d413ed013e97..000000000000 --- a/shared/modules/conversion.utils.js +++ /dev/null @@ -1,452 +0,0 @@ -/** - * 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 {string} [options.numberOfDecimals] - The desired number of decimals in the result - * @param {string} [options.roundDown] - The desired number of decimals to round down to - * @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` conditional modifies the supplied `value` property, depending - * on the accompanying options. - */ - -import BigNumber from 'bignumber.js'; - -import { addHexPrefix, BN } from 'ethereumjs-util'; -import { ETH, WEI } from '../../ui/helpers/constants/common'; - -import { stripHexPrefix } from './hexstring-utils'; - -// Big Number Constants -const BIG_NUMBER_WEI_MULTIPLIER = new BigNumber('1000000000000000000'); -const BIG_NUMBER_GWEI_MULTIPLIER = new BigNumber('1000000000'); -const BIG_NUMBER_ETH_MULTIPLIER = new BigNumber('1'); - -// Setter Maps -const toBigNumber = { - hex: (n) => new BigNumber(stripHexPrefix(n), 16), - dec: (n) => new BigNumber(String(n), 10), - BN: (n) => new BigNumber(n.toString(16), 16), -}; -const toNormalizedDenomination = { - WEI: (bigNumber) => bigNumber.div(BIG_NUMBER_WEI_MULTIPLIER), - GWEI: (bigNumber) => bigNumber.div(BIG_NUMBER_GWEI_MULTIPLIER), - ETH: (bigNumber) => bigNumber.div(BIG_NUMBER_ETH_MULTIPLIER), -}; -const toSpecifiedDenomination = { - WEI: (bigNumber) => bigNumber.times(BIG_NUMBER_WEI_MULTIPLIER).round(), - GWEI: (bigNumber) => bigNumber.times(BIG_NUMBER_GWEI_MULTIPLIER).round(9), - ETH: (bigNumber) => bigNumber.times(BIG_NUMBER_ETH_MULTIPLIER).round(9), -}; -const baseChange = { - hex: (n) => n.toString(16), - dec: (n) => new BigNumber(n).toString(10), - BN: (n) => new BN(n.toString(16)), -}; - -// Utility function for checking base types -const isValidBase = (base) => { - return Number.isInteger(base) && base > 1; -}; - -/** - * Defines the base type of numeric value - * - * @typedef {('hex' | 'dec' | 'BN')} NumericBase - */ - -/** - * Defines which type of denomination a value is in - * - * @typedef {('WEI' | 'GWEI' | 'ETH')} EthDenomination - */ - -/** - * Utility method to convert a value between denominations, formats and currencies. - * - * @param {object} input - * @param {string | BigNumber} input.value - * @param {NumericBase} input.fromNumericBase - * @param {EthDenomination} [input.fromDenomination] - * @param {string} [input.fromCurrency] - * @param {NumericBase} input.toNumericBase - * @param {EthDenomination} [input.toDenomination] - * @param {string} [input.toCurrency] - * @param {number} [input.numberOfDecimals] - * @param {number} [input.conversionRate] - * @param {boolean} [input.invertConversionRate] - * @param {string} [input.roundDown] - */ -const converter = ({ - value, - fromNumericBase, - fromDenomination, - fromCurrency, - toNumericBase, - toDenomination, - toCurrency, - numberOfDecimals, - conversionRate, - invertConversionRate, - roundDown, -}) => { - let convertedValue = fromNumericBase - ? toBigNumber[fromNumericBase](value) - : value; - - if (fromDenomination) { - convertedValue = toNormalizedDenomination[fromDenomination](convertedValue); - } - - if (fromCurrency !== toCurrency) { - if (conversionRate === null || conversionRate === undefined) { - throw new Error( - `Converting from ${fromCurrency} to ${toCurrency} requires a conversionRate, but one was not provided`, - ); - } - let rate = toBigNumber.dec(conversionRate); - if (invertConversionRate) { - rate = new BigNumber(1.0).div(conversionRate); - } - convertedValue = convertedValue.times(rate); - } - - if (toDenomination) { - convertedValue = toSpecifiedDenomination[toDenomination](convertedValue); - } - - if (numberOfDecimals !== undefined && numberOfDecimals !== null) { - convertedValue = convertedValue.round( - numberOfDecimals, - BigNumber.ROUND_HALF_DOWN, - ); - } - - if (roundDown) { - convertedValue = convertedValue.round(roundDown, BigNumber.ROUND_DOWN); - } - - if (toNumericBase) { - convertedValue = baseChange[toNumericBase](convertedValue); - } - return convertedValue; -}; - -const conversionUtil = ( - value, - { - fromCurrency = null, - toCurrency = fromCurrency, - fromNumericBase, - toNumericBase, - fromDenomination, - toDenomination, - numberOfDecimals, - conversionRate, - invertConversionRate, - }, -) => { - if (fromCurrency !== toCurrency && !conversionRate) { - return 0; - } - return converter({ - fromCurrency, - toCurrency, - fromNumericBase, - toNumericBase, - fromDenomination, - toDenomination, - numberOfDecimals, - conversionRate, - invertConversionRate, - value: value || '0', - }); -}; - -const getBigNumber = (value, base) => { - if (!isValidBase(base)) { - throw new Error('Must specify valid base'); - } - - // We don't include 'number' here, because BigNumber will throw if passed - // a number primitive it considers unsafe. - if (typeof value === 'string' || value instanceof BigNumber) { - return new BigNumber(value, base); - } - - return new BigNumber(String(value), base); -}; - -const addCurrencies = (a, b, options = {}) => { - const { aBase, bBase, ...conversionOptions } = options; - - if (!isValidBase(aBase) || !isValidBase(bBase)) { - throw new Error('Must specify valid aBase and bBase'); - } - - const value = getBigNumber(a, aBase).add(getBigNumber(b, bBase)); - - return converter({ - value, - ...conversionOptions, - }); -}; - -const subtractCurrencies = (a, b, options = {}) => { - const { aBase, bBase, ...conversionOptions } = options; - - if (!isValidBase(aBase) || !isValidBase(bBase)) { - throw new Error('Must specify valid aBase and bBase'); - } - - const value = getBigNumber(a, aBase).minus(getBigNumber(b, bBase)); - - return converter({ - value, - ...conversionOptions, - }); -}; - -const multiplyCurrencies = (a, b, options = {}) => { - const { multiplicandBase, multiplierBase, ...conversionOptions } = options; - - if (!isValidBase(multiplicandBase) || !isValidBase(multiplierBase)) { - throw new Error('Must specify valid multiplicandBase and multiplierBase'); - } - - const value = getBigNumber(a, multiplicandBase).times( - getBigNumber(b, multiplierBase), - ); - - return converter({ - value, - ...conversionOptions, - }); -}; - -const divideCurrencies = (a, b, options = {}) => { - const { dividendBase, divisorBase, ...conversionOptions } = options; - - if (!isValidBase(dividendBase) || !isValidBase(divisorBase)) { - throw new Error('Must specify valid dividendBase and divisorBase'); - } - - const value = getBigNumber(a, dividendBase).div(getBigNumber(b, divisorBase)); - - return converter({ - value, - ...conversionOptions, - }); -}; - -const conversionGreaterThan = ({ ...firstProps }, { ...secondProps }) => { - const firstValue = converter({ ...firstProps }); - const secondValue = converter({ ...secondProps }); - - return firstValue.gt(secondValue); -}; - -const conversionLessThan = ({ ...firstProps }, { ...secondProps }) => { - const firstValue = converter({ ...firstProps }); - const secondValue = converter({ ...secondProps }); - - return firstValue.lt(secondValue); -}; - -const conversionMax = ({ ...firstProps }, { ...secondProps }) => { - const firstIsGreater = conversionGreaterThan( - { ...firstProps }, - { ...secondProps }, - ); - - return firstIsGreater ? firstProps.value : secondProps.value; -}; - -const conversionGTE = ({ ...firstProps }, { ...secondProps }) => { - const firstValue = converter({ ...firstProps }); - const secondValue = converter({ ...secondProps }); - return firstValue.greaterThanOrEqualTo(secondValue); -}; - -const conversionLTE = ({ ...firstProps }, { ...secondProps }) => { - const firstValue = converter({ ...firstProps }); - const secondValue = converter({ ...secondProps }); - return firstValue.lessThanOrEqualTo(secondValue); -}; - -const toNegative = (n, options = {}) => { - return multiplyCurrencies(n, -1, options); -}; - -function decGWEIToHexWEI(decGWEI) { - return conversionUtil(decGWEI, { - fromNumericBase: 'dec', - toNumericBase: 'hex', - fromDenomination: 'GWEI', - toDenomination: 'WEI', - }); -} - -export function subtractHexes(aHexWEI, bHexWEI) { - return subtractCurrencies(aHexWEI, bHexWEI, { - aBase: 16, - bBase: 16, - toNumericBase: 'hex', - numberOfDecimals: 6, - }); -} - -export function addHexes(aHexWEI, bHexWEI) { - return addCurrencies(aHexWEI, bHexWEI, { - aBase: 16, - bBase: 16, - toNumericBase: 'hex', - numberOfDecimals: 6, - }); -} - -export function decWEIToDecETH(hexWEI) { - return conversionUtil(hexWEI, { - fromNumericBase: 'dec', - toNumericBase: 'dec', - fromDenomination: 'WEI', - toDenomination: 'ETH', - }); -} - -export function hexWEIToDecETH(hexWEI) { - return conversionUtil(hexWEI, { - fromNumericBase: 'hex', - toNumericBase: 'dec', - fromDenomination: 'WEI', - toDenomination: 'ETH', - }); -} - -export function decEthToConvertedCurrency( - ethTotal, - convertedCurrency, - conversionRate, -) { - return conversionUtil(ethTotal, { - fromNumericBase: 'dec', - toNumericBase: 'dec', - fromCurrency: 'ETH', - toCurrency: convertedCurrency, - numberOfDecimals: 2, - conversionRate, - }); -} - -export function getWeiHexFromDecimalValue({ - value, - fromCurrency, - conversionRate, - fromDenomination, - invertConversionRate, -}) { - return conversionUtil(value, { - fromNumericBase: 'dec', - toNumericBase: 'hex', - toCurrency: ETH, - fromCurrency, - conversionRate, - invertConversionRate, - fromDenomination, - toDenomination: WEI, - }); -} - -/** - * Converts a BN object to a hex string with a '0x' prefix - * - * @param {BN} inputBn - The BN to convert to a hex string - * @returns {string} A '0x' prefixed hex string - */ -export function bnToHex(inputBn) { - return addHexPrefix(inputBn.toString(16)); -} - -export function getValueFromWeiHex({ - value, - fromCurrency = ETH, - toCurrency, - conversionRate, - numberOfDecimals, - toDenomination, -}) { - return conversionUtil(value, { - fromNumericBase: 'hex', - toNumericBase: 'dec', - fromCurrency, - toCurrency, - numberOfDecimals, - fromDenomination: WEI, - toDenomination, - conversionRate, - }); -} - -export function sumHexes(...args) { - const total = args.reduce((acc, hexAmount) => { - return addCurrencies(acc, hexAmount, { - toNumericBase: 'hex', - aBase: 16, - bBase: 16, - }); - }); - - return addHexPrefix(total); -} - -export function hexWEIToDecGWEI(decGWEI) { - return conversionUtil(decGWEI, { - fromNumericBase: 'hex', - toNumericBase: 'dec', - fromDenomination: 'WEI', - toDenomination: 'GWEI', - }); -} - -export function decimalToHex(decimal) { - return conversionUtil(decimal, { - fromNumericBase: 'dec', - toNumericBase: 'hex', - }); -} - -export function hexToDecimal(hexValue) { - return conversionUtil(hexValue, { - fromNumericBase: 'hex', - toNumericBase: 'dec', - }); -} - -export { - conversionUtil, - addCurrencies, - multiplyCurrencies, - conversionGreaterThan, - conversionLessThan, - conversionGTE, - conversionLTE, - conversionMax, - toNegative, - subtractCurrencies, - decGWEIToHexWEI, - toBigNumber, - toNormalizedDenomination, - divideCurrencies, -}; diff --git a/shared/modules/conversion.utils.test.js b/shared/modules/conversion.utils.test.js index c6b064a94f8e..c3f2b6a92bad 100644 --- a/shared/modules/conversion.utils.test.js +++ b/shared/modules/conversion.utils.test.js @@ -1,212 +1,11 @@ -import BigNumber from 'bignumber.js'; -import { ETH } from '../../ui/helpers/constants/common'; +import { EtherDenomination } from '../constants/common'; import { - addCurrencies, - conversionUtil, decWEIToDecETH, - divideCurrencies, getValueFromWeiHex, getWeiHexFromDecimalValue, } from './conversion.utils'; describe('conversion utils', () => { - describe('addCurrencies()', () => { - it('add whole numbers', () => { - const result = addCurrencies(3, 9, { - aBase: 10, - bBase: 10, - }); - expect(result.toNumber()).toStrictEqual(12); - }); - - it('add decimals', () => { - const result = addCurrencies(1.3, 1.9, { - aBase: 10, - bBase: 10, - }); - expect(result.toNumber()).toStrictEqual(3.2); - }); - - it('add repeating decimals', () => { - const result = addCurrencies(1 / 3, 1 / 9, { - aBase: 10, - bBase: 10, - }); - expect(result.toNumber()).toStrictEqual(0.4444444444444444); - }); - }); - - describe('conversionUtil', () => { - it('returns expected types', () => { - const conv1 = conversionUtil(1000000000000000000, { - fromNumericBase: 'dec', - toNumericBase: 'hex', - }); - const conv2 = conversionUtil(1, { - fromNumericBase: 'dec', - fromDenomination: 'ETH', - toDenomination: 'WEI', - }); - expect(typeof conv1 === 'string').toStrictEqual(true); - expect(conv2 instanceof BigNumber).toStrictEqual(true); - }); - it('converts from dec to hex', () => { - expect( - conversionUtil('1000000000000000000', { - fromNumericBase: 'dec', - toNumericBase: 'hex', - }), - ).toStrictEqual('de0b6b3a7640000'); - expect( - conversionUtil('1500000000000000000', { - fromNumericBase: 'dec', - toNumericBase: 'hex', - }), - ).toStrictEqual('14d1120d7b160000'); - }); - it('converts hex formatted numbers to dec', () => { - expect( - conversionUtil('0xde0b6b3a7640000', { - fromNumericBase: 'hex', - toNumericBase: 'dec', - }), - ).toStrictEqual('1000000000000000000'); - expect( - conversionUtil('0x14d1120d7b160000', { - fromNumericBase: 'hex', - toNumericBase: 'dec', - }), - ).toStrictEqual('1500000000000000000'); - }); - it('converts WEI to ETH', () => { - expect( - conversionUtil('0xde0b6b3a7640000', { - fromNumericBase: 'hex', - toNumericBase: 'dec', - fromDenomination: 'WEI', - toDenomination: 'ETH', - }), - ).toStrictEqual('1'); - expect( - conversionUtil('0x14d1120d7b160000', { - fromNumericBase: 'hex', - toNumericBase: 'dec', - fromDenomination: 'WEI', - toDenomination: 'ETH', - }), - ).toStrictEqual('1.5'); - }); - it('converts ETH to WEI', () => { - expect( - conversionUtil('1', { - fromNumericBase: 'dec', - fromDenomination: 'ETH', - toDenomination: 'WEI', - }).toNumber(), - ).toStrictEqual(1000000000000000000); - expect( - conversionUtil('1.5', { - fromNumericBase: 'dec', - fromDenomination: 'ETH', - toDenomination: 'WEI', - }).toNumber(), - ).toStrictEqual(1500000000000000000); - }); - it('converts ETH to GWEI', () => { - expect( - conversionUtil('1', { - fromNumericBase: 'dec', - fromDenomination: 'ETH', - toDenomination: 'GWEI', - }).toNumber(), - ).toStrictEqual(1000000000); - expect( - conversionUtil('1.5', { - fromNumericBase: 'dec', - fromDenomination: 'ETH', - toDenomination: 'GWEI', - }).toNumber(), - ).toStrictEqual(1500000000); - }); - it('converts ETH to USD', () => { - expect( - conversionUtil('1', { - fromNumericBase: 'dec', - toNumericBase: 'dec', - toCurrency: 'usd', - conversionRate: 468.58, - numberOfDecimals: 2, - }), - ).toStrictEqual('468.58'); - expect( - conversionUtil('1.5', { - fromNumericBase: 'dec', - toNumericBase: 'dec', - toCurrency: 'usd', - conversionRate: 468.58, - numberOfDecimals: 2, - }), - ).toStrictEqual('702.87'); - }); - it('converts USD to ETH', () => { - expect( - conversionUtil('468.58', { - fromNumericBase: 'dec', - toNumericBase: 'dec', - toCurrency: 'usd', - conversionRate: 468.58, - numberOfDecimals: 2, - invertConversionRate: true, - }), - ).toStrictEqual('1'); - expect( - conversionUtil('702.87', { - fromNumericBase: 'dec', - toNumericBase: 'dec', - toCurrency: 'usd', - conversionRate: 468.58, - numberOfDecimals: 2, - invertConversionRate: true, - }), - ).toStrictEqual('1.5'); - }); - }); - - describe('divideCurrencies()', () => { - it('should correctly divide decimal values', () => { - const result = divideCurrencies(9, 3, { - dividendBase: 10, - divisorBase: 10, - }); - expect(result.toNumber()).toStrictEqual(3); - }); - - it('should correctly divide hexadecimal values', () => { - const result = divideCurrencies(1000, 0xa, { - dividendBase: 16, - divisorBase: 16, - }); - expect(result.toNumber()).toStrictEqual(0x100); - }); - - it('should correctly divide hexadecimal value from decimal value', () => { - const result = divideCurrencies(0x3e8, 0xa, { - dividendBase: 16, - divisorBase: 16, - }); - expect(result.toNumber()).toStrictEqual(0x100); - }); - - it('should throw error for wrong base value', () => { - expect(() => { - divideCurrencies(0x3e8, 0xa, { - dividendBase: 10.5, - divisorBase: 7, - }); - }).toThrow('Must specify valid dividendBase and divisorBase'); - }); - }); - describe('decWEIToDecETH', () => { it('converts 10000000000000 WEI to ETH', () => { const ethDec = decWEIToDecETH('10000000000000'); @@ -223,11 +22,18 @@ describe('conversion utils', () => { it('should correctly convert 0 in ETH', () => { const weiValue = getWeiHexFromDecimalValue({ value: '0', - fromCurrency: ETH, - fromDenomination: ETH, + fromDenomination: EtherDenomination.ETH, }); expect(weiValue).toStrictEqual('0'); }); + + it('should correctly convert 10 in ETH to 8ac7230489e80000 (10000000000000000000) wei', () => { + const weiValue = getWeiHexFromDecimalValue({ + value: '10', + fromDenomination: EtherDenomination.ETH, + }); + expect(weiValue).toStrictEqual('8ac7230489e80000'); + }); }); describe('getValueFromWeiHex', () => { @@ -235,7 +41,6 @@ describe('conversion utils', () => { const ethTransactionAmount = getValueFromWeiHex({ value: '0xde0b6b3a7640000', toCurrency: 'ETH', - conversionRate: 468.58, numberOfDecimals: 6, }); diff --git a/shared/modules/conversion.utils.ts b/shared/modules/conversion.utils.ts new file mode 100644 index 000000000000..e2466bcabb1a --- /dev/null +++ b/shared/modules/conversion.utils.ts @@ -0,0 +1,172 @@ +import { BigNumber } from 'bignumber.js'; + +import { addHexPrefix, BN } from 'ethereumjs-util'; +import { EtherDenomination } from '../constants/common'; +import { Numeric, NumericValue } from './Numeric'; + +export function decGWEIToHexWEI(decGWEI: number) { + return new Numeric(decGWEI, 10, EtherDenomination.GWEI) + .toBase(16) + .toDenomination(EtherDenomination.WEI) + .toString(); +} + +export function subtractHexes(aHexWEI: string, bHexWEI: string) { + return new Numeric(aHexWEI, 16) + .minus(new Numeric(bHexWEI, 16)) + .round(6, BigNumber.ROUND_HALF_DOWN) + .toString(); +} + +export function addHexes(aHexWEI: string, bHexWEI: string) { + return new Numeric(aHexWEI, 16) + .add(new Numeric(bHexWEI, 16)) + .round(6, BigNumber.ROUND_HALF_DOWN) + .toString(); +} + +export function decWEIToDecETH(decWEI: string) { + return new Numeric(decWEI, 10, EtherDenomination.WEI) + .toDenomination(EtherDenomination.ETH) + .toString(); +} + +export function hexWEIToDecETH(hexWEI: string) { + return new Numeric(hexWEI, 16, EtherDenomination.WEI) + .toDenomination(EtherDenomination.ETH) + .toBase(10) + .toString(); +} + +export function decEthToConvertedCurrency( + ethTotal: NumericValue, + convertedCurrency?: string, + conversionRate?: number, +) { + let numeric = new Numeric(ethTotal, 10, EtherDenomination.ETH); + + if (convertedCurrency !== EtherDenomination.ETH) { + numeric = numeric.applyConversionRate(conversionRate); + } + + return numeric.round(2); +} + +export function getWeiHexFromDecimalValue({ + value, + conversionRate = 1, + fromDenomination, + fromCurrency, + invertConversionRate = false, +}: { + value: NumericValue; + conversionRate?: number; + fromDenomination?: EtherDenomination; + fromCurrency?: string; + invertConversionRate?: boolean; +}) { + let numeric = new Numeric(value, 10, fromDenomination); + if (fromCurrency !== EtherDenomination.ETH) { + numeric = numeric.applyConversionRate(conversionRate, invertConversionRate); + } + return numeric.toBase(16).toDenomination(EtherDenomination.WEI).toString(); +} + +/** + * Converts a BN object to a hex string with a '0x' prefix + * + * @param inputBn - The BN to convert to a hex string + * @returns A '0x' prefixed hex string + */ +export function bnToHex(inputBn: BN) { + return addHexPrefix(inputBn.toString(16)); +} + +export function getEthConversionFromWeiHex({ + value, + fromCurrency = EtherDenomination.ETH, + conversionRate, + numberOfDecimals = 6, +}: { + value: NumericValue; + conversionRate?: number; + fromCurrency?: EtherDenomination | string; + numberOfDecimals?: number; +}) { + const denominations = [ + EtherDenomination.ETH, + EtherDenomination.GWEI, + EtherDenomination.WEI, + ]; + + let nonZeroDenomination; + + for (let i = 0; i < denominations.length; i++) { + const convertedValue = getValueFromWeiHex({ + value, + conversionRate, + fromCurrency, + toCurrency: fromCurrency, + numberOfDecimals, + toDenomination: denominations[i], + }); + + if (convertedValue !== '0' || i === denominations.length - 1) { + nonZeroDenomination = `${convertedValue} ${denominations[i]}`; + break; + } + } + + return nonZeroDenomination; +} + +export function getValueFromWeiHex({ + value, + fromCurrency = EtherDenomination.ETH, + toCurrency, + conversionRate, + numberOfDecimals, + toDenomination = EtherDenomination.ETH, +}: { + value: NumericValue; + fromCurrency?: EtherDenomination | string; + toCurrency?: EtherDenomination | string; + conversionRate?: number; + numberOfDecimals?: number; + toDenomination?: EtherDenomination; +}) { + let numeric = new Numeric(value, 16, EtherDenomination.WEI); + if (fromCurrency !== toCurrency) { + numeric = numeric.applyConversionRate(conversionRate); + } + return numeric + .toBase(10) + .toDenomination(toDenomination) + .round(numberOfDecimals, BigNumber.ROUND_HALF_DOWN) + .toString(); +} + +export function sumHexes(first: string, ...args: string[]) { + const firstValue = new Numeric(first, 16); + const total = args.reduce( + (acc, hexAmount) => acc.add(new Numeric(hexAmount, 16)), + firstValue, + ); + + return total.toPrefixedHexString(); +} + +export function hexWEIToDecGWEI(value: number | string | BigNumber | BN) { + return new Numeric(value, 16, EtherDenomination.WEI) + .toBase(10) + .toDenomination(EtherDenomination.GWEI) + .toString(); +} + +export function decimalToHex(decimal: number | string | BigNumber | BN) { + return new Numeric(decimal, 10).toBase(16).toString(); +} + +export function hexToDecimal(hexValue: number | string | BigNumber | BN) { + return new Numeric(hexValue, 16).toBase(10).toString(); +} From c35b9dea64adc4ccc3897998fa01f35db1de9b95 Mon Sep 17 00:00:00 2001 From: weizman Date: Tue, 24 Jan 2023 21:24:01 +0200 Subject: [PATCH 2/2] remove duplicate comment line (#17381) --- development/build/index.js | 1 - 1 file changed, 1 deletion(-) diff --git a/development/build/index.js b/development/build/index.js index 73a2d2d21b27..304a621233bb 100755 --- a/development/build/index.js +++ b/development/build/index.js @@ -73,7 +73,6 @@ async function defineAndRunBuildTasks() { version, } = await parseArgv(); - // build lavamoat runtime file // build lavamoat runtime file await lavapack.buildRuntime({ scuttleGlobalThis: true,