diff --git a/contracts/Boardroomv3.sol b/contracts/Boardroomv3.sol index 177742e9..aa8c5895 100644 --- a/contracts/Boardroomv3.sol +++ b/contracts/Boardroomv3.sol @@ -5,6 +5,7 @@ import '@openzeppelin/contracts/token/ERC20/IERC20.sol'; import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol'; import './lib/Safe112.sol'; +import './lib/prb-math/PRBMathUD60x18.sol'; import './owner/Operator.sol'; import './utils/ContractGuard.sol'; import './interfaces/IBasisAsset.sol'; @@ -26,23 +27,6 @@ contract ShareWrapper { function balanceOf(address account) public view returns (uint256) { return _balances[account]; } - - function stake(uint256 amount) public virtual { - _totalSupply = _totalSupply.add(amount); - _balances[msg.sender] = _balances[msg.sender].add(amount); - share.safeTransferFrom(msg.sender, address(this), amount); - } - - function withdraw(uint256 amount) public virtual { - uint256 directorShare = _balances[msg.sender]; - require( - directorShare >= amount, - 'Boardroom: withdraw request greater than staked amount' - ); - _totalSupply = _totalSupply.sub(amount); - _balances[msg.sender] = directorShare.sub(amount); - share.safeTransfer(msg.sender, amount); - } } contract Boardroomv3 is ShareWrapper, ContractGuard, Operator, IFeeDistributorRecipient { @@ -57,7 +41,7 @@ contract Boardroomv3 is ShareWrapper, ContractGuard, Operator, IFeeDistributorRe uint256 lastSnapshotIndex; uint256 rewardEarned; uint256 pendingWithdrawalBalance; - uint256 pendingWithdrawalTime; + uint256 startTime; } struct BoardSnapshot { @@ -141,82 +125,20 @@ contract Boardroomv3 is ShareWrapper, ContractGuard, Operator, IFeeDistributorRe } function earned(address director) public view returns (uint256) { - uint256 latestRPS = getLatestSnapshot().rewardPerShare; - uint256 storedRPS = getLastSnapshotOf(director).rewardPerShare; + uint256 stakingPeriod = (now - directors[director].startTime) / 1 days; - return - balanceOf(director).mul(latestRPS.sub(storedRPS)).div(1e18).add( - directors[director].rewardEarned - ); + return balanceOf(director).mul(PRBMathUD60x18.log10(stakingPeriod + 1)).div(1e18).add(directors[director].rewardEarned); } function pendingWithdrawalBalance(address director) public view returns (uint256) { return directors[director].pendingWithdrawalBalance; } - function pendingWithdrawalTime(address director) public view returns (uint256) { - return directors[director].pendingWithdrawalTime; + function startTime(address director) public view returns (uint256) { + return directors[director].startTime; } /* ========== MUTATIVE FUNCTIONS ========== */ - - function stake(uint256 amount) - public - override - onlyOneBlock - updateReward(msg.sender) - { - require(amount > 0, 'Boardroom: Cannot stake 0'); - super.stake(amount); - emit Staked(msg.sender, amount); - } - - function withdraw(uint256 amount) - public - override - onlyOneBlock - directorExists - updateReward(msg.sender) - { - require(amount > 0, 'Boardroom: Cannot withdraw 0'); - super.withdraw(amount); - emit Withdrawn(msg.sender, amount); - } - - function exit() external { - withdraw(balanceOf(msg.sender)); - claimReward(); - } - - //Claim rewards after the 5 day delay - function claimReward() public { - uint256 timeCanWithdraw = directors[msg.sender].pendingWithdrawalTime; - require(timeCanWithdraw <= now, 'Boardroom: Need to wait more time before claiming reward'); - - uint256 reward = directors[msg.sender].pendingWithdrawalBalance; - - if (reward > 0) { - directors[msg.sender].pendingWithdrawalBalance = 0; - directors[msg.sender].pendingWithdrawalTime = 0; - - cash.safeTransfer(msg.sender, reward); - emit RewardPaid(msg.sender, reward); - } - } - - //Initiates a reward claim with a 5 day delay - //This will reset the timer for any "mature" rewards the user has - function initiateRewardClaim() public updateReward(msg.sender) { - uint256 reward = directors[msg.sender].rewardEarned; - if (reward > 0) { - uint256 newPendingWithdrawalBalance = directors[msg.sender].pendingWithdrawalBalance.add(reward); - directors[msg.sender].rewardEarned = 0; - directors[msg.sender].pendingWithdrawalBalance = newPendingWithdrawalBalance; - directors[msg.sender].pendingWithdrawalTime = now + 5 days; - emit RewardPending(msg.sender, reward); - } - } - function allocateSeigniorage(uint256 amount) external onlyOneBlock diff --git a/contracts/lib/prb-math/PRBMathCommon.sol b/contracts/lib/prb-math/PRBMathCommon.sol new file mode 100644 index 00000000..c899d604 --- /dev/null +++ b/contracts/lib/prb-math/PRBMathCommon.sol @@ -0,0 +1,411 @@ +// SPDX-License-Identifier: WTFPL +pragma solidity >=0.6.0; + +/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library +/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point +// representation. When it does not, it is annonated in the function's NatSpec documentation. +library PRBMathCommon { + /// @dev How many trailing decimals can be represented. + uint256 internal constant SCALE = 1e18; + + /// @dev Largest power of two divisor of SCALE. + uint256 internal constant SCALE_LPOTD = 262144; + + /// @dev SCALE inverted mod 2^256. + uint256 internal constant SCALE_INVERSE = 78156646155174841979727994598816262306175212592076161876661508869554232690281; + + /// @notice Calculates the binary exponent of x using the binary fraction method. + /// @dev Uses 128.128-bit fixed-point numbers, which is the most efficient way. + /// See https://ethereum.stackexchange.com/a/96594/24693. + /// @param x The exponent as an unsigned 128.128-bit fixed-point number. + /// @return result The result as an unsigned 60x18 decimal fixed-point number. + function exp2(uint256 x) internal pure returns (uint256 result) { +// unchecked { + // Start from 0.5 in the 128.128-bit fixed-point format. + result = 0x80000000000000000000000000000000; + + // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows + // because the initial result is 2^127 and all magic factors are less than 2^129. + if (x & 0x80000000000000000000000000000000 > 0) result = (result * 0x16A09E667F3BCC908B2FB1366EA957D3E) >> 128; + if (x & 0x40000000000000000000000000000000 > 0) result = (result * 0x1306FE0A31B7152DE8D5A46305C85EDED) >> 128; + if (x & 0x20000000000000000000000000000000 > 0) result = (result * 0x1172B83C7D517ADCDF7C8C50EB14A7920) >> 128; + if (x & 0x10000000000000000000000000000000 > 0) result = (result * 0x10B5586CF9890F6298B92B71842A98364) >> 128; + if (x & 0x8000000000000000000000000000000 > 0) result = (result * 0x1059B0D31585743AE7C548EB68CA417FE) >> 128; + if (x & 0x4000000000000000000000000000000 > 0) result = (result * 0x102C9A3E778060EE6F7CACA4F7A29BDE9) >> 128; + if (x & 0x2000000000000000000000000000000 > 0) result = (result * 0x10163DA9FB33356D84A66AE336DCDFA40) >> 128; + if (x & 0x1000000000000000000000000000000 > 0) result = (result * 0x100B1AFA5ABCBED6129AB13EC11DC9544) >> 128; + if (x & 0x800000000000000000000000000000 > 0) result = (result * 0x10058C86DA1C09EA1FF19D294CF2F679C) >> 128; + if (x & 0x400000000000000000000000000000 > 0) result = (result * 0x1002C605E2E8CEC506D21BFC89A23A011) >> 128; + if (x & 0x200000000000000000000000000000 > 0) result = (result * 0x100162F3904051FA128BCA9C55C31E5E0) >> 128; + if (x & 0x100000000000000000000000000000 > 0) result = (result * 0x1000B175EFFDC76BA38E31671CA939726) >> 128; + if (x & 0x80000000000000000000000000000 > 0) result = (result * 0x100058BA01FB9F96D6CACD4B180917C3E) >> 128; + if (x & 0x40000000000000000000000000000 > 0) result = (result * 0x10002C5CC37DA9491D0985C348C68E7B4) >> 128; + if (x & 0x20000000000000000000000000000 > 0) result = (result * 0x1000162E525EE054754457D5995292027) >> 128; + if (x & 0x10000000000000000000000000000 > 0) result = (result * 0x10000B17255775C040618BF4A4ADE83FD) >> 128; + if (x & 0x8000000000000000000000000000 > 0) result = (result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAC) >> 128; + if (x & 0x4000000000000000000000000000 > 0) result = (result * 0x100002C5C89D5EC6CA4D7C8ACC017B7CA) >> 128; + if (x & 0x2000000000000000000000000000 > 0) result = (result * 0x10000162E43F4F831060E02D839A9D16D) >> 128; + if (x & 0x1000000000000000000000000000 > 0) result = (result * 0x100000B1721BCFC99D9F890EA06911763) >> 128; + if (x & 0x800000000000000000000000000 > 0) result = (result * 0x10000058B90CF1E6D97F9CA14DBCC1629) >> 128; + if (x & 0x400000000000000000000000000 > 0) result = (result * 0x1000002C5C863B73F016468F6BAC5CA2C) >> 128; + if (x & 0x200000000000000000000000000 > 0) result = (result * 0x100000162E430E5A18F6119E3C02282A6) >> 128; + if (x & 0x100000000000000000000000000 > 0) result = (result * 0x1000000B1721835514B86E6D96EFD1BFF) >> 128; + if (x & 0x80000000000000000000000000 > 0) result = (result * 0x100000058B90C0B48C6BE5DF846C5B2F0) >> 128; + if (x & 0x40000000000000000000000000 > 0) result = (result * 0x10000002C5C8601CC6B9E94213C72737B) >> 128; + if (x & 0x20000000000000000000000000 > 0) result = (result * 0x1000000162E42FFF037DF38AA2B219F07) >> 128; + if (x & 0x10000000000000000000000000 > 0) result = (result * 0x10000000B17217FBA9C739AA5819F44FA) >> 128; + if (x & 0x8000000000000000000000000 > 0) result = (result * 0x1000000058B90BFCDEE5ACD3C1CEDC824) >> 128; + if (x & 0x4000000000000000000000000 > 0) result = (result * 0x100000002C5C85FE31F35A6A30DA1BE51) >> 128; + if (x & 0x2000000000000000000000000 > 0) result = (result * 0x10000000162E42FF0999CE3541B9FFFD0) >> 128; + if (x & 0x1000000000000000000000000 > 0) result = (result * 0x100000000B17217F80F4EF5AADDA45554) >> 128; + if (x & 0x800000000000000000000000 > 0) result = (result * 0x10000000058B90BFBF8479BD5A81B51AE) >> 128; + if (x & 0x400000000000000000000000 > 0) result = (result * 0x1000000002C5C85FDF84BD62AE30A74CD) >> 128; + if (x & 0x200000000000000000000000 > 0) result = (result * 0x100000000162E42FEFB2FED257559BDAA) >> 128; + if (x & 0x100000000000000000000000 > 0) result = (result * 0x1000000000B17217F7D5A7716BBA4A9AF) >> 128; + if (x & 0x80000000000000000000000 > 0) result = (result * 0x100000000058B90BFBE9DDBAC5E109CCF) >> 128; + if (x & 0x40000000000000000000000 > 0) result = (result * 0x10000000002C5C85FDF4B15DE6F17EB0E) >> 128; + if (x & 0x20000000000000000000000 > 0) result = (result * 0x1000000000162E42FEFA494F1478FDE05) >> 128; + if (x & 0x10000000000000000000000 > 0) result = (result * 0x10000000000B17217F7D20CF927C8E94D) >> 128; + if (x & 0x8000000000000000000000 > 0) result = (result * 0x1000000000058B90BFBE8F71CB4E4B33E) >> 128; + if (x & 0x4000000000000000000000 > 0) result = (result * 0x100000000002C5C85FDF477B662B26946) >> 128; + if (x & 0x2000000000000000000000 > 0) result = (result * 0x10000000000162E42FEFA3AE53369388D) >> 128; + if (x & 0x1000000000000000000000 > 0) result = (result * 0x100000000000B17217F7D1D351A389D41) >> 128; + if (x & 0x800000000000000000000 > 0) result = (result * 0x10000000000058B90BFBE8E8B2D3D4EDF) >> 128; + if (x & 0x400000000000000000000 > 0) result = (result * 0x1000000000002C5C85FDF4741BEA6E77F) >> 128; + if (x & 0x200000000000000000000 > 0) result = (result * 0x100000000000162E42FEFA39FE95583C3) >> 128; + if (x & 0x100000000000000000000 > 0) result = (result * 0x1000000000000B17217F7D1CFB72B45E3) >> 128; + if (x & 0x80000000000000000000 > 0) result = (result * 0x100000000000058B90BFBE8E7CC35C3F2) >> 128; + if (x & 0x40000000000000000000 > 0) result = (result * 0x10000000000002C5C85FDF473E242EA39) >> 128; + if (x & 0x20000000000000000000 > 0) result = (result * 0x1000000000000162E42FEFA39F02B772C) >> 128; + if (x & 0x10000000000000000000 > 0) result = (result * 0x10000000000000B17217F7D1CF7D83C1A) >> 128; + if (x & 0x8000000000000000000 > 0) result = (result * 0x1000000000000058B90BFBE8E7BDCBE2E) >> 128; + if (x & 0x4000000000000000000 > 0) result = (result * 0x100000000000002C5C85FDF473DEA871F) >> 128; + if (x & 0x2000000000000000000 > 0) result = (result * 0x10000000000000162E42FEFA39EF44D92) >> 128; + if (x & 0x1000000000000000000 > 0) result = (result * 0x100000000000000B17217F7D1CF79E949) >> 128; + if (x & 0x800000000000000000 > 0) result = (result * 0x10000000000000058B90BFBE8E7BCE545) >> 128; + if (x & 0x400000000000000000 > 0) result = (result * 0x1000000000000002C5C85FDF473DE6ECA) >> 128; + if (x & 0x200000000000000000 > 0) result = (result * 0x100000000000000162E42FEFA39EF366F) >> 128; + if (x & 0x100000000000000000 > 0) result = (result * 0x1000000000000000B17217F7D1CF79AFA) >> 128; + if (x & 0x80000000000000000 > 0) result = (result * 0x100000000000000058B90BFBE8E7BCD6E) >> 128; + if (x & 0x40000000000000000 > 0) result = (result * 0x10000000000000002C5C85FDF473DE6B3) >> 128; + if (x & 0x20000000000000000 > 0) result = (result * 0x1000000000000000162E42FEFA39EF359) >> 128; + if (x & 0x10000000000000000 > 0) result = (result * 0x10000000000000000B17217F7D1CF79AC) >> 128; + + // We do two things at the same time below: + // + // 1. Multiply the result by 2^n + 1, where 2^n is the integer part and 1 is an extra bit to account + // for the fact that we initially set the result to 0.5 We implement this by subtracting from 127 + // instead of 128. + // 2. Convert the result to the unsigned 60.18-decimal fixed-point format. + // + // This works because result * SCALE * 2^ip / 2^127 = result * SCALE / 2^(127 - ip), where ip is the integer + // part and SCALE / 2^128 is what converts the result to our unsigned fixed-point format. + result *= SCALE; + result >>= (127 - (x >> 128)); +// } + } + + /// @notice Finds the zero-based index of the first one in the binary representation of x. + /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set + /// @param x The uint256 number for which to find the index of the most significant bit. + /// @return msb The index of the most significant bit as an uint256. + function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) { + if (x >= 2**128) { + x >>= 128; + msb += 128; + } + if (x >= 2**64) { + x >>= 64; + msb += 64; + } + if (x >= 2**32) { + x >>= 32; + msb += 32; + } + if (x >= 2**16) { + x >>= 16; + msb += 16; + } + if (x >= 2**8) { + x >>= 8; + msb += 8; + } + if (x >= 2**4) { + x >>= 4; + msb += 4; + } + if (x >= 2**2) { + x >>= 2; + msb += 2; + } + if (x >= 2**1) { + // No need to shift x any more. + msb += 1; + } + } + + /// @notice Calculates floor(x*y÷denominator) with full precision. + /// + /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv. + /// + /// Requirements: + /// - The denominator cannot be zero. + /// - The result must fit within uint256. + /// + /// Caveats: + /// - This function does not work with fixed-point numbers. + /// + /// @param x The multiplicand as an uint256. + /// @param y The multiplier as an uint256. + /// @param denominator The divisor as an uint256. + /// @return result The result as an uint256. + function mulDiv( + uint256 x, + uint256 y, + uint256 denominator + ) internal pure returns (uint256 result) { + // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2**256 and mod 2**256 - 1, then use + // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 + // variables such that product = prod1 * 2**256 + prod0. + uint256 prod0; // Least significant 256 bits of the product + uint256 prod1; // Most significant 256 bits of the product + assembly { + let mm := mulmod(x, y, not(0)) + prod0 := mul(x, y) + prod1 := sub(sub(mm, prod0), lt(mm, prod0)) + } + + // Handle non-overflow cases, 256 by 256 division + if (prod1 == 0) { + require(denominator > 0); + assembly { + result := div(prod0, denominator) + } + return result; + } + + // Make sure the result is less than 2**256. Also prevents denominator == 0. + require(denominator > prod1); + + /////////////////////////////////////////////// + // 512 by 256 division. + /////////////////////////////////////////////// + + // Make division exact by subtracting the remainder from [prod1 prod0]. + uint256 remainder; + assembly { + // Compute remainder using mulmod. + remainder := mulmod(x, y, denominator) + + // Subtract 256 bit number from 512 bit number + prod1 := sub(prod1, gt(remainder, prod0)) + prod0 := sub(prod0, remainder) + } + + // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. + // See https://cs.stackexchange.com/q/138556/92363. +// unchecked { + // Does not overflow because the denominator cannot be zero at this stage in the function. + uint256 lpotdod = denominator & (~denominator + 1); + assembly { + // Divide denominator by lpotdod. + denominator := div(denominator, lpotdod) + + // Divide [prod1 prod0] by lpotdod. + prod0 := div(prod0, lpotdod) + + // Flip lpotdod such that it is 2**256 / lpotdod. If lpotdod is zero, then it becomes one. + lpotdod := add(div(sub(0, lpotdod), lpotdod), 1) + } + + // Shift in bits from prod1 into prod0. + prod0 |= prod1 * lpotdod; + + // Invert denominator mod 2**256. Now that denominator is an odd number, it has an inverse modulo 2**256 such + // that denominator * inv = 1 mod 2**256. Compute the inverse by starting with a seed that is correct for + // four bits. That is, denominator * inv = 1 mod 2**4 + uint256 inverse = (3 * denominator) ^ 2; + + // Now use Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works + // in modular arithmetic, doubling the correct bits in each step. + inverse *= 2 - denominator * inverse; // inverse mod 2**8 + inverse *= 2 - denominator * inverse; // inverse mod 2**16 + inverse *= 2 - denominator * inverse; // inverse mod 2**32 + inverse *= 2 - denominator * inverse; // inverse mod 2**64 + inverse *= 2 - denominator * inverse; // inverse mod 2**128 + inverse *= 2 - denominator * inverse; // inverse mod 2**256 + + // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. + // This will give us the correct result modulo 2**256. Since the precoditions guarantee that the outcome is + // less than 2**256, this is the final result. We don't need to compute the high bits of the result and prod1 + // is no longer required. + result = prod0 * inverse; + return result; +// } + } + + /// @notice Calculates floor(x*y÷1e18) with full precision. + /// + /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the + /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of + /// being rounded to 1e-18. See "Listing 6" and text above it at https://accu.org/index.php/journals/1717. + /// + /// Requirements: + /// - The result must fit within uint256. + /// + /// Caveats: + /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMathCommon.mulDiv" to understand how this works. + /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two queations: + /// 1. x * y = type(uint256).max * SCALE + /// 2. (x * y) % SCALE >= SCALE / 2 + /// + /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number. + /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number. + /// @return result The result as an unsigned 60.18-decimal fixed-point number. + function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) { + uint256 prod0; + uint256 prod1; + assembly { + let mm := mulmod(x, y, not(0)) + prod0 := mul(x, y) + prod1 := sub(sub(mm, prod0), lt(mm, prod0)) + } + + uint256 remainder; + uint256 roundUpUnit; + assembly { + remainder := mulmod(x, y, SCALE) + roundUpUnit := gt(remainder, 499999999999999999) + } + + if (prod1 == 0) { +// unchecked { + result = (prod0 / SCALE) + roundUpUnit; + return result; +// } + } + + require(SCALE > prod1); + + assembly { + result := add( + mul( + or( + div(sub(prod0, remainder), SCALE_LPOTD), + mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1)) + ), + SCALE_INVERSE + ), + roundUpUnit + ) + } + } + + /// @notice Calculates floor(x*y÷denominator) with full precision. + /// + /// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately. + /// + /// Requirements: + /// - None of the inputs can be type(int256).min. + /// - The result must fit within int256. + /// + /// @param x The multiplicand as an int256. + /// @param y The multiplier as an int256. + /// @param denominator The divisor as an int256. + /// @return result The result as an int256. + function mulDivSigned( + int256 x, + int256 y, + int256 denominator + ) internal pure returns (int256 result) { + require(x > type(int256).min); + require(y > type(int256).min); + require(denominator > type(int256).min); + + // Get hold of the absolute values of x, y and the denominator. + uint256 ax; + uint256 ay; + uint256 ad; +// unchecked { + ax = x < 0 ? uint256(-x) : uint256(x); + ay = y < 0 ? uint256(-y) : uint256(y); + ad = denominator < 0 ? uint256(-denominator) : uint256(denominator); +// } + + // Compute the absolute value of (x*y)÷denominator. The result must fit within int256. + uint256 resultUnsigned = mulDiv(ax, ay, ad); + require(resultUnsigned <= uint256(type(int256).max)); + + // Get the signs of x, y and the denominator. + uint256 sx; + uint256 sy; + uint256 sd; + assembly { + sx := sgt(x, sub(0, 1)) + sy := sgt(y, sub(0, 1)) + sd := sgt(denominator, sub(0, 1)) + } + + // XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs. + // If yes, the result should be negative. + result = sx ^ sy ^ sd == 0 ? -int256(resultUnsigned) : int256(resultUnsigned); + } + + /// @notice Calculates the square root of x, rounding down. + /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. + /// + /// Caveats: + /// - This function does not work with fixed-point numbers. + /// + /// @param x The uint256 number for which to calculate the square root. + /// @return result The result as an uint256. + function sqrt(uint256 x) internal pure returns (uint256 result) { + if (x == 0) { + return 0; + } + + // Set the initial guess to the closest power of two that is higher than x. + uint256 xAux = uint256(x); + result = 1; + if (xAux >= 0x100000000000000000000000000000000) { + xAux >>= 128; + result <<= 64; + } + if (xAux >= 0x10000000000000000) { + xAux >>= 64; + result <<= 32; + } + if (xAux >= 0x100000000) { + xAux >>= 32; + result <<= 16; + } + if (xAux >= 0x10000) { + xAux >>= 16; + result <<= 8; + } + if (xAux >= 0x100) { + xAux >>= 8; + result <<= 4; + } + if (xAux >= 0x10) { + xAux >>= 4; + result <<= 2; + } + if (xAux >= 0x8) { + result <<= 1; + } + + // The operations can never overflow because the result is max 2^127 when it enters this block. +// unchecked { + result = (result + x / result) >> 1; + result = (result + x / result) >> 1; + result = (result + x / result) >> 1; + result = (result + x / result) >> 1; + result = (result + x / result) >> 1; + result = (result + x / result) >> 1; + result = (result + x / result) >> 1; // Seven iterations should be enough + uint256 roundedDownResult = x / result; + return result >= roundedDownResult ? roundedDownResult : result; +// } + } +} diff --git a/contracts/lib/prb-math/PRBMathSD59x18.sol b/contracts/lib/prb-math/PRBMathSD59x18.sol new file mode 100644 index 00000000..ae665b9a --- /dev/null +++ b/contracts/lib/prb-math/PRBMathSD59x18.sol @@ -0,0 +1,632 @@ +// SPDX-License-Identifier: WTFPL +pragma solidity >=0.6.0; + +import "./PRBMathCommon.sol"; + +/// @title PRBMathSD59x18 +/// @author Paul Razvan Berg +/// @notice Smart contract library for advanced fixed-point math. It works with int256 numbers considered to have 18 +/// trailing decimals. We call this number representation signed 59.18-decimal fixed-point, since the numbers can have +/// a sign and there can be up to 59 digits in the integer part and up to 18 decimals in the fractional part. The numbers +/// are bound by the minimum and the maximum values permitted by the Solidity type int256. +library PRBMathSD59x18 { + /// @dev log2(e) as a signed 59.18-decimal fixed-point number. + int256 internal constant LOG2_E = 1442695040888963407; + + /// @dev Half the SCALE number. + int256 internal constant HALF_SCALE = 5e17; + + /// @dev The maximum value a signed 59.18-decimal fixed-point number can have. + int256 internal constant MAX_SD59x18 = 57896044618658097711785492504343953926634992332820282019728792003956564819967; + + /// @dev The maximum whole value a signed 59.18-decimal fixed-point number can have. + int256 internal constant MAX_WHOLE_SD59x18 = 57896044618658097711785492504343953926634992332820282019728000000000000000000; + + /// @dev The minimum value a signed 59.18-decimal fixed-point number can have. + int256 internal constant MIN_SD59x18 = -57896044618658097711785492504343953926634992332820282019728792003956564819968; + + /// @dev The minimum whole value a signed 59.18-decimal fixed-point number can have. + int256 internal constant MIN_WHOLE_SD59x18 = -57896044618658097711785492504343953926634992332820282019728000000000000000000; + + /// @dev How many trailing decimals can be represented. + int256 internal constant SCALE = 1e18; + + /// INTERNAL FUNCTIONS /// + + /// @notice Calculate the absolute value of x. + /// + /// @dev Requirements: + /// - x must be greater than MIN_SD59x18. + /// + /// @param x The number to calculate the absolute value for. + /// @param result The absolute value of x. + function abs(int256 x) internal pure returns (int256 result) { +// unchecked { + require(x > MIN_SD59x18); + result = x < 0 ? -x : x; +// } + } + + /// @notice Calculates arithmetic average of x and y, rounding down. + /// @param x The first operand as a signed 59.18-decimal fixed-point number. + /// @param y The second operand as a signed 59.18-decimal fixed-point number. + /// @return result The arithmetic average as a signed 59.18-decimal fixed-point number. + function avg(int256 x, int256 y) internal pure returns (int256 result) { + // The operations can never overflow. +// unchecked { + // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need + // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice. + result = (x >> 1) + (y >> 1) + (x & y & 1); +// } + } + + /// @notice Yields the least greatest signed 59.18 decimal fixed-point number greater than or equal to x. + /// + /// @dev Optimised for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts. + /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. + /// + /// Requirements: + /// - x must be less than or equal to MAX_WHOLE_SD59x18. + /// + /// @param x The signed 59.18-decimal fixed-point number to ceil. + /// @param result The least integer greater than or equal to x, as a signed 58.18-decimal fixed-point number. + function ceil(int256 x) internal pure returns (int256 result) { + require(x <= MAX_WHOLE_SD59x18); +// unchecked { + int256 remainder = x % SCALE; + if (remainder == 0) { + result = x; + } else { + // Solidity uses C fmod style, which returns a modulus with the same sign as x. + result = x - remainder; + if (x > 0) { + result += SCALE; + } + } +// } + } + + /// @notice Divides two signed 59.18-decimal fixed-point numbers, returning a new signed 59.18-decimal fixed-point number. + /// + /// @dev Variant of "mulDiv" that works with signed numbers. Works by computing the signs and the absolute values separately. + /// + /// Requirements: + /// - All from "PRBMathCommon.mulDiv". + /// - None of the inputs can be type(int256).min. + /// - y cannot be zero. + /// - The result must fit within int256. + /// + /// Caveats: + /// - All from "PRBMathCommon.mulDiv". + /// + /// @param x The numerator as a signed 59.18-decimal fixed-point number. + /// @param y The denominator as a signed 59.18-decimal fixed-point number. + /// @param result The quotient as a signed 59.18-decimal fixed-point number. + function div(int256 x, int256 y) internal pure returns (int256 result) { + require(x > type(int256).min); + require(y > type(int256).min); + + // Get hold of the absolute values of x and y. + uint256 ax; + uint256 ay; +// unchecked { + ax = x < 0 ? uint256(-x) : uint256(x); + ay = y < 0 ? uint256(-y) : uint256(y); +// } + + // Compute the absolute value of (x*SCALE)÷y. The result must fit within int256. + uint256 resultUnsigned = PRBMathCommon.mulDiv(ax, uint256(SCALE), ay); + require(resultUnsigned <= uint256(type(int256).max)); + + // Get the signs of x and y. + uint256 sx; + uint256 sy; + assembly { + sx := sgt(x, sub(0, 1)) + sy := sgt(y, sub(0, 1)) + } + + // XOR over sx and sy. This is basically checking whether the inputs have the same sign. If yes, the result + // should be positive. Otherwise, it should be negative. + result = sx ^ sy == 1 ? -int256(resultUnsigned) : int256(resultUnsigned); + } + + /// @notice Returns Euler's number as a signed 59.18-decimal fixed-point number. + /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant). + function e() internal pure returns (int256 result) { + result = 2718281828459045235; + } + + /// @notice Calculates the natural exponent of x. + /// + /// @dev Based on the insight that e^x = 2^(x * log2(e)). + /// + /// Requirements: + /// - All from "log2". + /// - x must be less than 88.722839111672999628. + /// + /// Caveats: + /// - All from "exp2". + /// - For any x less than -41.446531673892822322, the result is zero. + /// + /// @param x The exponent as a signed 59.18-decimal fixed-point number. + /// @return result The result as a signed 59.18-decimal fixed-point number. + function exp(int256 x) internal pure returns (int256 result) { + // Without this check, the value passed to "exp2" would be less than -59.794705707972522261. + if (x < -41446531673892822322) { + return 0; + } + + // Without this check, the value passed to "exp2" would be greater than 128e18. + require(x < 88722839111672999628); + + // Do the fixed-point multiplication inline to save gas. +// unchecked { + int256 doubleScaleProduct = x * LOG2_E; + result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE); +// } + } + + /// @notice Calculates the binary exponent of x using the binary fraction method. + /// + /// @dev See https://ethereum.stackexchange.com/q/79903/24693. + /// + /// Requirements: + /// - x must be 128e18 or less. + /// - The result must fit within MAX_SD59x18. + /// + /// Caveats: + /// - For any x less than -59.794705707972522261, the result is zero. + /// + /// @param x The exponent as a signed 59.18-decimal fixed-point number. + /// @return result The result as a signed 59.18-decimal fixed-point number. + function exp2(int256 x) internal pure returns (int256 result) { + // This works because 2^(-x) = 1/2^x. + if (x < 0) { + // 2**59.794705707972522262 is the maximum number whose inverse does not truncate down to zero. + if (x < -59794705707972522261) { + return 0; + } + + // Do the fixed-point inversion inline to save gas. The numerator is SCALE * SCALE. +// unchecked { result = 1e36 / exp2(-x); } + result = 1e36 / exp2(-x); + } else { + // 2**128 doesn't fit within the 128.128-bit fixed-point representation. + require(x < 128e18); + +// unchecked { + // Convert x to the 128.128-bit fixed-point format. + uint256 x128x128 = (uint256(x) << 128) / uint256(SCALE); + + // Safe to convert the result to int256 directly because the maximum input allowed is 128e18. + result = int256(PRBMathCommon.exp2(x128x128)); +// } + } + } + + /// @notice Yields the greatest signed 59.18 decimal fixed-point number less than or equal to x. + /// + /// @dev Optimised for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts. + /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. + /// + /// Requirements: + /// - x must be greater than or equal to MIN_WHOLE_SD59x18. + /// + /// @param x The signed 59.18-decimal fixed-point number to floor. + /// @param result The greatest integer less than or equal to x, as a signed 58.18-decimal fixed-point number. + function floor(int256 x) internal pure returns (int256 result) { + require(x >= MIN_WHOLE_SD59x18); +// unchecked { + int256 remainder = x % SCALE; + if (remainder == 0) { + result = x; + } else { + // Solidity uses C fmod style, which returns a modulus with the same sign as x. + result = x - remainder; + if (x < 0) { + result -= SCALE; + } + } +// } + } + + /// @notice Yields the excess beyond the floor of x for positive numbers and the part of the number to the right + /// of the radix point for negative numbers. + /// @dev Based on the odd function definition. https://en.wikipedia.org/wiki/Fractional_part + /// @param x The signed 59.18-decimal fixed-point number to get the fractional part of. + /// @param result The fractional part of x as a signed 59.18-decimal fixed-point number. + function frac(int256 x) internal pure returns (int256 result) { +// unchecked { result = x % SCALE; } + result = x % SCALE; + } + + /// @notice Converts a number from basic integer form to signed 59.18-decimal fixed-point representation. + /// + /// @dev Requirements: + /// - x must be greater than or equal to MIN_SD59x18 divided by SCALE. + /// - x must be less than or equal to MAX_SD59x18 divided by SCALE. + /// + /// @param x The basic integer to convert. + /// @param result The same number in signed 59.18-decimal fixed-point representation. + function fromInt(int256 x) internal pure returns (int256 result) { +// unchecked { + require(x >= MIN_SD59x18 / SCALE && x <= MAX_SD59x18 / SCALE); + result = x * SCALE; +// } + } + + /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down. + /// + /// @dev Requirements: + /// - x * y must fit within MAX_SD59x18, lest it overflows. + /// - x * y cannot be negative. + /// + /// @param x The first operand as a signed 59.18-decimal fixed-point number. + /// @param y The second operand as a signed 59.18-decimal fixed-point number. + /// @return result The result as a signed 59.18-decimal fixed-point number. + function gm(int256 x, int256 y) internal pure returns (int256 result) { + if (x == 0) { + return 0; + } + +// unchecked { + // Checking for overflow this way is faster than letting Solidity do it. + int256 xy = x * y; + require(xy / x == y); + + // The product cannot be negative. + require(xy >= 0); + + // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE + // during multiplication. See the comments within the "sqrt" function. + result = int256(PRBMathCommon.sqrt(uint256(xy))); +// } + } + + /// @notice Calculates 1 / x, rounding towards zero. + /// + /// @dev Requirements: + /// - x cannot be zero. + /// + /// @param x The signed 59.18-decimal fixed-point number for which to calculate the inverse. + /// @return result The inverse as a signed 59.18-decimal fixed-point number. + function inv(int256 x) internal pure returns (int256 result) { +// unchecked { + // 1e36 is SCALE * SCALE. + result = 1e36 / x; +// } + } + + /// @notice Calculates the natural logarithm of x. + /// + /// @dev Based on the insight that ln(x) = log2(x) / log2(e). + /// + /// Requirements: + /// - All from "log2". + /// + /// Caveats: + /// - All from "log2". + /// - This doesn't return exactly 1 for 2718281828459045235, for that we would need more fine-grained precision. + /// + /// @param x The signed 59.18-decimal fixed-point number for which to calculate the natural logarithm. + /// @return result The natural logarithm as a signed 59.18-decimal fixed-point number. + function ln(int256 x) internal pure returns (int256 result) { + // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x) + // can return is 195205294292027477728. +// unchecked { result = (log2(x) * SCALE) / LOG2_E; } + result = (log2(x) * SCALE) / LOG2_E; + } + + /// @notice Calculates the common logarithm of x. + /// + /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common + /// logarithm based on the insight that log10(x) = log2(x) / log2(10). + /// + /// Requirements: + /// - All from "log2". + /// + /// Caveats: + /// - All from "log2". + /// + /// @param x The signed 59.18-decimal fixed-point number for which to calculate the common logarithm. + /// @return result The common logarithm as a signed 59.18-decimal fixed-point number. + function log10(int256 x) internal pure returns (int256 result) { + require(x > 0); + + // Note that the "mul" in this block is the assembly mul operation, not the "mul" function defined in this contract. + // prettier-ignore + assembly { + switch x + case 1 { result := mul(SCALE, sub(0, 18)) } + case 10 { result := mul(SCALE, sub(1, 18)) } + case 100 { result := mul(SCALE, sub(2, 18)) } + case 1000 { result := mul(SCALE, sub(3, 18)) } + case 10000 { result := mul(SCALE, sub(4, 18)) } + case 100000 { result := mul(SCALE, sub(5, 18)) } + case 1000000 { result := mul(SCALE, sub(6, 18)) } + case 10000000 { result := mul(SCALE, sub(7, 18)) } + case 100000000 { result := mul(SCALE, sub(8, 18)) } + case 1000000000 { result := mul(SCALE, sub(9, 18)) } + case 10000000000 { result := mul(SCALE, sub(10, 18)) } + case 100000000000 { result := mul(SCALE, sub(11, 18)) } + case 1000000000000 { result := mul(SCALE, sub(12, 18)) } + case 10000000000000 { result := mul(SCALE, sub(13, 18)) } + case 100000000000000 { result := mul(SCALE, sub(14, 18)) } + case 1000000000000000 { result := mul(SCALE, sub(15, 18)) } + case 10000000000000000 { result := mul(SCALE, sub(16, 18)) } + case 100000000000000000 { result := mul(SCALE, sub(17, 18)) } + case 1000000000000000000 { result := 0 } + case 10000000000000000000 { result := SCALE } + case 100000000000000000000 { result := mul(SCALE, 2) } + case 1000000000000000000000 { result := mul(SCALE, 3) } + case 10000000000000000000000 { result := mul(SCALE, 4) } + case 100000000000000000000000 { result := mul(SCALE, 5) } + case 1000000000000000000000000 { result := mul(SCALE, 6) } + case 10000000000000000000000000 { result := mul(SCALE, 7) } + case 100000000000000000000000000 { result := mul(SCALE, 8) } + case 1000000000000000000000000000 { result := mul(SCALE, 9) } + case 10000000000000000000000000000 { result := mul(SCALE, 10) } + case 100000000000000000000000000000 { result := mul(SCALE, 11) } + case 1000000000000000000000000000000 { result := mul(SCALE, 12) } + case 10000000000000000000000000000000 { result := mul(SCALE, 13) } + case 100000000000000000000000000000000 { result := mul(SCALE, 14) } + case 1000000000000000000000000000000000 { result := mul(SCALE, 15) } + case 10000000000000000000000000000000000 { result := mul(SCALE, 16) } + case 100000000000000000000000000000000000 { result := mul(SCALE, 17) } + case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) } + case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) } + case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) } + case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) } + case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) } + case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) } + case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) } + case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) } + case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) } + case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) } + case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) } + case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) } + case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) } + case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) } + case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) } + case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) } + case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) } + case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) } + case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) } + case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) } + case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) } + case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) } + case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) } + case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) } + case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) } + case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) } + case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) } + case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) } + case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) } + case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) } + case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) } + case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) } + case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) } + case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) } + case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) } + case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) } + case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) } + case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) } + case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) } + case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) } + case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) } + default { + result := MAX_SD59x18 + } + } + + if (result == MAX_SD59x18) { + // Do the fixed-point division inline to save gas. The denominator is log2(10). +// unchecked { result = (log2(x) * SCALE) / 332192809488736234; } + result = (log2(x) * SCALE) / 332192809488736234; + } + } + + /// @notice Calculates the binary logarithm of x. + /// + /// @dev Based on the iterative approximation algorithm. + /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation + /// + /// Requirements: + /// - x must be greater than zero. + /// + /// Caveats: + /// - The results are not perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation. + /// + /// @param x The signed 59.18-decimal fixed-point number for which to calculate the binary logarithm. + /// @return result The binary logarithm as a signed 59.18-decimal fixed-point number. + function log2(int256 x) internal pure returns (int256 result) { + require(x > 0); +// unchecked { + // This works because log2(x) = -log2(1/x). + int256 sign; + if (x >= SCALE) { + sign = 1; + } else { + sign = -1; + // Do the fixed-point inversion inline to save gas. The numerator is SCALE * SCALE. + assembly { + x := div(1000000000000000000000000000000000000, x) + } + } + + // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n). + uint256 n = PRBMathCommon.mostSignificantBit(uint256(x / SCALE)); + + // The integer part of the logarithm as a signed 59.18-decimal fixed-point number. The operation can't overflow + // because n is maximum 255, SCALE is 1e18 and sign is either 1 or -1. + result = int256(n) * SCALE; + + // This is y = x * 2^(-n). + int256 y = x >> n; + + // If y = 1, the fractional part is zero. + if (y == SCALE) { + return result * sign; + } + + // Calculate the fractional part via the iterative approximation. + // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster. + for (int256 delta = int256(HALF_SCALE); delta > 0; delta >>= 1) { + y = (y * y) / SCALE; + + // Is y^2 > 2 and so in the range [2,4)? + if (y >= 2 * SCALE) { + // Add the 2^(-m) factor to the logarithm. + result += delta; + + // Corresponds to z/2 on Wikipedia. + y >>= 1; + } + } + result *= sign; +// } + } + + /// @notice Multiplies two signed 59.18-decimal fixed-point numbers together, returning a new signed 59.18-decimal + /// fixed-point number. + /// + /// @dev Variant of "mulDiv" that works with signed numbers and employs constant folding, i.e. the denominator is + /// alawys 1e18. + /// + /// Requirements: + /// - All from "PRBMathCommon.mulDivFixedPoint". + /// - The result must fit within MAX_SD59x18. + /// + /// Caveats: + /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMathCommon.mulDiv" to understand how this works. + /// + /// @param x The multiplicand as a signed 59.18-decimal fixed-point number. + /// @param y The multiplier as a signed 59.18-decimal fixed-point number. + /// @return result The result as a signed 59.18-decimal fixed-point number. + function mul(int256 x, int256 y) internal pure returns (int256 result) { + require(x > MIN_SD59x18); + require(y > MIN_SD59x18); + +// unchecked { + uint256 ax; + uint256 ay; + ax = x < 0 ? uint256(-x) : uint256(x); + ay = y < 0 ? uint256(-y) : uint256(y); + + uint256 resultUnsigned = PRBMathCommon.mulDivFixedPoint(ax, ay); + require(resultUnsigned <= uint256(MAX_SD59x18)); + + uint256 sx; + uint256 sy; + assembly { + sx := sgt(x, sub(0, 1)) + sy := sgt(y, sub(0, 1)) + } + result = sx ^ sy == 1 ? -int256(resultUnsigned) : int256(resultUnsigned); +// } + } + + /// @notice Returns PI as a signed 59.18-decimal fixed-point number. + function pi() internal pure returns (int256 result) { + result = 3141592653589793238; + } + + /// @notice Raises x to the power of y. + /// + /// @dev Based on the insight that x^y = 2^(log2(x) * y). + /// + /// Requirements: + /// - All from "exp2", "log2" and "mul". + /// - z cannot be zero. + /// + /// Caveats: + /// - All from "exp2", "log2" and "mul". + /// - Assumes 0^0 is 1. + /// + /// @param x Number to raise to given power y, as a signed 59.18-decimal fixed-point number. + /// @param y Exponent to raise x to, as a signed 59.18-decimal fixed-point number. + /// @return result x raised to power y, as a signed 59.18-decimal fixed-point number. + function pow(int256 x, int256 y) internal pure returns (int256 result) { + if (x == 0) { + return y == 0 ? SCALE : int256(0); + } else { + result = exp2(mul(log2(x), y)); + } + } + + /// @notice Raises x (signed 59.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the + /// famous algorithm "exponentiation by squaring". + /// + /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring + /// + /// Requirements: + /// - All from "abs" and "PRBMathCommon.mulDivFixedPoint". + /// - The result must fit within MAX_SD59x18. + /// + /// Caveats: + /// - All from "PRBMathCommon.mulDivFixedPoint". + /// - Assumes 0^0 is 1. + /// + /// @param x The base as a signed 59.18-decimal fixed-point number. + /// @param y The exponent as an uint256. + /// @return result The result as a signed 59.18-decimal fixed-point number. + function powu(int256 x, uint256 y) internal pure returns (int256 result) { + uint256 absX = uint256(abs(x)); + + // Calculate the first iteration of the loop in advance. + uint256 absResult = y & 1 > 0 ? absX : uint256(SCALE); + + // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster. + for (y >>= 1; y > 0; y >>= 1) { + absX = PRBMathCommon.mulDivFixedPoint(absX, absX); + + // Equivalent to "y % 2 == 1" but faster. + if (y & 1 > 0) { + absResult = PRBMathCommon.mulDivFixedPoint(absResult, absX); + } + } + + // The result must fit within the 59.18-decimal fixed-point representation. + require(absResult <= uint256(MAX_SD59x18)); + + // Is the base negative and the exponent an odd number? + bool isNegative = x < 0 && y & 1 == 1; + result = isNegative ? -int256(absResult) : int256(absResult); + } + + /// @notice Returns 1 as a signed 59.18-decimal fixed-point number. + function scale() internal pure returns (int256 result) { + result = SCALE; + } + + /// @notice Calculates the square root of x, rounding down. + /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. + /// + /// Requirements: + /// - x cannot be negative. + /// - x must be less than MAX_SD59x18 / SCALE. + /// + /// Caveats: + /// - The maximum fixed-point number permitted is 57896044618658097711785492504343953926634.992332820282019729. + /// + /// @param x The signed 59.18-decimal fixed-point number for which to calculate the square root. + /// @return result The result as a signed 59.18-decimal fixed-point . + function sqrt(int256 x) internal pure returns (int256 result) { + require(x >= 0); + require(x < 57896044618658097711785492504343953926634992332820282019729); +// unchecked { + // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two signed + // 59.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root). + result = int256(PRBMathCommon.sqrt(uint256(x * SCALE))); +// } + } + + /// @notice Converts a signed 59.18-decimal fixed-point number to basic integer form, rounding down in the process. + /// @param x The signed 59.18-decimal fixed-point number to convert. + /// @return result The same number in basic integer form. + function toInt(int256 x) internal pure returns (int256 result) { + result = x / SCALE; +// unchecked { result = x / SCALE; } + } +} diff --git a/contracts/lib/prb-math/PRBMathUD60x18.sol b/contracts/lib/prb-math/PRBMathUD60x18.sol new file mode 100644 index 00000000..21c8d245 --- /dev/null +++ b/contracts/lib/prb-math/PRBMathUD60x18.sol @@ -0,0 +1,483 @@ +// SPDX-License-Identifier: WTFPL +pragma solidity >=0.6.0; + +import "./PRBMathCommon.sol"; + +/// @title PRBMathUD60x18 +/// @author Paul Razvan Berg +/// @notice Smart contract library for advanced fixed-point math. It works with uint256 numbers considered to have 18 +/// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60 +/// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the +/// maximum values permitted by the Solidity type uint256. +library PRBMathUD60x18 { + /// @dev Half the SCALE number. + uint256 internal constant HALF_SCALE = 5e17; + + /// @dev log2(e) as an unsigned 60.18-decimal fixed-point number. + uint256 internal constant LOG2_E = 1442695040888963407; + + /// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have. + uint256 internal constant MAX_UD60x18 = 115792089237316195423570985008687907853269984665640564039457584007913129639935; + + /// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have. + uint256 internal constant MAX_WHOLE_UD60x18 = 115792089237316195423570985008687907853269984665640564039457000000000000000000; + + /// @dev How many trailing decimals can be represented. + uint256 internal constant SCALE = 1e18; + + /// @notice Calculates arithmetic average of x and y, rounding down. + /// @param x The first operand as an unsigned 60.18-decimal fixed-point number. + /// @param y The second operand as an unsigned 60.18-decimal fixed-point number. + /// @return result The arithmetic average as an usigned 60.18-decimal fixed-point number. + function avg(uint256 x, uint256 y) internal pure returns (uint256 result) { + // The operations can never overflow. +// unchecked { + // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need + // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice. + result = (x >> 1) + (y >> 1) + (x & y & 1); +// } + } + + /// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x. + /// + /// @dev Optimised for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts. + /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. + /// + /// Requirements: + /// - x must be less than or equal to MAX_WHOLE_UD60x18. + /// + /// @param x The unsigned 60.18-decimal fixed-point number to ceil. + /// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number. + function ceil(uint256 x) internal pure returns (uint256 result) { + require(x <= MAX_WHOLE_UD60x18); + assembly { + // Equivalent to "x % SCALE" but faster. + let remainder := mod(x, SCALE) + + // Equivalent to "SCALE - remainder" but faster. + let delta := sub(SCALE, remainder) + + // Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster. + result := add(x, mul(delta, gt(remainder, 0))) + } + } + + /// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number. + /// + /// @dev Uses mulDiv to enable overflow-safe multiplication and division. + /// + /// Requirements: + /// - y cannot be zero. + /// + /// @param x The numerator as an unsigned 60.18-decimal fixed-point number. + /// @param y The denominator as an unsigned 60.18-decimal fixed-point number. + /// @param result The quotient as an unsigned 60.18-decimal fixed-point number. + function div(uint256 x, uint256 y) internal pure returns (uint256 result) { + result = PRBMathCommon.mulDiv(x, SCALE, y); + } + + /// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number. + /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant). + function e() internal pure returns (uint256 result) { + result = 2718281828459045235; + } + + /// @notice Calculates the natural exponent of x. + /// + /// @dev Based on the insight that e^x = 2^(x * log2(e)). + /// + /// Requirements: + /// - All from "log2". + /// - x must be less than 88.722839111672999628. + /// + /// @param x The exponent as an unsigned 60.18-decimal fixed-point number. + /// @return result The result as an unsigned 60.18-decimal fixed-point number. + function exp(uint256 x) internal pure returns (uint256 result) { + // Without this check, the value passed to "exp2" would be greater than 128e18. + require(x < 88722839111672999628); + + // Do the fixed-point multiplication inline to save gas. +// unchecked { + uint256 doubleScaleProduct = x * LOG2_E; + result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE); +// } + } + + /// @notice Calculates the binary exponent of x using the binary fraction method. + /// + /// @dev See https://ethereum.stackexchange.com/q/79903/24693. + /// + /// Requirements: + /// - x must be 128e18 or less. + /// - The result must fit within MAX_UD60x18. + /// + /// @param x The exponent as an unsigned 60.18-decimal fixed-point number. + /// @return result The result as an unsigned 60.18-decimal fixed-point number. + function exp2(uint256 x) internal pure returns (uint256 result) { + // 2**128 doesn't fit within the 128.128-bit format used internally in this function. + require(x < 128e18); + +// unchecked { + // Convert x to the 128.128-bit fixed-point format. + uint256 x128x128 = (x << 128) / SCALE; + + // Pass x to the PRBMathCommon.exp2 function, which uses the 128.128-bit fixed-point number representation. + result = PRBMathCommon.exp2(x128x128); +// } + } + + /// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x. + /// @dev Optimised for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts. + /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. + /// @param x The unsigned 60.18-decimal fixed-point number to floor. + /// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number. + function floor(uint256 x) internal pure returns (uint256 result) { + assembly { + // Equivalent to "x % SCALE" but faster. + let remainder := mod(x, SCALE) + + // Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster. + result := sub(x, mul(remainder, gt(remainder, 0))) + } + } + + /// @notice Yields the excess beyond the floor of x. + /// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part. + /// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of. + /// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number. + function frac(uint256 x) internal pure returns (uint256 result) { + assembly { + result := mod(x, SCALE) + } + } + + /// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation. + /// + /// @dev Requirements: + /// - x must be less than or equal to MAX_UD60x18 divided by SCALE. + /// + /// @param x The basic integer to convert. + /// @param result The same number in unsigned 60.18-decimal fixed-point representation. + function fromUint(uint256 x) internal pure returns (uint256 result) { +// unchecked { + require(x <= MAX_UD60x18 / SCALE); + result = x * SCALE; +// } + } + + /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down. + /// + /// @dev Requirements: + /// - x * y must fit within MAX_UD60x18, lest it overflows. + /// + /// @param x The first operand as an unsigned 60.18-decimal fixed-point number. + /// @param y The second operand as an unsigned 60.18-decimal fixed-point number. + /// @return result The result as an unsigned 60.18-decimal fixed-point number. + function gm(uint256 x, uint256 y) internal pure returns (uint256 result) { + if (x == 0) { + return 0; + } + +// unchecked { + // Checking for overflow this way is faster than letting Solidity do it. + uint256 xy = x * y; + require(xy / x == y); + + // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE + // during multiplication. See the comments within the "sqrt" function. + result = PRBMathCommon.sqrt(xy); +// } + } + + /// @notice Calculates 1 / x, rounding towards zero. + /// + /// @dev Requirements: + /// - x cannot be zero. + /// + /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse. + /// @return result The inverse as an unsigned 60.18-decimal fixed-point number. + function inv(uint256 x) internal pure returns (uint256 result) { +// unchecked { + // 1e36 is SCALE * SCALE. + result = 1e36 / x; +// } + } + + /// @notice Calculates the natural logarithm of x. + /// + /// @dev Based on the insight that ln(x) = log2(x) / log2(e). + /// + /// Requirements: + /// - All from "log2". + /// + /// Caveats: + /// - All from "log2". + /// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision. + /// + /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm. + /// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number. + function ln(uint256 x) internal pure returns (uint256 result) { + // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x) + // can return is 196205294292027477728. +// unchecked { result = (log2(x) * SCALE) / LOG2_E; } + result = (log2(x) * SCALE) / LOG2_E; + } + + /// @notice Calculates the common logarithm of x. + /// + /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common + /// logarithm based on the insight that log10(x) = log2(x) / log2(10). + /// + /// Requirements: + /// - All from "log2". + /// + /// Caveats: + /// - All from "log2". + /// + /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm. + /// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number. + function log10(uint256 x) internal pure returns (uint256 result) { + require(x >= SCALE); + + // Note that the "mul" in this block is the assembly mul operation, not the "mul" function defined in this contract. + // prettier-ignore + assembly { + switch x + case 1 { result := mul(SCALE, sub(0, 18)) } + case 10 { result := mul(SCALE, sub(1, 18)) } + case 100 { result := mul(SCALE, sub(2, 18)) } + case 1000 { result := mul(SCALE, sub(3, 18)) } + case 10000 { result := mul(SCALE, sub(4, 18)) } + case 100000 { result := mul(SCALE, sub(5, 18)) } + case 1000000 { result := mul(SCALE, sub(6, 18)) } + case 10000000 { result := mul(SCALE, sub(7, 18)) } + case 100000000 { result := mul(SCALE, sub(8, 18)) } + case 1000000000 { result := mul(SCALE, sub(9, 18)) } + case 10000000000 { result := mul(SCALE, sub(10, 18)) } + case 100000000000 { result := mul(SCALE, sub(11, 18)) } + case 1000000000000 { result := mul(SCALE, sub(12, 18)) } + case 10000000000000 { result := mul(SCALE, sub(13, 18)) } + case 100000000000000 { result := mul(SCALE, sub(14, 18)) } + case 1000000000000000 { result := mul(SCALE, sub(15, 18)) } + case 10000000000000000 { result := mul(SCALE, sub(16, 18)) } + case 100000000000000000 { result := mul(SCALE, sub(17, 18)) } + case 1000000000000000000 { result := 0 } + case 10000000000000000000 { result := SCALE } + case 100000000000000000000 { result := mul(SCALE, 2) } + case 1000000000000000000000 { result := mul(SCALE, 3) } + case 10000000000000000000000 { result := mul(SCALE, 4) } + case 100000000000000000000000 { result := mul(SCALE, 5) } + case 1000000000000000000000000 { result := mul(SCALE, 6) } + case 10000000000000000000000000 { result := mul(SCALE, 7) } + case 100000000000000000000000000 { result := mul(SCALE, 8) } + case 1000000000000000000000000000 { result := mul(SCALE, 9) } + case 10000000000000000000000000000 { result := mul(SCALE, 10) } + case 100000000000000000000000000000 { result := mul(SCALE, 11) } + case 1000000000000000000000000000000 { result := mul(SCALE, 12) } + case 10000000000000000000000000000000 { result := mul(SCALE, 13) } + case 100000000000000000000000000000000 { result := mul(SCALE, 14) } + case 1000000000000000000000000000000000 { result := mul(SCALE, 15) } + case 10000000000000000000000000000000000 { result := mul(SCALE, 16) } + case 100000000000000000000000000000000000 { result := mul(SCALE, 17) } + case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) } + case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) } + case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) } + case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) } + case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) } + case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) } + case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) } + case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) } + case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) } + case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) } + case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) } + case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) } + case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) } + case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) } + case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) } + case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) } + case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) } + case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) } + case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) } + case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) } + case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) } + case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) } + case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) } + case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) } + case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) } + case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) } + case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) } + case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) } + case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) } + case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) } + case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) } + case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) } + case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) } + case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) } + case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) } + case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) } + case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) } + case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) } + case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) } + case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) } + case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) } + case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) } + default { + result := MAX_UD60x18 + } + } + + if (result == MAX_UD60x18) { + // Do the fixed-point division inline to save gas. The denominator is log2(10). +// unchecked { result = (log2(x) * SCALE) / 332192809488736234; } + result = (log2(x) * SCALE) / 332192809488736234; + } + } + + /// @notice Calculates the binary logarithm of x. + /// + /// @dev Based on the iterative approximation algorithm. + /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation + /// + /// Requirements: + /// - x must be greater than or equal to SCALE, otherwise the result would be negative. + /// + /// Caveats: + /// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation. + /// + /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm. + /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number. + function log2(uint256 x) internal pure returns (uint256 result) { + require(x >= SCALE); +// unchecked { + // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n). + uint256 n = PRBMathCommon.mostSignificantBit(x / SCALE); + + // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow + // because n is maximum 255 and SCALE is 1e18. + result = n * SCALE; + + // This is y = x * 2^(-n). + uint256 y = x >> n; + + // If y = 1, the fractional part is zero. + if (y == SCALE) { + return result; + } + + // Calculate the fractional part via the iterative approximation. + // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster. + for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) { + y = (y * y) / SCALE; + + // Is y^2 > 2 and so in the range [2,4)? + if (y >= 2 * SCALE) { + // Add the 2^(-m) factor to the logarithm. + result += delta; + + // Corresponds to z/2 on Wikipedia. + y >>= 1; + } + } +// } + } + + /// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal + /// fixed-point number. + /// @dev See the documentation for the "PRBMathCommon.mulDivFixedPoint" function. + /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number. + /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number. + /// @return result The result as an unsigned 60.18-decimal fixed-point number. + function mul(uint256 x, uint256 y) internal pure returns (uint256 result) { + result = PRBMathCommon.mulDivFixedPoint(x, y); + } + + /// @notice Returns PI as an unsigned 60.18-decimal fixed-point number. + function pi() internal pure returns (uint256 result) { + result = 3141592653589793238; + } + + /// @notice Raises x to the power of y. + /// + /// @dev Based on the insight that x^y = 2^(log2(x) * y). + /// + /// Requirements: + /// - All from "exp2", "log2" and "mul". + /// + /// Caveats: + /// - All from "exp2", "log2" and "mul". + /// - Assumes 0^0 is 1. + /// + /// @param x Number to raise to given power y, as a signed 59.18-decimal fixed-point number. + /// @param y Exponent to raise x to, as a signed 59.18-decimal fixed-point number. + /// @return result x raised to power y, as a signed 59.18-decimal fixed-point number. + function pow(uint256 x, uint256 y) internal pure returns (uint256 result) { + if (x == 0) { + return y == 0 ? SCALE : uint256(0); + } else { + result = exp2(mul(log2(x), y)); + } + } + + /// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the + /// famous algorithm "exponentiation by squaring". + /// + /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring + /// + /// Requirements: + /// - The result must fit within MAX_UD60x18. + /// + /// Caveats: + /// - All from "mul". + /// - Assumes 0^0 is 1. + /// + /// @param x The base as an unsigned 60.18-decimal fixed-point number. + /// @param y The exponent as an uint256. + /// @return result The result as an unsigned 60.18-decimal fixed-point number. + function powu(uint256 x, uint256 y) internal pure returns (uint256 result) { + // Calculate the first iteration of the loop in advance. + result = y & 1 > 0 ? x : SCALE; + + // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster. + for (y >>= 1; y > 0; y >>= 1) { + x = PRBMathCommon.mulDivFixedPoint(x, x); + + // Equivalent to "y % 2 == 1" but faster. + if (y & 1 > 0) { + result = PRBMathCommon.mulDivFixedPoint(result, x); + } + } + } + + /// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number. + function scale() internal pure returns (uint256 result) { + result = SCALE; + } + + /// @notice Calculates the square root of x, rounding down. + /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. + /// + /// Requirements: + /// - x must be less than MAX_UD60x18 / SCALE. + /// + /// Caveats: + /// - The maximum fixed-point number permitted is 115792089237316195423570985008687907853269.984665640564039458. + /// + /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root. + /// @return result The result as an unsigned 60.18-decimal fixed-point . + function sqrt(uint256 x) internal pure returns (uint256 result) { + require(x < 115792089237316195423570985008687907853269984665640564039458); +// unchecked { + // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned + // 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root). + result = PRBMathCommon.sqrt(x * SCALE); +// } + } + + /// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process. + /// @param x The unsigned 60.18-decimal fixed-point number to convert. + /// @return result The same number in basic integer form. + function toUint(uint256 x) internal pure returns (uint256 result) { +// unchecked { result = x / SCALE; } + result = x / SCALE; + } +}