BigMathUnsafe the number is divided into two parts: a coefficient and an exponent. This comes at a cost of losing some precision at the end of the number because the exponent simply fills it with zeroes. This precision is oftentimes negligible and can result in significant gas cost reduction due to storage space reduction. Also note, Valid big number is as follows: if the exponent is > 0, then coefficient last bits should be occupied to have max precision roundUp is more like a increase 1, which happens everytime for the same number. roundDown simply sets trailing digits after coefficientSize to zero (floor), only once to the same number. ROUND_DOWN bool ROUND_DOWN constants to use for roundUp input param to increase readability ROUND_UP bool ROUND_UP toBigNumber function toBigNumber ( uint256 normal , uint256 coefficientSize , uint256 exponentSize , bool roundUp ) internal pure returns ( uint256 bigNumber ) converts normal number to BigNumber with exponent and coefficient (or precision). e.g.: 5035703444687813576399599 (normal) = (coefficient 32bits , exponent 8bits ) 40bits 5035703444687813576399599 (decimal) => 10000101010010110100000011111011110010100110100000000011100101001101001101011101111 (binary) => 10000101010010110100000011111011000000000000000000000000000000000000000000000000000 ^-------------------- 51(exponent) -------------- ^ coefficient = 1000,0101,0100,1011,0100,0000,1111,1011 (2236301563) exponent = 0011,0011 (51) bigNumber = 1000,0101,0100,1011,0100,0000,1111,1011,0011,0011 (572493200179) Parameters Name Type Description normal uint256 number which needs to be converted into Big Number coefficientSize uint256 at max how many bits of precision there should be (64 = uint64 (64 bits precision)) exponentSize uint256 at max how many bits of exponent there should be (8 = uint8 (8 bits exponent)) roundUp bool signals if result should be rounded down or up Return Values Name Type Description bigNumber uint256 converted bigNumber (coefficient << exponent) toBigNumberExtended function toBigNumberExtended ( uint256 normal , uint256 coefficientSize , uint256 exponentSize , bool roundUp ) internal pure returns ( uint256 coefficient , uint256 exponent , uint256 bigNumber ) see {BigMathUnsafe-toBigNumber}, but returns coefficient and exponent too fromBigNumber function fromBigNumber ( uint256 coefficient , uint256 exponent ) internal pure returns ( uint256 normal ) get normal number from BigNumber coefficient and exponent . e.g.: (coefficient 32bits , exponent 8bits ) 40bits => (normal) (2236301563, 51) = 100001010100101101000000111110110000000000000000000000000000000000000000000000000 coefficient = 1000,0101,0100,1011,0100,0000,1111,1011 (2236301563) exponent = 0011,0011 (51) normal = 10000101010010110100000011111011000000000000000000000000000000000000000000000000000 (5035703442907428892442624) ^-------------------- 51(exponent) -------------- ^ fromBigNumber function fromBigNumber ( uint256 bigNumber , uint256 exponentSize , uint256 exponentMask ) internal pure returns ( uint256 normal ) get normal number from bigNumber , exponentSize and exponentMask mulDivNormal function mulDivNormal ( uint256 normal , uint256 bigNumber1 , uint256 bigNumber2 , uint256 exponentSize , uint256 exponentMask ) internal pure returns ( uint256 res ) multiplies a normal number with a bigNumber1 and then divides by bigNumber2 , with exponentSize and exponentMask being used for both bigNumbers. e.g. res = normal * bigNumber1 / bigNumber2 normal: normal number 281474976710656 bigNumber1: bigNumber 265046402172 (0011,1101,1011,0101,1111,1111,0010,0100)Coefficient, (0111,1100)Exponent bigNumber2: bigNumber 178478830197 [(0010 1001 1000 1110 0010 1010 1101 0010)Coefficient, (0111 0101)Exponent Return Values Name Type Description res uint256 normal number 53503841411969141 decompileBigNumber function decompileBigNumber ( uint256 bigNumber , uint256 exponentSize , uint256 exponentMask ) internal pure returns ( uint256 coefficient , uint256 exponent ) decompiles a bigNumber into coefficient and exponent , based on exponentSize and exponentMask . e.g. bigNumber 40bits => coefficient 32bits , exponent 8bits 1000,0101,0100,1011,0100,0000,1111,1011,0011,0011 => coefficient = 1000,0101,0100,1011,0100,0000,1111,1011 (2236301563) exponent = 0011,0011 (51) mostSignificantBit function mostSignificantBit ( uint256 normal ) internal pure returns ( uint256 lastBit ) gets the most significant bit lastBit of a normal number (length of given number of binary format). e.g. 5035703444687813576399599 = 10000101010010110100000011111011110010100110100000000011100101001101001101011101111 lastBit = ^--------------------------------- 83 ----------------------------------------^ mulDivBigNumber function mulDivBigNumber ( uint256 bigNumber , uint256 number1 , uint256 number2 , uint256 precisionBits , uint256 coefficientSize , uint256 exponentSize , uint256 exponentMask , bool roundUp ) internal pure returns ( uint256 result ) multiplies a bigNumber with normal number1 and then divides by normal number2 . exponentSize and exponentMask are used for the input bigNumber and the result is a BigNumber with coefficientSize and exponentSize . Parameters | Name | Type | Description | | --------------- | ------- | -------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | | bigNumber | uint256 | Coefficient | Exponent. Eg: 8 bits coefficient (1101 0101) and 4 bits exponent (0011) | | number1 | uint256 | normal number. Eg:- 32421421413532 | | number2 | uint256 | normal number. Eg:- 91897739843913 | | precisionBits | uint256 | precision bits should be set such that, (((Coefficient * number1) << precisionBits) / number2) > max coefficient possible | | coefficientSize | uint256 | coefficient size. Eg: 8 bits, 56 btits, etc | | exponentSize | uint256 | exponent size. Eg: 4 bits, 12 btits, etc | | exponentMask | uint256 | exponent mask. (1 << exponentSize) - 1 | | roundUp | bool | is true then roundUp, default it's round down | Return Values Name Type Description result uint256 bigNumber * number1 / number2. Note bigNumber can't get directly multiplied or divide by normal numbers. TODO: Add an example which can help in better understanding. Didn't converted into assembly as overflow checks are good to have mulBigNumber function mulBigNumber ( uint256 bigNumber1 , uint256 bigNumber2 , uint256 coefficientSize , uint256 exponentSize , uint256 decimal ) internal pure returns ( uint256 res ) multiplies a bigNumber1 with another bigNumber2 . e.g. res = bigNumber1 * bigNumber2 = (coe1, exp1) * (coe2, exp2) >> decimal = (coe1*coe2>>overflow, exp1+exp2+overflow-decimal) Parameters Name Type Description bigNumber1 uint256 BigNumber format with coefficient and exponent bigNumber2 uint256 BigNumber format with coefficient and exponent coefficientSize uint256 max size of coefficient, same for both bigNumber1 and bigNumber2 exponentSize uint256 max size of exponent, same for both bigNumber1 and bigNumber2 decimal uint256 decimals in bits Return Values Name Type Description res uint256 BigNumber format with coefficient and exponent divBigNumber function divBigNumber ( uint256 bigNumber1 , uint256 bigNumber2 , uint256 coefficientSize , uint256 exponentSize , uint256 precision_ , uint256 decimal ) internal pure returns ( uint256 res ) divides a bigNumber1 by bigNumber2 . e.g. res = bigNumber1 / bigNumber2 = (coe1, exp1) / (coe2, exp2) << decimal = ((coe1<

WeETHOracle

constructor

getExchangeRate