ERC-20
Overview
Max Total Supply
80,186,922.391574416426748684 veMAV
Holders
286
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
843.195330774673415171 veMAVValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
MaverickV2VotingEscrowWSync
Compiler Version
v0.8.25+commit.b61c2a91
Optimization Enabled:
Yes with 5500 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {MaverickV2VotingEscrow} from "./MaverickV2VotingEscrow.sol"; import {IMaverickV2VotingEscrowWSync} from "./interfaces/IMaverickV2VotingEscrowWSync.sol"; import {IMaverickV2VotingEscrowFactory} from "./interfaces/IMaverickV2VotingEscrowFactory.sol"; import {ILegacyVeMav} from "./votingescrowbase/ILegacyVeMav.sol"; /** * @notice Inherits MaverickV2VotingEscrow and adds functionality for * synchronizing veMav V1 and veMav v2 balances. */ contract MaverickV2VotingEscrowWSync is MaverickV2VotingEscrow, IMaverickV2VotingEscrowWSync { /// @inheritdoc IMaverickV2VotingEscrowWSync IERC20 public immutable legacyVeMav; /// @inheritdoc IMaverickV2VotingEscrowWSync mapping(address staker => mapping(uint256 legacyLockupIndex => uint256 balance)) public syncBalances; /// @inheritdoc IMaverickV2VotingEscrowWSync uint256 public constant MIN_SYNC_DURATION = 365 days; constructor(string memory __name, string memory __symbol) MaverickV2VotingEscrow(__name, __symbol) { legacyVeMav = IMaverickV2VotingEscrowFactory(msg.sender).legacyVeMav(); startTimestamp = ILegacyVeMav(address(legacyVeMav)).epoch(); } /// @inheritdoc IMaverickV2VotingEscrowWSync function sync(address staker, uint256 legacyLockupIndex) public nonReentrant returns (uint256 newBalance) { mapping(uint256 => uint256) storage stakerBalancePerIndex = syncBalances[staker]; uint256 oldBalance = stakerBalancePerIndex[legacyLockupIndex]; Lockup memory lockup = ILegacyVeMav(address(legacyVeMav)).lockups(staker, legacyLockupIndex); if (lockup.end != 0 && lockup.end < block.timestamp + MIN_SYNC_DURATION) revert VotingEscrowLockupEndTooShortToSync(lockup.end, block.timestamp + MIN_SYNC_DURATION); newBalance = lockup.votes; if (newBalance != oldBalance) { unchecked { if (newBalance > oldBalance) { _mint(staker, newBalance - oldBalance); } else if (newBalance < oldBalance) { _burn(staker, oldBalance - newBalance); } } stakerBalancePerIndex[legacyLockupIndex] = newBalance; emit Sync(staker, legacyLockupIndex, newBalance); } } }
// SPDX-License-Identifier: GPL-2.0-or-later // As the copyright holder of this work, Ubiquity Labs retains // the right to distribute, use, and modify this code under any license of // their choosing, in addition to the terms of the GPL-v2 or later. pragma solidity ^0.8.25; interface IMulticall { function multicall(bytes[] calldata data) external returns (bytes[] memory results); }
// SPDX-License-Identifier: GPL-2.0-or-later // As the copyright holder of this work, Ubiquity Labs retains // the right to distribute, use, and modify this code under any license of // their choosing, in addition to the terms of the GPL-v2 or later. pragma solidity ^0.8.25; import {IMulticall} from "./IMulticall.sol"; import {Address} from "@openzeppelin/contracts/utils/Address.sol"; // Modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/6ba452dea4258afe77726293435f10baf2bed265/contracts/utils/Multicall.sol /* * @notice Multicall */ abstract contract Multicall is IMulticall { /** * @notice This function allows multiple calls to different contract functions * in a single transaction. * @param data An array of encoded function call data. * @return results An array of the results of the function calls. */ function multicall(bytes[] calldata data) external returns (bytes[] memory results) { results = new bytes[](data.length); for (uint256 i = 0; i < data.length; i++) { results[i] = Address.functionDelegateCall(address(this), data[i]); } } }
// SPDX-License-Identifier: GPL-2.0-or-later // As the copyright holder of this work, Ubiquity Labs retains // the right to distribute, use, and modify this code under any license of // their choosing, in addition to the terms of the GPL-v2 or later. pragma solidity ^0.8.25; // factory contraints on pools uint8 constant MAX_PROTOCOL_FEE_RATIO_D3 = 0.25e3; // 25% uint256 constant MAX_PROTOCOL_LENDING_FEE_RATE_D18 = 0.02e18; // 2% uint64 constant MAX_POOL_FEE_D18 = 0.9e18; // 90% uint64 constant MIN_LOOKBACK = 1 seconds; uint64 constant MAX_TICK_SPACING = 10_000; // pool constraints uint8 constant NUMBER_OF_KINDS = 4; int32 constant NUMBER_OF_KINDS_32 = int32(int8(NUMBER_OF_KINDS)); uint256 constant MAX_TICK = 322_378; // max price 1e14 in D18 scale int32 constant MAX_TICK_32 = int32(int256(MAX_TICK)); int32 constant MIN_TICK_32 = int32(-int256(MAX_TICK)); uint256 constant MAX_BINS_TO_MERGE = 3; uint128 constant MINIMUM_LIQUIDITY = 1e8; // accessor named constants uint8 constant ALL_KINDS_MASK = 0xF; // 0b1111 uint8 constant PERMISSIONED_LIQUIDITY_MASK = 0x10; // 0b010000 uint8 constant PERMISSIONED_SWAP_MASK = 0x20; // 0b100000 uint8 constant OPTIONS_MASK = ALL_KINDS_MASK | PERMISSIONED_LIQUIDITY_MASK | PERMISSIONED_SWAP_MASK; // 0b111111 // named values address constant MERGED_LP_BALANCE_ADDRESS = address(0); uint256 constant MERGED_LP_BALANCE_SUBACCOUNT = 0; uint128 constant ONE = 1e18; uint128 constant ONE_SQUARED = 1e36; int256 constant INT256_ONE = 1e18; uint256 constant ONE_D8 = 1e8; uint256 constant ONE_D3 = 1e3; int40 constant INT_ONE_D8 = 1e8; int40 constant HALF_TICK_D8 = 0.5e8; uint8 constant DEFAULT_DECIMALS = 18; uint256 constant DEFAULT_SCALE = 1; bytes constant EMPTY_PRICE_BREAKS = hex"010000000000000000000000";
// SPDX-License-Identifier: GPL-2.0-or-later // As the copyright holder of this work, Ubiquity Labs retains // the right to distribute, use, and modify this code under any license of // their choosing, in addition to the terms of the GPL-v2 or later. pragma solidity ^0.8.25; import {Math as OzMath} from "@openzeppelin/contracts/utils/math/Math.sol"; import {ONE, DEFAULT_SCALE, DEFAULT_DECIMALS, INT_ONE_D8, ONE_SQUARED} from "./Constants.sol"; /** * @notice Math functions. */ library Math { /** * @notice Returns the lesser of two values. * @param x First uint256 value. * @param y Second uint256 value. */ function min(uint256 x, uint256 y) internal pure returns (uint256 z) { assembly ("memory-safe") { z := xor(x, mul(xor(x, y), lt(y, x))) } } /** * @notice Returns the lesser of two uint128 values. * @param x First uint128 value. * @param y Second uint128 value. */ function min128(uint128 x, uint128 y) internal pure returns (uint128 z) { assembly ("memory-safe") { z := xor(x, mul(xor(x, y), lt(y, x))) } } /** * @notice Returns the lesser of two int256 values. * @param x First int256 value. * @param y Second int256 value. */ function min(int256 x, int256 y) internal pure returns (int256 z) { assembly ("memory-safe") { z := xor(x, mul(xor(x, y), slt(y, x))) } } /** * @notice Returns the greater of two uint256 values. * @param x First uint256 value. * @param y Second uint256 value. */ function max(uint256 x, uint256 y) internal pure returns (uint256 z) { assembly ("memory-safe") { z := xor(x, mul(xor(x, y), gt(y, x))) } } /** * @notice Returns the greater of two int256 values. * @param x First int256 value. * @param y Second int256 value. */ function max(int256 x, int256 y) internal pure returns (int256 z) { assembly ("memory-safe") { z := xor(x, mul(xor(x, y), sgt(y, x))) } } /** * @notice Returns the greater of two uint128 values. * @param x First uint128 value. * @param y Second uint128 value. */ function max128(uint128 x, uint128 y) internal pure returns (uint128 z) { assembly ("memory-safe") { z := xor(x, mul(xor(x, y), gt(y, x))) } } /** * @notice Thresholds a value to be within the specified bounds. * @param value The value to bound. * @param lowerLimit The minimum allowable value. * @param upperLimit The maximum allowable value. */ function boundValue( uint256 value, uint256 lowerLimit, uint256 upperLimit ) internal pure returns (uint256 outputValue) { outputValue = min(max(value, lowerLimit), upperLimit); } /** * @notice Returns the difference between two uint128 values or zero if the result would be negative. * @param x The minuend. * @param y The subtrahend. */ function clip128(uint128 x, uint128 y) internal pure returns (uint128) { unchecked { return x < y ? 0 : x - y; } } /** * @notice Returns the difference between two uint256 values or zero if the result would be negative. * @param x The minuend. * @param y The subtrahend. */ function clip(uint256 x, uint256 y) internal pure returns (uint256) { unchecked { return x < y ? 0 : x - y; } } /** * @notice Divides one uint256 by another, rounding down to the nearest * integer. * @param x The dividend. * @param y The divisor. */ function divFloor(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivFloor(x, ONE, y); } /** * @notice Divides one uint256 by another, rounding up to the nearest integer. * @param x The dividend. * @param y The divisor. */ function divCeil(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivCeil(x, ONE, y); } /** * @notice Multiplies two uint256 values and then divides by ONE, rounding down. * @param x The multiplicand. * @param y The multiplier. */ function mulFloor(uint256 x, uint256 y) internal pure returns (uint256) { return OzMath.mulDiv(x, y, ONE); } /** * @notice Multiplies two uint256 values and then divides by ONE, rounding up. * @param x The multiplicand. * @param y The multiplier. */ function mulCeil(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivCeil(x, y, ONE); } /** * @notice Calculates the multiplicative inverse of a uint256, rounding down. * @param x The value to invert. */ function invFloor(uint256 x) internal pure returns (uint256) { unchecked { return ONE_SQUARED / x; } } /** * @notice Calculates the multiplicative inverse of a uint256, rounding up. * @param denominator The value to invert. */ function invCeil(uint256 denominator) internal pure returns (uint256 z) { assembly ("memory-safe") { // divide z - 1 by the denominator and add 1. z := add(div(sub(ONE_SQUARED, 1), denominator), 1) } } /** * @notice Multiplies two uint256 values and divides by a third, rounding down. * @param x The multiplicand. * @param y The multiplier. * @param k The divisor. */ function mulDivFloor(uint256 x, uint256 y, uint256 k) internal pure returns (uint256 result) { result = OzMath.mulDiv(x, y, max(1, k)); } /** * @notice Multiplies two uint256 values and divides by a third, rounding up if there's a remainder. * @param x The multiplicand. * @param y The multiplier. * @param k The divisor. */ function mulDivCeil(uint256 x, uint256 y, uint256 k) internal pure returns (uint256 result) { result = mulDivFloor(x, y, k); if (mulmod(x, y, max(1, k)) != 0) result = result + 1; } /** * @notice Multiplies two uint256 values and divides by a third, rounding * down. Will revert if `x * y` is larger than `type(uint256).max`. * @param x The first operand for multiplication. * @param y The second operand for multiplication. * @param denominator The divisor after multiplication. */ function mulDivDown(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 z) { assembly ("memory-safe") { // Store x * y in z for now. z := mul(x, y) if iszero(denominator) { denominator := 1 } if iszero(or(iszero(x), eq(div(z, x), y))) { revert(0, 0) } // Divide z by the denominator. z := div(z, denominator) } } /** * @notice Multiplies two uint256 values and divides by a third, rounding * up. Will revert if `x * y` is larger than `type(uint256).max`. * @param x The first operand for multiplication. * @param y The second operand for multiplication. * @param denominator The divisor after multiplication. */ function mulDivUp(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 z) { assembly ("memory-safe") { // Store x * y in z for now. z := mul(x, y) if iszero(denominator) { denominator := 1 } if iszero(or(iszero(x), eq(div(z, x), y))) { revert(0, 0) } // First, divide z - 1 by the denominator and add 1. // We allow z - 1 to underflow if z is 0, because we multiply the // end result by 0 if z is zero, ensuring we return 0 if z is zero. z := mul(iszero(iszero(z)), add(div(sub(z, 1), denominator), 1)) } } /** * @notice Multiplies a uint256 by another and divides by a constant, * rounding down. Will revert if `x * y` is larger than * `type(uint256).max`. * @param x The multiplicand. * @param y The multiplier. */ function mulDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, y, ONE); } /** * @notice Divides a uint256 by another, rounding down the result. Will * revert if `x * 1e18` is larger than `type(uint256).max`. * @param x The dividend. * @param y The divisor. */ function divDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, ONE, y); } /** * @notice Divides a uint256 by another, rounding up the result. Will * revert if `x * 1e18` is larger than `type(uint256).max`. * @param x The dividend. * @param y The divisor. */ function divUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, ONE, y); } /** * @notice Scales a number based on a difference in decimals from a default. * @param decimals The new decimal precision. */ function scale(uint8 decimals) internal pure returns (uint256) { unchecked { if (decimals == DEFAULT_DECIMALS) { return DEFAULT_SCALE; } else { return 10 ** (DEFAULT_DECIMALS - decimals); } } } /** * @notice Adjusts a scaled amount to the token decimal scale. * @param amount The scaled amount. * @param scaleFactor The scaling factor to adjust by. * @param ceil Whether to round up (true) or down (false). */ function ammScaleToTokenScale(uint256 amount, uint256 scaleFactor, bool ceil) internal pure returns (uint256 z) { unchecked { if (scaleFactor == DEFAULT_SCALE || amount == 0) { return amount; } else { if (!ceil) return amount / scaleFactor; assembly ("memory-safe") { z := add(div(sub(amount, 1), scaleFactor), 1) } } } } /** * @notice Adjusts a token amount to the D18 AMM scale. * @param amount The amount in token scale. * @param scaleFactor The scale factor for adjustment. */ function tokenScaleToAmmScale(uint256 amount, uint256 scaleFactor) internal pure returns (uint256) { if (scaleFactor == DEFAULT_SCALE) { return amount; } else { return amount * scaleFactor; } } /** * @notice Returns the absolute value of a signed 32-bit integer. * @param x The integer to take the absolute value of. */ function abs32(int32 x) internal pure returns (uint32) { unchecked { return uint32(x < 0 ? -x : x); } } /** * @notice Returns the absolute value of a signed 256-bit integer. * @param x The integer to take the absolute value of. */ function abs(int256 x) internal pure returns (uint256) { unchecked { return uint256(x < 0 ? -x : x); } } /** * @notice Calculates the integer square root of a uint256 rounded down. * @param x The number to take the square root of. */ function sqrt(uint256 x) internal pure returns (uint256 z) { // from https://github.com/transmissions11/solmate/blob/e8f96f25d48fe702117ce76c79228ca4f20206cb/src/utils/FixedPointMathLib.sol assembly ("memory-safe") { let y := x z := 181 if iszero(lt(y, 0x10000000000000000000000000000000000)) { y := shr(128, y) z := shl(64, z) } if iszero(lt(y, 0x1000000000000000000)) { y := shr(64, y) z := shl(32, z) } if iszero(lt(y, 0x10000000000)) { y := shr(32, y) z := shl(16, z) } if iszero(lt(y, 0x1000000)) { y := shr(16, y) z := shl(8, z) } z := shr(18, mul(z, add(y, 65536))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := sub(z, lt(div(x, z), z)) } } /** * @notice Computes the floor of a D8-scaled number as an int32, ignoring * potential overflow in the cast. * @param val The D8-scaled number. */ function floorD8Unchecked(int256 val) internal pure returns (int32) { int32 val32; bool check; unchecked { val32 = int32(val / INT_ONE_D8); check = (val < 0 && val % INT_ONE_D8 != 0); } return check ? val32 - 1 : val32; } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol"; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {IERC6372} from "@openzeppelin/contracts/interfaces/IERC6372.sol"; import {IHistoricalBalance} from "../votingescrowbase/IHistoricalBalance.sol"; interface IMaverickV2VotingEscrowBase is IVotes, IHistoricalBalance { error VotingEscrowTransferNotSupported(); error VotingEscrowInvalidAddress(address); error VotingEscrowInvalidAmount(uint256); error VotingEscrowInvalidDuration(uint256 duration, uint256 minDuration, uint256 maxDuration); error VotingEscrowInvalidEndTime(uint256 newEnd, uint256 oldEnd); error VotingEscrowStakeStillLocked(uint256 currentTime, uint256 endTime); error VotingEscrowStakeAlreadyRedeemed(); error VotingEscrowNotApprovedExtender(address account, address extender, uint256 lockupId); error VotingEscrowIncentiveAlreadyClaimed(address account, uint256 batchIndex); error VotingEscrowNoIncentivesToClaim(address account, uint256 batchIndex); error VotingEscrowInvalidExtendIncentiveToken(IERC20 incentiveToken); error VotingEscrowNoSupplyAtTimepoint(); error VotingEscrowIncentiveTimepointInFuture(uint256 timestamp, uint256 claimTimepoint); event Stake(address indexed user, uint256 lockupId, Lockup); event Unstake(address indexed user, uint256 lockupId, Lockup); event ExtenderApproval(address staker, address extender, uint256 lockupId, bool newState); event ClaimIncentiveBatch(uint256 batchIndex, address account, uint256 claimAmount); event CreateNewIncentiveBatch( address user, uint256 amount, uint256 timepoint, uint256 stakeDuration, IERC20 incentiveToken ); struct Lockup { uint128 amount; uint128 end; uint256 votes; } struct ClaimInformation { bool timepointInPast; bool hasClaimed; uint128 claimAmount; } struct BatchInformation { uint128 totalIncentives; uint128 stakeDuration; uint48 claimTimepoint; IERC20 incentiveToken; } struct TokenIncentiveTotals { uint128 totalIncentives; uint128 claimedIncentives; } // solhint-disable-next-line func-name-mixedcase function MIN_STAKE_DURATION() external returns (uint256 duration); // solhint-disable-next-line func-name-mixedcase function MAX_STAKE_DURATION() external returns (uint256 duration); // solhint-disable-next-line func-name-mixedcase function YEAR_BASE() external returns (uint256); /** * @notice This function retrieves the address of the ERC20 token used as the base token for staking and rewards. * @return baseToken The address of the IERC20 base token contract. */ function baseToken() external returns (IERC20); /** * @notice This function retrieves the starting timestamp. This may be used * for reward calculations or other time-based logic. */ function startTimestamp() external returns (uint256 timestamp); /** * @notice This function retrieves the details of a specific lockup for a given staker and lockup index. * @param staker The address of the staker for which to retrieve the lockup details. * @param index The index of the lockup within the staker's lockup history. * @return lockup A Lockup struct containing details about the lockup (see struct definition for details). */ function getLockup(address staker, uint256 index) external view returns (Lockup memory lockup); /** * @notice This function retrieves the total number of lockups associated with a specific staker. * @param staker The address of the staker for which to retrieve the lockup count. * @return count The total number of lockups for the staker. */ function lockupCount(address staker) external view returns (uint256 count); /** * @notice This function simulates a lockup scenario, providing details about the resulting lockup structure for a specified amount and duration. * @param amount The amount of tokens to be locked. * @param duration The duration of the lockup period. * @return lockup A Lockup struct containing details about the simulated lockup (see struct definition for details). */ function previewVotes(uint128 amount, uint256 duration) external view returns (Lockup memory lockup); /** * @notice This function grants approval for a designated extender contract to manage a specific lockup on behalf of the staker. * @param extender The address of the extender contract to be approved. * @param lockupId The ID of the lockup for which to grant approval. */ function approveExtender(address extender, uint256 lockupId) external; /** * @notice This function revokes approval previously granted to an extender contract for managing a specific lockup. * @param extender The address of the extender contract whose approval is being revoked. * @param lockupId The ID of the lockup for which to revoke approval. */ function revokeExtender(address extender, uint256 lockupId) external; /** * @notice This function checks whether a specific account has been approved by a staker to manage a particular lockup through an extender contract. * @param account The address of the account to check for approval (may be the extender or another account). * @param extender The address of the extender contract for which to check approval. * @param lockupId The ID of the lockup to verify approval for. * @return isApproved True if the account is approved for the lockup, False otherwise (bool). */ function isApprovedExtender(address account, address extender, uint256 lockupId) external view returns (bool); /** * @notice This function extends the lockup period for the caller (msg.sender) for a specified lockup ID, adding a new duration and amount. * @param lockupId The ID of the lockup to be extended. * @param duration The additional duration to extend the lockup by. * @param amount The additional amount of tokens to be locked. * @return newLockup A Lockup struct containing details about the newly extended lockup (see struct definition for details). */ function extendForSender( uint256 lockupId, uint256 duration, uint128 amount ) external returns (Lockup memory newLockup); /** * @notice This function extends the lockup period for a specified account, adding a new duration and amount. The caller (msg.sender) must be authorized to manage the lockup through an extender contract. * @param account The address of the account whose lockup is being extended. * @param lockupId The ID of the lockup to be extended. * @param duration The additional duration to extend the lockup by. * @param amount The additional amount of tokens to be locked. * @return newLockup A Lockup struct containing details about the newly extended lockup (see struct definition for details). */ function extendForAccount( address account, uint256 lockupId, uint256 duration, uint128 amount ) external returns (Lockup memory newLockup); /** * @notice This function merges multiple lockups associated with the caller * (msg.sender) into a single new lockup. * @param lockupIds An array containing the IDs of the lockups to be merged. * @return newLockup A Lockup struct containing details about the newly merged lockup (see struct definition for details). */ function merge(uint256[] memory lockupIds) external returns (Lockup memory newLockup); /** * @notice This function unstakes the specified lockup ID for the caller (msg.sender), returning the details of the unstaked lockup. * @param lockupId The ID of the lockup to be unstaked. * @param to The address to which the unstaked tokens should be sent (optional, defaults to msg.sender). * @return lockup A Lockup struct containing details about the unstaked lockup (see struct definition for details). */ function unstake(uint256 lockupId, address to) external returns (Lockup memory lockup); /** * @notice This function is a simplified version of `unstake` that automatically sends the unstaked tokens to the caller (msg.sender). * @param lockupId The ID of the lockup to be unstaked. * @return lockup A Lockup struct containing details about the unstaked lockup (see struct definition for details). */ function unstakeToSender(uint256 lockupId) external returns (Lockup memory lockup); /** * @notice This function stakes a specified amount of tokens for the caller * (msg.sender) for a defined duration. * @param amount The amount of tokens to be staked. * @param duration The duration of the lockup period. * @return lockup A Lockup struct containing details about the newly * created lockup (see struct definition for details). */ function stakeToSender(uint128 amount, uint256 duration) external returns (Lockup memory lockup); /** * @notice This function stakes a specified amount of tokens for a defined * duration, allowing the caller (msg.sender) to specify an optional * recipient for the staked tokens. * @param amount The amount of tokens to be staked. * @param duration The duration of the lockup period. * @param to The address to which the staked tokens will be credited (optional, defaults to msg.sender). * @return lockup A Lockup struct containing details about the newly * created lockup (see struct definition for details). */ function stake(uint128 amount, uint256 duration, address to) external returns (Lockup memory); /** * @notice This function retrieves the total incentive information for a specific ERC-20 token. * @param token The address of the ERC20 token for which to retrieve incentive totals. * @return totals A TokenIncentiveTotals struct containing details about * the token's incentives (see struct definition for details). */ function incentiveTotals(IERC20 token) external view returns (TokenIncentiveTotals memory); /** * @notice This function retrieves the total number of created incentive batches. * @return count The total number of incentive batches. */ function incentiveBatchCount() external view returns (uint256); /** * @notice This function retrieves claim information for a specific account and incentive batch index. * @param account The address of the account for which to retrieve claim information. * @param batchIndex The index of the incentive batch for which to retrieve * claim information. * @return claimInformation A ClaimInformation struct containing details about the * account's claims for the specified batch (see struct definition for * details). * @return batchInformation A BatchInformation struct containing details about the * specified batch (see struct definition for details). */ function claimAndBatchInformation( address account, uint256 batchIndex ) external view returns (ClaimInformation memory claimInformation, BatchInformation memory batchInformation); /** * @notice This function retrieves batch information for a incentive batch index. * @param batchIndex The index of the incentive batch for which to retrieve * claim information. * @return info A BatchInformation struct containing details about the * specified batch (see struct definition for details). */ function incentiveBatchInformation(uint256 batchIndex) external view returns (BatchInformation memory info); /** * @notice This function allows claiming rewards from a specific incentive * batch while simultaneously extending a lockup with the claimed tokens. * @param batchIndex The index of the incentive batch from which to claim rewards. * @param lockupId The ID of the lockup to be extended with the claimed tokens. * @return lockup A Lockup struct containing details about the updated * lockup after extension (see struct definition for details). * @return claimAmount The amount of tokens claimed from the incentive batch. */ function claimFromIncentiveBatchAndExtend( uint256 batchIndex, uint256 lockupId ) external returns (Lockup memory lockup, uint128 claimAmount); /** * @notice This function allows claiming rewards from a specific incentive * batch, without extending any lockups. * @param batchIndex The index of the incentive batch from which to claim rewards. * @return lockup A Lockup struct containing details about the user's * lockup that might have been affected by the claim (see struct definition * for details). * @return claimAmount The amount of tokens claimed from the incentive batch. */ function claimFromIncentiveBatch(uint256 batchIndex) external returns (Lockup memory lockup, uint128 claimAmount); /** * @notice This function creates a new incentive batch for a specified amount * of incentive tokens, timepoint, stake duration, and associated ERC-20 * token. An incentive batch is a reward of incentives put up by the * caller at a certain timepoint. The incentive batch is claimable by ve * holders after the timepoint has passed. The ve holders will receive * their incentive pro rata of their vote balance (`pastbalanceOf`) at that * timepoint. The incentivizer can specify that users have to stake the * resulting incentive for a given `stakeDuration` number of seconds. * `stakeDuration` can either be zero, meaning that no staking is required * on redemption, or can be a number between `MIN_STAKE_DURATION()` and * `MAX_STAKE_DURATION()`. * @param amount The total amount of incentive tokens to be distributed in the batch. * @param timepoint The timepoint at which the incentive batch starts accruing rewards. * @param stakeDuration The duration of the lockup period required to be * eligible for the incentive batch rewards. * @param incentiveToken The address of the ERC20 token used for the incentive rewards. * @return index The index of the newly created incentive batch. */ function createIncentiveBatch( uint128 amount, uint48 timepoint, uint128 stakeDuration, IERC20 incentiveToken ) external returns (uint256 index); } interface IMaverickV2VotingEscrow is IMaverickV2VotingEscrowBase, IERC20Metadata, IERC6372 {}
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {IERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {IMaverickV2VotingEscrow} from "./IMaverickV2VotingEscrow.sol"; interface IMaverickV2VotingEscrowFactory { error VotingEscrowTokenAlreadyExists(IERC20 baseToken, IMaverickV2VotingEscrow veToken); event CreateVotingEscrow(IERC20 baseToken, IMaverickV2VotingEscrow veToken); /** * @notice This function retrieves the address of the legacy Maverick V1 * Voting Escrow (veMAV) token. The address will be zero for blockchains * where this contract is deployed that do not have a legacy MAV contract * deployed. * @return legacyVeMav The address of the IERC20 legacy veMav token. */ function legacyVeMav() external view returns (IERC20); /** * @notice This function checks whether a provided IMaverickV2VotingEscrow * contract address was created by this factory. * @param veToken The address of the IMaverickV2VotingEscrow contract to be checked. * @return isFactoryToken True if the veToken was created by this factory, False otherwise (bool). */ function isFactoryToken(IMaverickV2VotingEscrow veToken) external view returns (bool); /** * @notice This function creates a new Maverick V2 Voting Escrow (veToken) * contract for a specified ERC20 base token. * @dev Once the ve contract is created, it will call `name()` and * `symbol()` on the `baseToken`. If those functions do not exist, the ve * creation will revert. * @param baseToken The address of the ERC-20 token to be used as the base token for the new veToken. * @return veToken The address of the newly created IMaverickV2VotingEscrow contract. */ function createVotingEscrow(IERC20 baseToken) external returns (IMaverickV2VotingEscrow veToken); /** * @notice This function retrieves a paginated list of existing Maverick V2 * Voting Escrow (veToken) contracts within a specified index range. * @param startIndex The starting index for the desired range of veTokens. * @param endIndex The ending index for the desired range of veTokens. * @return votingEscrows An array of IMaverickV2VotingEscrow addresses * representing the veTokens within the specified range. */ function votingEscrows( uint256 startIndex, uint256 endIndex ) external view returns (IMaverickV2VotingEscrow[] memory votingEscrows); /** * @notice This function retrieves the total number of deployed Maverick V2 * Voting Escrow (veToken) contracts. * @return count The total number of veTokens. */ function votingEscrowsCount() external view returns (uint256 count); /** * @notice This function retrieves the address of the existing Maverick V2 * Voting Escrow (veToken) contract associated with a specific ERC20 base * token. * @param baseToken The address of the ERC-20 base token for which to retrieve the veToken address. * @return veToken The address of the IMaverickV2VotingEscrow contract * associated with the base token, or the zero address if none exists. */ function veForBaseToken(IERC20 baseToken) external view returns (IMaverickV2VotingEscrow veToken); /** * @notice This function retrieves the default base token used for creating * new voting escrow contracts. This state variable is only used * temporarily when a new veToken is deployed. * @return baseToken The address of the default ERC-20 base token. */ function baseTokenParameter() external returns (IERC20); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; interface IMaverickV2VotingEscrowWSync { error VotingEscrowLockupEndTooShortToSync(uint256 legacyLockupEnd, uint256 minimumLockupEnd); event Sync(address staker, uint256 legacyLockupIndex, uint256 newBalance); /** * @notice This function retrieves the minimum lockup duration required for * a legacy lockup to be eligible for synchronization. * @return minSyncDuration The minimum allowed lockup end time. */ // solhint-disable-next-line func-name-mixedcase function MIN_SYNC_DURATION() external pure returns (uint256 minSyncDuration); /** * @notice This function retrieves the address of the legacy Maverick V1 * Voting Escrow (veMav) token. * @return legacyVeMav The address of the IERC20 legacy veMav token. */ function legacyVeMav() external view returns (IERC20); /** * @notice This function retrieves the synced balance for a specific legacy lockup index of a user. * @param staker The address of the user for whom to retrieve the synced balance. * @param legacyLockupIndex The index of the legacy lockup for which to * retrieve the synced balance. * @return balance The synced balance associated with the legacy lockup. */ function syncBalances(address staker, uint256 legacyLockupIndex) external view returns (uint256 balance); /** * @notice This function synchronizes a specific legacy lockup index for a * user within the contract. If the legacy lockup.end is not at least * `block.timestamp + MIN_SYNC_DURATION()`, this function will revert. * @param staker The address of the user for whom to perform synchronization. * @param legacyLockupIndex The index of the legacy lockup to be * synchronized. * @return newBalance The new balance resulting from the synchronization * process. */ function sync(address staker, uint256 legacyLockupIndex) external returns (uint256 newBalance); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {SafeCast as Cast} from "@openzeppelin/contracts/utils/math/SafeCast.sol"; import {Math as OzMath} from "@openzeppelin/contracts/utils/math/Math.sol"; import {VotingEscrow} from "./votingescrowbase/VotingEscrow.sol"; import {IMaverickV2VotingEscrowBase} from "./interfaces/IMaverickV2VotingEscrow.sol"; /** * @notice Provides staking, vote power history, vote delegation, and incentive * disbursement to ve holders. * * @dev `VotingEscrow` contract provides details on the staking and delegation * features. * * @dev Incentive disbursement can take place in any token and happens when a * user permissionlessly creates a new incentive batch for a specified amount * of incentive tokens, timepoint, stake duration, and associated ERC-20 token. * An incentive batch is a reward of incentives put up by the caller at a * certain timepoint. The incentive batch is claimable by ve holders after the * timepoint has passed. The ve holders will receive their incentive pro rata * of their vote balance (`pastbalanceOf`) at that timepoint. The incentivizer * can specify that users have to stake the resulting incentive for a given * `stakeDuration` number of seconds. `stakeDuration` can either be zero, * meaning that no staking is required on redemption, or can be a number * between `MIN_STAKE_DURATION()` and `MAX_STAKE_DURATION()`. */ contract MaverickV2VotingEscrow is VotingEscrow { using SafeERC20 for IERC20; using Cast for uint256; struct IncentiveSpecification { BatchInformation batchInformation; mapping(address => bool) hasClaimed; } mapping(uint256 => IncentiveSpecification) private _incentiveBatches; mapping(IERC20 => TokenIncentiveTotals) private _tokenIncentiveTotals; /// @inheritdoc IMaverickV2VotingEscrowBase uint256 public incentiveBatchCount; constructor(string memory __name, string memory __symbol) VotingEscrow(__name, __symbol) {} ////////////////////// // Incentive Functions ////////////////////// /// @inheritdoc IMaverickV2VotingEscrowBase function createIncentiveBatch( uint128 amount, uint48 timepoint, uint128 stakeDuration, IERC20 incentiveToken ) public returns (uint256 index) { if (amount == 0) revert VotingEscrowInvalidAmount(amount); if (stakeDuration != 0) { if (incentiveToken == baseToken) { _checkDuration(stakeDuration); } else { // if not base token, stakeDuration should be zero revert VotingEscrowInvalidDuration(stakeDuration, 0, 0); } } index = incentiveBatchCount; _tokenIncentiveTotals[incentiveToken].totalIncentives += amount; IncentiveSpecification storage spec = _incentiveBatches[index]; spec.batchInformation.totalIncentives = amount; spec.batchInformation.incentiveToken = incentiveToken; spec.batchInformation.claimTimepoint = timepoint; spec.batchInformation.stakeDuration = stakeDuration; incentiveBatchCount++; incentiveToken.safeTransferFrom(msg.sender, address(this), amount); emit CreateNewIncentiveBatch(msg.sender, amount, timepoint, stakeDuration, incentiveToken); } /// @inheritdoc IMaverickV2VotingEscrowBase function claimFromIncentiveBatch(uint256 batchIndex) public returns (Lockup memory lockup, uint128 claimAmount) { uint256 stakeDuration; IERC20 incentiveToken; (claimAmount, stakeDuration, incentiveToken) = _claim(batchIndex); if (incentiveToken == baseToken && stakeDuration != 0) { // no need to transfer; the base assets are already on this contract lockup = _stake(claimAmount, stakeDuration, msg.sender, type(uint256).max); } else { incentiveToken.safeTransfer(msg.sender, claimAmount); } } /// @inheritdoc IMaverickV2VotingEscrowBase function claimFromIncentiveBatchAndExtend( uint256 batchIndex, uint256 lockupId ) public returns (Lockup memory lockup, uint128 claimAmount) { uint256 stakeDuration; IERC20 incentiveToken; (claimAmount, stakeDuration, incentiveToken) = _claim(batchIndex); if (incentiveToken == baseToken && stakeDuration != 0) { // no need to transfer; the base assets are already on this contract lockup = _extend(claimAmount, stakeDuration, msg.sender, lockupId); } else { revert VotingEscrowInvalidExtendIncentiveToken(incentiveToken); } } ////////////////////// // View Functions ////////////////////// /// @inheritdoc IMaverickV2VotingEscrowBase function incentiveTotals(IERC20 incentiveToken) external view returns (TokenIncentiveTotals memory totals) { totals = _tokenIncentiveTotals[incentiveToken]; } /// @inheritdoc IMaverickV2VotingEscrowBase function claimAndBatchInformation( address account, uint256 batchIndex ) public view returns (ClaimInformation memory claimInformation, BatchInformation memory batchInformation) { IncentiveSpecification storage spec = _incentiveBatches[batchIndex]; batchInformation = spec.batchInformation; uint48 timepoint = batchInformation.claimTimepoint; claimInformation.timepointInPast = timepoint < block.timestamp; if (claimInformation.timepointInPast) { claimInformation.claimAmount = OzMath .mulDiv( batchInformation.totalIncentives, getPastBalanceOf(account, timepoint), getPastTotalSupply(timepoint) ) .toUint128(); claimInformation.hasClaimed = spec.hasClaimed[account]; } } /// @inheritdoc IMaverickV2VotingEscrowBase function incentiveBatchInformation(uint256 batchIndex) public view returns (BatchInformation memory info) { info = _incentiveBatches[batchIndex].batchInformation; } ////////////////////// // Internal Functions ////////////////////// function _claim( uint256 batchIndex ) internal returns (uint128 claimAmount, uint256 stakeDuration, IERC20 incentiveToken) { (ClaimInformation memory claimInformation, BatchInformation memory batchInformation) = claimAndBatchInformation( msg.sender, batchIndex ); if (!claimInformation.timepointInPast) revert VotingEscrowIncentiveTimepointInFuture(block.timestamp, batchInformation.claimTimepoint); if (claimInformation.claimAmount == 0) revert VotingEscrowNoIncentivesToClaim(msg.sender, batchIndex); if (claimInformation.hasClaimed) revert VotingEscrowIncentiveAlreadyClaimed(msg.sender, batchIndex); _tokenIncentiveTotals[batchInformation.incentiveToken].claimedIncentives += claimInformation.claimAmount; _incentiveBatches[batchIndex].hasClaimed[msg.sender] = true; emit ClaimIncentiveBatch(batchIndex, msg.sender, claimInformation.claimAmount); return (claimInformation.claimAmount, batchInformation.stakeDuration, batchInformation.incentiveToken); } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {ERC20Votes} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol"; import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol"; import {Time} from "@openzeppelin/contracts/utils/types/Time.sol"; import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol"; import {IHistoricalBalance} from "./IHistoricalBalance.sol"; /** * @notice Adds support for tracking historical balance on ERC20Votes (not just * historical voting power) and adds support for contributing and retrieving * incentives pro-rata of historical balanceOf. * * @notice Uses a timestamp-based clock for checkpoints as opposed to the * default OZ implementation that is blocknumber based. */ abstract contract HistoricalBalance is ERC20Votes, IHistoricalBalance { using Checkpoints for Checkpoints.Trace208; mapping(address account => Checkpoints.Trace208) private _balanceOfCheckpoints; ////////////////////// // Past Balance ////////////////////// /// @inheritdoc IHistoricalBalance function getPastBalanceOf(address account, uint256 timepoint) public view returns (uint256 balance) { uint48 currentTimepoint = clock(); if (timepoint >= currentTimepoint) { revert ERC5805FutureLookup(timepoint, currentTimepoint); } // cast is safe because of conditional above return _balanceOfCheckpoints[account].upperLookupRecent(uint48(timepoint)); } ////////////////////// // Overrides ////////////////////// function _update(address from, address to, uint256 amount) internal virtual override { ERC20Votes._update(from, to, amount); if (from != to && amount > 0) { if (from != address(0)) { __push(_balanceOfCheckpoints[from], __subtract, SafeCast.toUint208(amount)); } if (to != address(0)) { __push(_balanceOfCheckpoints[to], __add, SafeCast.toUint208(amount)); } } } function clock() public view override returns (uint48) { return Time.timestamp(); } /** * @dev Machine-readable description of the clock as specified in ERC-6372. */ // solhint-disable-next-line func-name-mixedcase function CLOCK_MODE() public pure override returns (string memory) { return "mode=timestamp"; } ////////////////////// // Helpers ////////////////////// function __push( Checkpoints.Trace208 storage store, function(uint208, uint208) view returns (uint208) op, uint208 delta ) private returns (uint208, uint208) { return store.push(clock(), op(store.latest(), delta)); } function __add(uint208 a, uint208 b) private pure returns (uint208) { return a + b; } function __subtract(uint208 a, uint208 b) private pure returns (uint208) { return a - b; } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; interface IHistoricalBalance { /** * @notice This function retrieves the historical balance of an account at * a specific point in time. * @param account The address of the account for which to retrieve the * historical balance. * @param timepoint The timepoint (block number or timestamp depending on * implementation) at which to query the balance (uint256). * @return balance The balance of the account at the specified timepoint. */ function getPastBalanceOf(address account, uint256 timepoint) external view returns (uint256 balance); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {IMaverickV2VotingEscrow} from "../interfaces/IMaverickV2VotingEscrow.sol"; interface ILegacyVeMav { function epoch() external view returns (uint256); function lockups( address staker, uint256 legacyLockupIndex ) external view returns (IMaverickV2VotingEscrow.Lockup memory); function lockupCount(address staker) external view returns (uint256 count); function mav() external view returns (IERC20); }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.25; import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {IERC20, ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol"; import {SafeCast as Cast} from "@openzeppelin/contracts/utils/math/SafeCast.sol"; import {ud} from "@prb/math/src/UD60x18.sol"; import {pow} from "@prb/math/src/ud60x18/Math.sol"; import {Math} from "@maverick/v2-common/contracts/libraries/Math.sol"; import {Multicall} from "@maverick/v2-common/contracts/base/Multicall.sol"; import {IMaverickV2VotingEscrowBase} from "../interfaces/IMaverickV2VotingEscrow.sol"; import {IMaverickV2VotingEscrowFactory} from "../interfaces/IMaverickV2VotingEscrowFactory.sol"; import {HistoricalBalance} from "./HistoricalBalance.sol"; // forked from https://github.com/OriginProtocol/ousd-governance/blob/5a6ed042feef6973177e3b1b093c5a6e64039de4/contracts/OgvStaking.sol /** * @notice Provides staking, vote power history, vote delegation. * * The balance received for staking (and thus the voting power) goes up * exponentially by the end of the staked period. */ abstract contract VotingEscrow is HistoricalBalance, IMaverickV2VotingEscrowBase, ReentrancyGuard, Multicall { using SafeERC20 for IERC20; using Cast for uint256; /// @inheritdoc IMaverickV2VotingEscrowBase uint256 public constant YEAR_BASE = 1.5e18; /// @inheritdoc IMaverickV2VotingEscrowBase uint256 public immutable startTimestamp; /// @inheritdoc IMaverickV2VotingEscrowBase uint256 public constant MIN_STAKE_DURATION = 4 weeks; /// @inheritdoc IMaverickV2VotingEscrowBase uint256 public constant MAX_STAKE_DURATION = 4 * (365 days); mapping(address => Lockup[]) internal _lockups; mapping(address => mapping(address => mapping(uint256 => bool))) internal _extenders; /// @inheritdoc IMaverickV2VotingEscrowBase IERC20 public immutable baseToken; constructor(string memory __name, string memory __symbol) ERC20(__name, __symbol) EIP712(__name, "1") { baseToken = IMaverickV2VotingEscrowFactory(msg.sender).baseTokenParameter(); startTimestamp = block.timestamp; } ////////////////////// // Internal State-Modifying Functions ////////////////////// /** * * @notice Internal function that stakes an amount for a duration to an address. * @dev This function validates that `to` is not the zero address and that the * duration is within bounds. * @dev Function also does a transferFrom for the base token amount. This * requires that the sender approve this ve contract to be able to transfer * tokens for the sender. * */ function _stake( uint128 amount, uint256 duration, address to, uint256 lockupId ) internal nonReentrant returns (Lockup memory lockup) { if (to == address(0)) revert VotingEscrowInvalidAddress(to); // duration checks applied inside previewVotes lockup = previewVotes(amount, duration); // stake to existing or new lockup if (lockupId >= lockupCount(to)) { _lockups[to].push(lockup); unchecked { lockupId = _lockups[to].length - 1; } } else { _lockups[to][lockupId] = lockup; } // mint ve votes _mint(to, lockup.votes); emit Stake(to, lockupId, lockup); } /** * * @notice Internal function that unstakes an account's lockup. * * @dev This function validates that the lockup has not already been * claimed and does burn the account's voting votes. * * @dev But the function does not transfer the baseTokens to the staker. * That transfer operation must be executed seperately as appropiate. * * @dev This function also does not validate that the lockup end time has * passed nor does it validate that `account` has permissions to unstake * this lockupId. * */ function _unstake(address account, uint256 lockupId) internal returns (Lockup memory lockup) { lockup = _lockups[account][lockupId]; if (lockup.end == 0) revert VotingEscrowStakeAlreadyRedeemed(); delete _lockups[account][lockupId]; // Keeps empty in array, so indexes are stable _burn(account, lockup.votes); emit Unstake(account, lockupId, lockup); } /** * * @notice Internal function that extends an account's lockup. * * @dev This function validates that the lockup has not already been * claimed. * * @dev This function also does not validate that the `account` has * permissions to unstake this lockupId. * */ function _extend( uint128 amount, uint256 duration, address account, uint256 lockupId ) internal returns (Lockup memory newLockup) { // unstake existing lockup Lockup memory oldLockup = _unstake(account, lockupId); // stake new lockup newLockup = _stake(oldLockup.amount + amount, duration, account, lockupId); // ensure the new lock is at least as long as old lock if (newLockup.end < oldLockup.end) revert VotingEscrowInvalidEndTime(newLockup.end, oldLockup.end); } ////////////////////// // Public Stake-Management Functions ////////////////////// /// @inheritdoc IMaverickV2VotingEscrowBase function stake(uint128 amount, uint256 duration, address to) public returns (Lockup memory lockup) { if (amount == 0) revert VotingEscrowInvalidAmount(amount); lockup = _stake(amount, duration, to, type(uint256).max); baseToken.safeTransferFrom(msg.sender, address(this), amount); } /// @inheritdoc IMaverickV2VotingEscrowBase function stakeToSender(uint128 amount, uint256 duration) public virtual returns (Lockup memory lockup) { return stake(amount, duration, msg.sender); } /// @inheritdoc IMaverickV2VotingEscrowBase function unstake(uint256 lockupId, address to) public nonReentrant returns (Lockup memory lockup) { lockup = _unstake(msg.sender, lockupId); if (block.timestamp < lockup.end) revert VotingEscrowStakeStillLocked(block.timestamp, lockup.end); baseToken.safeTransfer(to, lockup.amount); } /// @inheritdoc IMaverickV2VotingEscrowBase function unstakeToSender(uint256 lockupId) public returns (Lockup memory lockup) { return unstake(lockupId, msg.sender); } /// @inheritdoc IMaverickV2VotingEscrowBase function merge(uint256[] memory lockupIds) public returns (Lockup memory newLockup) { uint128 cumulativeAmount; uint256 maxEnd; Lockup memory oldLockup; for (uint256 k; k < lockupIds.length; k++) { oldLockup = _unstake(msg.sender, lockupIds[k]); cumulativeAmount += oldLockup.amount; maxEnd = Math.max(maxEnd, oldLockup.end); } // stake new lockup; checks to ensure new duration is at least min duration. newLockup = _stake(cumulativeAmount, maxEnd - block.timestamp, msg.sender, lockupIds[0]); } /// @inheritdoc IMaverickV2VotingEscrowBase function extendForSender( uint256 lockupId, uint256 duration, uint128 amount ) public virtual returns (Lockup memory newLockup) { newLockup = _extend(amount, duration, msg.sender, lockupId); if (amount != 0) baseToken.safeTransferFrom(msg.sender, address(this), amount); } /// @inheritdoc IMaverickV2VotingEscrowBase function extendForAccount( address account, uint256 lockupId, uint256 duration, uint128 amount ) public returns (Lockup memory newLockup) { _checkApprovedExtender(account, lockupId); newLockup = _extend(amount, duration, account, lockupId); if (amount != 0) baseToken.safeTransferFrom(msg.sender, address(this), amount); } ////////////////////// // Permissioning Functions ////////////////////// /// @inheritdoc IMaverickV2VotingEscrowBase function approveExtender(address extender, uint256 lockupId) public { _extenders[extender][msg.sender][lockupId] = true; emit ExtenderApproval(msg.sender, extender, lockupId, true); } /// @inheritdoc IMaverickV2VotingEscrowBase function revokeExtender(address extender, uint256 lockupId) public { _extenders[extender][msg.sender][lockupId] = false; emit ExtenderApproval(msg.sender, extender, lockupId, false); } /// @inheritdoc IMaverickV2VotingEscrowBase function isApprovedExtender(address account, address extender, uint256 lockupId) public view returns (bool) { return _extenders[extender][account][lockupId]; } function _checkApprovedExtender(address account, uint256 lockupId) internal view { bool approved = isApprovedExtender(account, msg.sender, lockupId); if (!approved && account != msg.sender) revert VotingEscrowNotApprovedExtender(account, msg.sender, lockupId); } ////////////////////// // View Functions ////////////////////// function _checkDuration(uint256 duration) internal pure { if (duration < MIN_STAKE_DURATION || duration > MAX_STAKE_DURATION) revert VotingEscrowInvalidDuration(duration, MIN_STAKE_DURATION, MAX_STAKE_DURATION); } /// @inheritdoc IMaverickV2VotingEscrowBase function previewVotes(uint128 amount, uint256 duration) public view returns (Lockup memory lockup) { _checkDuration(duration); unchecked { // duration has been validated to be a small number, can do an // unsafe cast and add lockup.end = uint128(block.timestamp + duration); uint256 endYearpoc = Math.divFloor((lockup.end - startTimestamp), 365 days); uint256 multiplier = pow(ud(YEAR_BASE), ud(endYearpoc)).unwrap(); lockup.amount = amount; lockup.votes = Math.mulFloor(amount, multiplier); } } /// @inheritdoc IMaverickV2VotingEscrowBase function getLockup(address staker, uint256 index) public view returns (Lockup memory lockup) { return _lockups[staker][index]; } /// @inheritdoc IMaverickV2VotingEscrowBase function lockupCount(address staker) public view returns (uint256 count) { return _lockups[staker].length; } ////////////////////// // Overrides ////////////////////// /** * @notice Transfers of voting balances are not allowed. This function will revert. */ function transfer(address, uint256) public pure override returns (bool) { revert VotingEscrowTransferNotSupported(); } /** * @notice Transfers of voting balances are not allowed. This function will revert. */ function transferFrom(address, address, uint256) public pure override returns (bool) { revert VotingEscrowTransferNotSupported(); } /** * @notice Transfers of voting balances are not allowed. This function will revert. */ function approve(address, uint256) public pure override returns (bool) { revert VotingEscrowTransferNotSupported(); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/IVotes.sol) pragma solidity ^0.8.20; /** * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts. */ interface IVotes { /** * @dev The signature used has expired. */ error VotesExpiredSignature(uint256 expiry); /** * @dev Emitted when an account changes their delegate. */ event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /** * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of voting units. */ event DelegateVotesChanged(address indexed delegate, uint256 previousVotes, uint256 newVotes); /** * @dev Returns the current amount of votes that `account` has. */ function getVotes(address account) external view returns (uint256); /** * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is * configured to use block numbers, this will return the value at the end of the corresponding block. */ function getPastVotes(address account, uint256 timepoint) external view returns (uint256); /** * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is * configured to use block numbers, this will return the value at the end of the corresponding block. * * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes. * Votes that have not been delegated are still part of total supply, even though they would not participate in a * vote. */ function getPastTotalSupply(uint256 timepoint) external view returns (uint256); /** * @dev Returns the delegate that `account` has chosen. */ function delegates(address account) external view returns (address); /** * @dev Delegates votes from the sender to `delegatee`. */ function delegate(address delegatee) external; /** * @dev Delegates votes from signer to `delegatee`. */ function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/Votes.sol) pragma solidity ^0.8.20; import {IERC5805} from "../../interfaces/IERC5805.sol"; import {Context} from "../../utils/Context.sol"; import {Nonces} from "../../utils/Nonces.sol"; import {EIP712} from "../../utils/cryptography/EIP712.sol"; import {Checkpoints} from "../../utils/structs/Checkpoints.sol"; import {SafeCast} from "../../utils/math/SafeCast.sol"; import {ECDSA} from "../../utils/cryptography/ECDSA.sol"; import {Time} from "../../utils/types/Time.sol"; /** * @dev This is a base abstract contract that tracks voting units, which are a measure of voting power that can be * transferred, and provides a system of vote delegation, where an account can delegate its voting units to a sort of * "representative" that will pool delegated voting units from different accounts and can then use it to vote in * decisions. In fact, voting units _must_ be delegated in order to count as actual votes, and an account has to * delegate those votes to itself if it wishes to participate in decisions and does not have a trusted representative. * * This contract is often combined with a token contract such that voting units correspond to token units. For an * example, see {ERC721Votes}. * * The full history of delegate votes is tracked on-chain so that governance protocols can consider votes as distributed * at a particular block number to protect against flash loans and double voting. The opt-in delegate system makes the * cost of this history tracking optional. * * When using this module the derived contract must implement {_getVotingUnits} (for example, make it return * {ERC721-balanceOf}), and can use {_transferVotingUnits} to track a change in the distribution of those units (in the * previous example, it would be included in {ERC721-_update}). */ abstract contract Votes is Context, EIP712, Nonces, IERC5805 { using Checkpoints for Checkpoints.Trace208; bytes32 private constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); mapping(address account => address) private _delegatee; mapping(address delegatee => Checkpoints.Trace208) private _delegateCheckpoints; Checkpoints.Trace208 private _totalCheckpoints; /** * @dev The clock was incorrectly modified. */ error ERC6372InconsistentClock(); /** * @dev Lookup to future votes is not available. */ error ERC5805FutureLookup(uint256 timepoint, uint48 clock); /** * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based * checkpoints (and voting), in which case {CLOCK_MODE} should be overridden as well to match. */ function clock() public view virtual returns (uint48) { return Time.blockNumber(); } /** * @dev Machine-readable description of the clock as specified in EIP-6372. */ // solhint-disable-next-line func-name-mixedcase function CLOCK_MODE() public view virtual returns (string memory) { // Check that the clock was not modified if (clock() != Time.blockNumber()) { revert ERC6372InconsistentClock(); } return "mode=blocknumber&from=default"; } /** * @dev Returns the current amount of votes that `account` has. */ function getVotes(address account) public view virtual returns (uint256) { return _delegateCheckpoints[account].latest(); } /** * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is * configured to use block numbers, this will return the value at the end of the corresponding block. * * Requirements: * * - `timepoint` must be in the past. If operating using block numbers, the block must be already mined. */ function getPastVotes(address account, uint256 timepoint) public view virtual returns (uint256) { uint48 currentTimepoint = clock(); if (timepoint >= currentTimepoint) { revert ERC5805FutureLookup(timepoint, currentTimepoint); } return _delegateCheckpoints[account].upperLookupRecent(SafeCast.toUint48(timepoint)); } /** * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is * configured to use block numbers, this will return the value at the end of the corresponding block. * * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes. * Votes that have not been delegated are still part of total supply, even though they would not participate in a * vote. * * Requirements: * * - `timepoint` must be in the past. If operating using block numbers, the block must be already mined. */ function getPastTotalSupply(uint256 timepoint) public view virtual returns (uint256) { uint48 currentTimepoint = clock(); if (timepoint >= currentTimepoint) { revert ERC5805FutureLookup(timepoint, currentTimepoint); } return _totalCheckpoints.upperLookupRecent(SafeCast.toUint48(timepoint)); } /** * @dev Returns the current total supply of votes. */ function _getTotalSupply() internal view virtual returns (uint256) { return _totalCheckpoints.latest(); } /** * @dev Returns the delegate that `account` has chosen. */ function delegates(address account) public view virtual returns (address) { return _delegatee[account]; } /** * @dev Delegates votes from the sender to `delegatee`. */ function delegate(address delegatee) public virtual { address account = _msgSender(); _delegate(account, delegatee); } /** * @dev Delegates votes from signer to `delegatee`. */ function delegateBySig( address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s ) public virtual { if (block.timestamp > expiry) { revert VotesExpiredSignature(expiry); } address signer = ECDSA.recover( _hashTypedDataV4(keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry))), v, r, s ); _useCheckedNonce(signer, nonce); _delegate(signer, delegatee); } /** * @dev Delegate all of `account`'s voting units to `delegatee`. * * Emits events {IVotes-DelegateChanged} and {IVotes-DelegateVotesChanged}. */ function _delegate(address account, address delegatee) internal virtual { address oldDelegate = delegates(account); _delegatee[account] = delegatee; emit DelegateChanged(account, oldDelegate, delegatee); _moveDelegateVotes(oldDelegate, delegatee, _getVotingUnits(account)); } /** * @dev Transfers, mints, or burns voting units. To register a mint, `from` should be zero. To register a burn, `to` * should be zero. Total supply of voting units will be adjusted with mints and burns. */ function _transferVotingUnits(address from, address to, uint256 amount) internal virtual { if (from == address(0)) { _push(_totalCheckpoints, _add, SafeCast.toUint208(amount)); } if (to == address(0)) { _push(_totalCheckpoints, _subtract, SafeCast.toUint208(amount)); } _moveDelegateVotes(delegates(from), delegates(to), amount); } /** * @dev Moves delegated votes from one delegate to another. */ function _moveDelegateVotes(address from, address to, uint256 amount) private { if (from != to && amount > 0) { if (from != address(0)) { (uint256 oldValue, uint256 newValue) = _push( _delegateCheckpoints[from], _subtract, SafeCast.toUint208(amount) ); emit DelegateVotesChanged(from, oldValue, newValue); } if (to != address(0)) { (uint256 oldValue, uint256 newValue) = _push( _delegateCheckpoints[to], _add, SafeCast.toUint208(amount) ); emit DelegateVotesChanged(to, oldValue, newValue); } } } /** * @dev Get number of checkpoints for `account`. */ function _numCheckpoints(address account) internal view virtual returns (uint32) { return SafeCast.toUint32(_delegateCheckpoints[account].length()); } /** * @dev Get the `pos`-th checkpoint for `account`. */ function _checkpoints( address account, uint32 pos ) internal view virtual returns (Checkpoints.Checkpoint208 memory) { return _delegateCheckpoints[account].at(pos); } function _push( Checkpoints.Trace208 storage store, function(uint208, uint208) view returns (uint208) op, uint208 delta ) private returns (uint208, uint208) { return store.push(clock(), op(store.latest(), delta)); } function _add(uint208 a, uint208 b) private pure returns (uint208) { return a + b; } function _subtract(uint208 a, uint208 b) private pure returns (uint208) { return a - b; } /** * @dev Must return the voting units held by an account. */ function _getVotingUnits(address) internal view virtual returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.20; /** * @dev Standard ERC20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol) pragma solidity ^0.8.20; interface IERC5267 { /** * @dev MAY be emitted to signal that the domain could have changed. */ event EIP712DomainChanged(); /** * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712 * signature. */ function eip712Domain() external view returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions ); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5805.sol) pragma solidity ^0.8.20; import {IVotes} from "../governance/utils/IVotes.sol"; import {IERC6372} from "./IERC6372.sol"; interface IERC5805 is IERC6372, IVotes {}
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC6372.sol) pragma solidity ^0.8.20; interface IERC6372 { /** * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting). */ function clock() external view returns (uint48); /** * @dev Description of the clock */ // solhint-disable-next-line func-name-mixedcase function CLOCK_MODE() external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.20; import {IERC20} from "./IERC20.sol"; import {IERC20Metadata} from "./extensions/IERC20Metadata.sol"; import {Context} from "../../utils/Context.sol"; import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * The default value of {decimals} is 18. To change this, you should override * this function so it returns a different value. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. */ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { mapping(address account => uint256) private _balances; mapping(address account => mapping(address spender => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the default value returned by this function, unless * it's overridden. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `value`. */ function transfer(address to, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _transfer(owner, to, value); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 value) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, value); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `value`. * - the caller must have allowance for ``from``'s tokens of at least * `value`. */ function transferFrom(address from, address to, uint256 value) public virtual returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, value); _transfer(from, to, value); return true; } /** * @dev Moves a `value` amount of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _transfer(address from, address to, uint256 value) internal { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(from, to, value); } /** * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding * this function. * * Emits a {Transfer} event. */ function _update(address from, address to, uint256 value) internal virtual { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows _totalSupply += value; } else { uint256 fromBalance = _balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. _balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. _totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. _balances[to] += value; } } emit Transfer(from, to, value); } /** * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). * Relies on the `_update` mechanism * * Emits a {Transfer} event with `from` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead. */ function _mint(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(address(0), account, value); } /** * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. * Relies on the `_update` mechanism. * * Emits a {Transfer} event with `to` set to the zero address. * * NOTE: This function is not virtual, {_update} should be overridden instead */ function _burn(address account, uint256 value) internal { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(account, address(0), value); } /** * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address owner, address spender, uint256 value) internal { _approve(owner, spender, value, true); } /** * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event. * * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any * `Approval` event during `transferFrom` operations. * * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to * true using the following override: * ``` * function _approve(address owner, address spender, uint256 value, bool) internal virtual override { * super._approve(owner, spender, value, true); * } * ``` * * Requirements are the same as {_approve}. */ function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } _allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } /** * @dev Updates `owner` s allowance for `spender` based on spent `value`. * * Does not update the allowance value in case of infinite allowance. * Revert if not enough allowance is available. * * Does not emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 value) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(spender, currentAllowance, value); } unchecked { _approve(owner, spender, currentAllowance - value, false); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Votes.sol) pragma solidity ^0.8.20; import {ERC20} from "../ERC20.sol"; import {Votes} from "../../../governance/utils/Votes.sol"; import {Checkpoints} from "../../../utils/structs/Checkpoints.sol"; /** * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's, * and supports token supply up to 2^208^ - 1, while COMP is limited to 2^96^ - 1. * * NOTE: This contract does not provide interface compatibility with Compound's COMP token. * * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting * power can be queried through the public accessors {getVotes} and {getPastVotes}. * * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked. */ abstract contract ERC20Votes is ERC20, Votes { /** * @dev Total supply cap has been exceeded, introducing a risk of votes overflowing. */ error ERC20ExceededSafeSupply(uint256 increasedSupply, uint256 cap); /** * @dev Maximum token supply. Defaults to `type(uint208).max` (2^208^ - 1). * * This maximum is enforced in {_update}. It limits the total supply of the token, which is otherwise a uint256, * so that checkpoints can be stored in the Trace208 structure used by {{Votes}}. Increasing this value will not * remove the underlying limitation, and will cause {_update} to fail because of a math overflow in * {_transferVotingUnits}. An override could be used to further restrict the total supply (to a lower value) if * additional logic requires it. When resolving override conflicts on this function, the minimum should be * returned. */ function _maxSupply() internal view virtual returns (uint256) { return type(uint208).max; } /** * @dev Move voting power when tokens are transferred. * * Emits a {IVotes-DelegateVotesChanged} event. */ function _update(address from, address to, uint256 value) internal virtual override { super._update(from, to, value); if (from == address(0)) { uint256 supply = totalSupply(); uint256 cap = _maxSupply(); if (supply > cap) { revert ERC20ExceededSafeSupply(supply, cap); } } _transferVotingUnits(from, to, value); } /** * @dev Returns the voting units of an `account`. * * WARNING: Overriding this function may compromise the internal vote accounting. * `ERC20Votes` assumes tokens map to voting units 1:1 and this is not easy to change. */ function _getVotingUnits(address account) internal view virtual override returns (uint256) { return balanceOf(account); } /** * @dev Get number of checkpoints for `account`. */ function numCheckpoints(address account) public view virtual returns (uint32) { return _numCheckpoints(account); } /** * @dev Get the `pos`-th checkpoint for `account`. */ function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoints.Checkpoint208 memory) { return _checkpoints(account, pos); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.20; import {IERC20} from "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * ==== Security Considerations * * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be * considered as an intention to spend the allowance in any specific way. The second is that because permits have * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be * generally recommended is: * * ```solidity * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public { * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {} * doThing(..., value); * } * * function doThing(..., uint256 value) public { * token.safeTransferFrom(msg.sender, address(this), value); * ... * } * ``` * * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also * {SafeERC20-safeTransferFrom}). * * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so * contracts should have entry points that don't rely on permit. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. * * CAUTION: See Security Considerations above. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the value of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the value of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves a `value` amount of tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 value) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets a `value` amount of tokens as the allowance of `spender` over the * caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 value) external returns (bool); /** * @dev Moves a `value` amount of tokens from `from` to `to` using the * allowance mechanism. `value` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 value) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.20; import {IERC20} from "../IERC20.sol"; import {IERC20Permit} from "../extensions/IERC20Permit.sol"; import {Address} from "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; /** * @dev An operation with an ERC20 token failed. */ error SafeERC20FailedOperation(address token); /** * @dev Indicates a failed `decreaseAllowance` request. */ error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease); /** * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value))); } /** * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. */ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value))); } /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 oldAllowance = token.allowance(address(this), spender); forceApprove(token, spender, oldAllowance + value); } /** * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no * value, non-reverting calls are assumed to be successful. */ function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal { unchecked { uint256 currentAllowance = token.allowance(address(this), spender); if (currentAllowance < requestedDecrease) { revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease); } forceApprove(token, spender, currentAllowance - requestedDecrease); } } /** * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval * to be set to zero before setting it to a non-zero value, such as USDT. */ function forceApprove(IERC20 token, address spender, uint256 value) internal { bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value)); if (!_callOptionalReturnBool(token, approvalCall)) { _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0))); _callOptionalReturn(token, approvalCall); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data); if (returndata.length != 0 && !abi.decode(returndata, (bool))) { revert SafeERC20FailedOperation(address(token)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). * * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. */ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false // and not revert is the subcall reverts. (bool success, bytes memory returndata) = address(token).call(data); return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) pragma solidity ^0.8.20; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev The ETH balance of the account is not enough to perform the operation. */ error AddressInsufficientBalance(address account); /** * @dev There's no code at `target` (it is not a contract). */ error AddressEmptyCode(address target); /** * @dev A call to an address target failed. The target may have reverted. */ error FailedInnerCall(); /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { if (address(this).balance < amount) { revert AddressInsufficientBalance(address(this)); } (bool success, ) = recipient.call{value: amount}(""); if (!success) { revert FailedInnerCall(); } } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason or custom error, it is bubbled * up by this function (like regular Solidity function calls). However, if * the call reverted with no returned reason, this function reverts with a * {FailedInnerCall} error. * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { if (address(this).balance < value) { revert AddressInsufficientBalance(address(this)); } (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an * unsuccessful call. */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata ) internal view returns (bytes memory) { if (!success) { _revert(returndata); } else { // only check if target is a contract if the call was successful and the return data is empty // otherwise we already know that it was a contract if (returndata.length == 0 && target.code.length == 0) { revert AddressEmptyCode(target); } return returndata; } } /** * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the * revert reason or with a default {FailedInnerCall} error. */ function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { if (!success) { _revert(returndata); } else { return returndata; } } /** * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. */ function _revert(bytes memory returndata) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert FailedInnerCall(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) pragma solidity ^0.8.20; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.20; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS } /** * @dev The signature derives the `address(0)`. */ error ECDSAInvalidSignature(); /** * @dev The signature has an invalid length. */ error ECDSAInvalidSignatureLength(uint256 length); /** * @dev The signature has an S value that is in the upper half order. */ error ECDSAInvalidSignatureS(bytes32 s); /** * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not * return address(0) without also returning an error description. Errors are documented using an enum (error type) * and a bytes32 providing additional information about the error. * * If no error is returned, then the address can be used for verification purposes. * * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length)); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature); _throwError(error, errorArg); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] */ function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) { unchecked { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // We do not check for an overflow here since the shift operation results in 0 or 1. uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. */ function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) { (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs); _throwError(error, errorArg); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError, bytes32) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS, s); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature, bytes32(0)); } return (signer, RecoverError.NoError, bytes32(0)); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) { (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s); _throwError(error, errorArg); return recovered; } /** * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided. */ function _throwError(RecoverError error, bytes32 errorArg) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert ECDSAInvalidSignature(); } else if (error == RecoverError.InvalidSignatureLength) { revert ECDSAInvalidSignatureLength(uint256(errorArg)); } else if (error == RecoverError.InvalidSignatureS) { revert ECDSAInvalidSignatureS(errorArg); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol) pragma solidity ^0.8.20; import {MessageHashUtils} from "./MessageHashUtils.sol"; import {ShortStrings, ShortString} from "../ShortStrings.sol"; import {IERC5267} from "../../interfaces/IERC5267.sol"; /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the * separator from the immutable values, which is cheaper than accessing a cached version in cold storage. * * @custom:oz-upgrades-unsafe-allow state-variable-immutable */ abstract contract EIP712 is IERC5267 { using ShortStrings for *; bytes32 private constant TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to // invalidate the cached domain separator if the chain id changes. bytes32 private immutable _cachedDomainSeparator; uint256 private immutable _cachedChainId; address private immutable _cachedThis; bytes32 private immutable _hashedName; bytes32 private immutable _hashedVersion; ShortString private immutable _name; ShortString private immutable _version; string private _nameFallback; string private _versionFallback; /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { _name = name.toShortStringWithFallback(_nameFallback); _version = version.toShortStringWithFallback(_versionFallback); _hashedName = keccak256(bytes(name)); _hashedVersion = keccak256(bytes(version)); _cachedChainId = block.chainid; _cachedDomainSeparator = _buildDomainSeparator(); _cachedThis = address(this); } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view returns (bytes32) { if (address(this) == _cachedThis && block.chainid == _cachedChainId) { return _cachedDomainSeparator; } else { return _buildDomainSeparator(); } } function _buildDomainSeparator() private view returns (bytes32) { return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash); } /** * @dev See {IERC-5267}. */ function eip712Domain() public view virtual returns ( bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions ) { return ( hex"0f", // 01111 _EIP712Name(), _EIP712Version(), block.chainid, address(this), bytes32(0), new uint256[](0) ); } /** * @dev The name parameter for the EIP712 domain. * * NOTE: By default this function reads _name which is an immutable value. * It only reads from storage if necessary (in case the value is too large to fit in a ShortString). */ // solhint-disable-next-line func-name-mixedcase function _EIP712Name() internal view returns (string memory) { return _name.toStringWithFallback(_nameFallback); } /** * @dev The version parameter for the EIP712 domain. * * NOTE: By default this function reads _version which is an immutable value. * It only reads from storage if necessary (in case the value is too large to fit in a ShortString). */ // solhint-disable-next-line func-name-mixedcase function _EIP712Version() internal view returns (string memory) { return _version.toStringWithFallback(_versionFallback); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol) pragma solidity ^0.8.20; import {Strings} from "../Strings.sol"; /** * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing. * * The library provides methods for generating a hash of a message that conforms to the * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712] * specifications. */ library MessageHashUtils { /** * @dev Returns the keccak256 digest of an EIP-191 signed data with version * `0x45` (`personal_sign` messages). * * The digest is calculated by prefixing a bytes32 `messageHash` with * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. * * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with * keccak256, although any bytes32 value can be safely used because the final digest will * be re-hashed. * * See {ECDSA-recover}. */ function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) { /// @solidity memory-safe-assembly assembly { mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20) } } /** * @dev Returns the keccak256 digest of an EIP-191 signed data with version * `0x45` (`personal_sign` messages). * * The digest is calculated by prefixing an arbitrary `message` with * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. * * See {ECDSA-recover}. */ function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) { return keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message)); } /** * @dev Returns the keccak256 digest of an EIP-191 signed data with version * `0x00` (data with intended validator). * * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended * `validator` address. Then hashing the result. * * See {ECDSA-recover}. */ function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) { return keccak256(abi.encodePacked(hex"19_00", validator, data)); } /** * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`). * * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with * `\x19\x01` and hashing the result. It corresponds to the hash signed by the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712. * * See {ECDSA-recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(ptr, hex"19_01") mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) digest := keccak256(ptr, 0x42) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol) pragma solidity ^0.8.20; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Muldiv operation overflow. */ error MathOverflowedMulDiv(); enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Returns the addition of two unsigned integers, with an overflow flag. */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds towards infinity instead * of rounding towards zero. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. return a / b; } // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by * Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 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 = x * y; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. if (denominator <= prod1) { revert MathOverflowedMulDiv(); } /////////////////////////////////////////////// // 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. uint256 twos = denominator & (0 - denominator); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // 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; // Use the 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 preconditions 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 x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded * towards zero. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.20; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeCast { /** * @dev Value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value); /** * @dev An int value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedIntToUint(int256 value); /** * @dev Value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedIntDowncast(uint8 bits, int256 value); /** * @dev An uint value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedUintToInt(uint256 value); /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits */ function toUint248(uint256 value) internal pure returns (uint248) { if (value > type(uint248).max) { revert SafeCastOverflowedUintDowncast(248, value); } return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits */ function toUint240(uint256 value) internal pure returns (uint240) { if (value > type(uint240).max) { revert SafeCastOverflowedUintDowncast(240, value); } return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits */ function toUint232(uint256 value) internal pure returns (uint232) { if (value > type(uint232).max) { revert SafeCastOverflowedUintDowncast(232, value); } return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { if (value > type(uint224).max) { revert SafeCastOverflowedUintDowncast(224, value); } return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits */ function toUint216(uint256 value) internal pure returns (uint216) { if (value > type(uint216).max) { revert SafeCastOverflowedUintDowncast(216, value); } return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits */ function toUint208(uint256 value) internal pure returns (uint208) { if (value > type(uint208).max) { revert SafeCastOverflowedUintDowncast(208, value); } return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits */ function toUint200(uint256 value) internal pure returns (uint200) { if (value > type(uint200).max) { revert SafeCastOverflowedUintDowncast(200, value); } return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits */ function toUint192(uint256 value) internal pure returns (uint192) { if (value > type(uint192).max) { revert SafeCastOverflowedUintDowncast(192, value); } return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits */ function toUint184(uint256 value) internal pure returns (uint184) { if (value > type(uint184).max) { revert SafeCastOverflowedUintDowncast(184, value); } return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits */ function toUint176(uint256 value) internal pure returns (uint176) { if (value > type(uint176).max) { revert SafeCastOverflowedUintDowncast(176, value); } return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits */ function toUint168(uint256 value) internal pure returns (uint168) { if (value > type(uint168).max) { revert SafeCastOverflowedUintDowncast(168, value); } return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits */ function toUint160(uint256 value) internal pure returns (uint160) { if (value > type(uint160).max) { revert SafeCastOverflowedUintDowncast(160, value); } return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits */ function toUint152(uint256 value) internal pure returns (uint152) { if (value > type(uint152).max) { revert SafeCastOverflowedUintDowncast(152, value); } return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits */ function toUint144(uint256 value) internal pure returns (uint144) { if (value > type(uint144).max) { revert SafeCastOverflowedUintDowncast(144, value); } return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits */ function toUint136(uint256 value) internal pure returns (uint136) { if (value > type(uint136).max) { revert SafeCastOverflowedUintDowncast(136, value); } return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { if (value > type(uint128).max) { revert SafeCastOverflowedUintDowncast(128, value); } return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits */ function toUint120(uint256 value) internal pure returns (uint120) { if (value > type(uint120).max) { revert SafeCastOverflowedUintDowncast(120, value); } return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits */ function toUint112(uint256 value) internal pure returns (uint112) { if (value > type(uint112).max) { revert SafeCastOverflowedUintDowncast(112, value); } return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits */ function toUint104(uint256 value) internal pure returns (uint104) { if (value > type(uint104).max) { revert SafeCastOverflowedUintDowncast(104, value); } return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { if (value > type(uint96).max) { revert SafeCastOverflowedUintDowncast(96, value); } return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits */ function toUint88(uint256 value) internal pure returns (uint88) { if (value > type(uint88).max) { revert SafeCastOverflowedUintDowncast(88, value); } return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits */ function toUint80(uint256 value) internal pure returns (uint80) { if (value > type(uint80).max) { revert SafeCastOverflowedUintDowncast(80, value); } return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits */ function toUint72(uint256 value) internal pure returns (uint72) { if (value > type(uint72).max) { revert SafeCastOverflowedUintDowncast(72, value); } return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { if (value > type(uint64).max) { revert SafeCastOverflowedUintDowncast(64, value); } return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits */ function toUint56(uint256 value) internal pure returns (uint56) { if (value > type(uint56).max) { revert SafeCastOverflowedUintDowncast(56, value); } return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits */ function toUint48(uint256 value) internal pure returns (uint48) { if (value > type(uint48).max) { revert SafeCastOverflowedUintDowncast(48, value); } return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits */ function toUint40(uint256 value) internal pure returns (uint40) { if (value > type(uint40).max) { revert SafeCastOverflowedUintDowncast(40, value); } return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { if (value > type(uint32).max) { revert SafeCastOverflowedUintDowncast(32, value); } return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits */ function toUint24(uint256 value) internal pure returns (uint24) { if (value > type(uint24).max) { revert SafeCastOverflowedUintDowncast(24, value); } return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { if (value > type(uint16).max) { revert SafeCastOverflowedUintDowncast(16, value); } return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits */ function toUint8(uint256 value) internal pure returns (uint8) { if (value > type(uint8).max) { revert SafeCastOverflowedUintDowncast(8, value); } return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { if (value < 0) { revert SafeCastOverflowedIntToUint(value); } return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(248, value); } } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(240, value); } } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(232, value); } } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(224, value); } } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(216, value); } } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(208, value); } } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(200, value); } } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(192, value); } } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(184, value); } } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(176, value); } } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(168, value); } } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(160, value); } } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(152, value); } } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(144, value); } } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(136, value); } } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(128, value); } } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(120, value); } } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(112, value); } } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(104, value); } } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(96, value); } } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(88, value); } } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(80, value); } } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(72, value); } } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(64, value); } } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(56, value); } } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(48, value); } } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(40, value); } } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(32, value); } } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(24, value); } } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(16, value); } } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(8, value); } } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive if (value > uint256(type(int256).max)) { revert SafeCastOverflowedUintToInt(value); } return int256(value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.20; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol) pragma solidity ^0.8.20; /** * @dev Provides tracking nonces for addresses. Nonces will only increment. */ abstract contract Nonces { /** * @dev The nonce used for an `account` is not the expected current nonce. */ error InvalidAccountNonce(address account, uint256 currentNonce); mapping(address account => uint256) private _nonces; /** * @dev Returns the next unused nonce for an address. */ function nonces(address owner) public view virtual returns (uint256) { return _nonces[owner]; } /** * @dev Consumes a nonce. * * Returns the current value and increments nonce. */ function _useNonce(address owner) internal virtual returns (uint256) { // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be // decremented or reset. This guarantees that the nonce never overflows. unchecked { // It is important to do x++ and not ++x here. return _nonces[owner]++; } } /** * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`. */ function _useCheckedNonce(address owner, uint256 nonce) internal virtual { uint256 current = _useNonce(owner); if (nonce != current) { revert InvalidAccountNonce(owner, current); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol) pragma solidity ^0.8.20; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant NOT_ENTERED = 1; uint256 private constant ENTERED = 2; uint256 private _status; /** * @dev Unauthorized reentrant call. */ error ReentrancyGuardReentrantCall(); constructor() { _status = NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be NOT_ENTERED if (_status == ENTERED) { revert ReentrancyGuardReentrantCall(); } // Any calls to nonReentrant after this point will fail _status = ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/ShortStrings.sol) pragma solidity ^0.8.20; import {StorageSlot} from "./StorageSlot.sol"; // | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | // | length | 0x BB | type ShortString is bytes32; /** * @dev This library provides functions to convert short memory strings * into a `ShortString` type that can be used as an immutable variable. * * Strings of arbitrary length can be optimized using this library if * they are short enough (up to 31 bytes) by packing them with their * length (1 byte) in a single EVM word (32 bytes). Additionally, a * fallback mechanism can be used for every other case. * * Usage example: * * ```solidity * contract Named { * using ShortStrings for *; * * ShortString private immutable _name; * string private _nameFallback; * * constructor(string memory contractName) { * _name = contractName.toShortStringWithFallback(_nameFallback); * } * * function name() external view returns (string memory) { * return _name.toStringWithFallback(_nameFallback); * } * } * ``` */ library ShortStrings { // Used as an identifier for strings longer than 31 bytes. bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF; error StringTooLong(string str); error InvalidShortString(); /** * @dev Encode a string of at most 31 chars into a `ShortString`. * * This will trigger a `StringTooLong` error is the input string is too long. */ function toShortString(string memory str) internal pure returns (ShortString) { bytes memory bstr = bytes(str); if (bstr.length > 31) { revert StringTooLong(str); } return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length)); } /** * @dev Decode a `ShortString` back to a "normal" string. */ function toString(ShortString sstr) internal pure returns (string memory) { uint256 len = byteLength(sstr); // using `new string(len)` would work locally but is not memory safe. string memory str = new string(32); /// @solidity memory-safe-assembly assembly { mstore(str, len) mstore(add(str, 0x20), sstr) } return str; } /** * @dev Return the length of a `ShortString`. */ function byteLength(ShortString sstr) internal pure returns (uint256) { uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF; if (result > 31) { revert InvalidShortString(); } return result; } /** * @dev Encode a string into a `ShortString`, or write it to storage if it is too long. */ function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) { if (bytes(value).length < 32) { return toShortString(value); } else { StorageSlot.getStringSlot(store).value = value; return ShortString.wrap(FALLBACK_SENTINEL); } } /** * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}. */ function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) { if (ShortString.unwrap(value) != FALLBACK_SENTINEL) { return toString(value); } else { return store; } } /** * @dev Return the length of a string that was encoded to `ShortString` or written to storage using * {setWithFallback}. * * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of * actual characters as the UTF-8 encoding of a single character can span over multiple bytes. */ function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) { if (ShortString.unwrap(value) != FALLBACK_SENTINEL) { return byteLength(value); } else { return bytes(store).length; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol) pragma solidity ^0.8.20; import {Math} from "./math/Math.sol"; import {SignedMath} from "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; /** * @dev The `value` string doesn't fit in the specified `length`. */ error StringsInsufficientHexLength(uint256 value, uint256 length); /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), HEX_DIGITS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toStringSigned(int256 value) internal pure returns (string memory) { return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { uint256 localValue = value; bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = HEX_DIGITS[localValue & 0xf]; localValue >>= 4; } if (localValue != 0) { revert StringsInsufficientHexLength(value, length); } return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal * representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/Checkpoints.sol) // This file was procedurally generated from scripts/generate/templates/Checkpoints.js. pragma solidity ^0.8.20; import {Math} from "../math/Math.sol"; /** * @dev This library defines the `Trace*` struct, for checkpointing values as they change at different points in * time, and later looking up past values by block number. See {Votes} as an example. * * To create a history of checkpoints define a variable type `Checkpoints.Trace*` in your contract, and store a new * checkpoint for the current transaction block using the {push} function. */ library Checkpoints { /** * @dev A value was attempted to be inserted on a past checkpoint. */ error CheckpointUnorderedInsertion(); struct Trace224 { Checkpoint224[] _checkpoints; } struct Checkpoint224 { uint32 _key; uint224 _value; } /** * @dev Pushes a (`key`, `value`) pair into a Trace224 so that it is stored as the checkpoint. * * Returns previous value and new value. * * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint32).max` key set will disable the * library. */ function push(Trace224 storage self, uint32 key, uint224 value) internal returns (uint224, uint224) { return _insert(self._checkpoints, key, value); } /** * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if * there is none. */ function lowerLookup(Trace224 storage self, uint32 key) internal view returns (uint224) { uint256 len = self._checkpoints.length; uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len); return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. */ function upperLookup(Trace224 storage self, uint32 key) internal view returns (uint224) { uint256 len = self._checkpoints.length; uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. * * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high * keys). */ function upperLookupRecent(Trace224 storage self, uint32 key) internal view returns (uint224) { uint256 len = self._checkpoints.length; uint256 low = 0; uint256 high = len; if (len > 5) { uint256 mid = len - Math.sqrt(len); if (key < _unsafeAccess(self._checkpoints, mid)._key) { high = mid; } else { low = mid + 1; } } uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints. */ function latest(Trace224 storage self) internal view returns (uint224) { uint256 pos = self._checkpoints.length; return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value * in the most recent checkpoint. */ function latestCheckpoint(Trace224 storage self) internal view returns (bool exists, uint32 _key, uint224 _value) { uint256 pos = self._checkpoints.length; if (pos == 0) { return (false, 0, 0); } else { Checkpoint224 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1); return (true, ckpt._key, ckpt._value); } } /** * @dev Returns the number of checkpoint. */ function length(Trace224 storage self) internal view returns (uint256) { return self._checkpoints.length; } /** * @dev Returns checkpoint at given position. */ function at(Trace224 storage self, uint32 pos) internal view returns (Checkpoint224 memory) { return self._checkpoints[pos]; } /** * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint, * or by updating the last one. */ function _insert(Checkpoint224[] storage self, uint32 key, uint224 value) private returns (uint224, uint224) { uint256 pos = self.length; if (pos > 0) { // Copying to memory is important here. Checkpoint224 memory last = _unsafeAccess(self, pos - 1); // Checkpoint keys must be non-decreasing. if (last._key > key) { revert CheckpointUnorderedInsertion(); } // Update or push new checkpoint if (last._key == key) { _unsafeAccess(self, pos - 1)._value = value; } else { self.push(Checkpoint224({_key: key, _value: value})); } return (last._value, value); } else { self.push(Checkpoint224({_key: key, _value: value})); return (0, value); } } /** * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high` * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive * `high`. * * WARNING: `high` should not be greater than the array's length. */ function _upperBinaryLookup( Checkpoint224[] storage self, uint32 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key > key) { high = mid; } else { low = mid + 1; } } return high; } /** * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and * exclusive `high`. * * WARNING: `high` should not be greater than the array's length. */ function _lowerBinaryLookup( Checkpoint224[] storage self, uint32 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key < key) { low = mid + 1; } else { high = mid; } } return high; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess( Checkpoint224[] storage self, uint256 pos ) private pure returns (Checkpoint224 storage result) { assembly { mstore(0, self.slot) result.slot := add(keccak256(0, 0x20), pos) } } struct Trace208 { Checkpoint208[] _checkpoints; } struct Checkpoint208 { uint48 _key; uint208 _value; } /** * @dev Pushes a (`key`, `value`) pair into a Trace208 so that it is stored as the checkpoint. * * Returns previous value and new value. * * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint48).max` key set will disable the * library. */ function push(Trace208 storage self, uint48 key, uint208 value) internal returns (uint208, uint208) { return _insert(self._checkpoints, key, value); } /** * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if * there is none. */ function lowerLookup(Trace208 storage self, uint48 key) internal view returns (uint208) { uint256 len = self._checkpoints.length; uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len); return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. */ function upperLookup(Trace208 storage self, uint48 key) internal view returns (uint208) { uint256 len = self._checkpoints.length; uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. * * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high * keys). */ function upperLookupRecent(Trace208 storage self, uint48 key) internal view returns (uint208) { uint256 len = self._checkpoints.length; uint256 low = 0; uint256 high = len; if (len > 5) { uint256 mid = len - Math.sqrt(len); if (key < _unsafeAccess(self._checkpoints, mid)._key) { high = mid; } else { low = mid + 1; } } uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints. */ function latest(Trace208 storage self) internal view returns (uint208) { uint256 pos = self._checkpoints.length; return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value * in the most recent checkpoint. */ function latestCheckpoint(Trace208 storage self) internal view returns (bool exists, uint48 _key, uint208 _value) { uint256 pos = self._checkpoints.length; if (pos == 0) { return (false, 0, 0); } else { Checkpoint208 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1); return (true, ckpt._key, ckpt._value); } } /** * @dev Returns the number of checkpoint. */ function length(Trace208 storage self) internal view returns (uint256) { return self._checkpoints.length; } /** * @dev Returns checkpoint at given position. */ function at(Trace208 storage self, uint32 pos) internal view returns (Checkpoint208 memory) { return self._checkpoints[pos]; } /** * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint, * or by updating the last one. */ function _insert(Checkpoint208[] storage self, uint48 key, uint208 value) private returns (uint208, uint208) { uint256 pos = self.length; if (pos > 0) { // Copying to memory is important here. Checkpoint208 memory last = _unsafeAccess(self, pos - 1); // Checkpoint keys must be non-decreasing. if (last._key > key) { revert CheckpointUnorderedInsertion(); } // Update or push new checkpoint if (last._key == key) { _unsafeAccess(self, pos - 1)._value = value; } else { self.push(Checkpoint208({_key: key, _value: value})); } return (last._value, value); } else { self.push(Checkpoint208({_key: key, _value: value})); return (0, value); } } /** * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high` * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive * `high`. * * WARNING: `high` should not be greater than the array's length. */ function _upperBinaryLookup( Checkpoint208[] storage self, uint48 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key > key) { high = mid; } else { low = mid + 1; } } return high; } /** * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and * exclusive `high`. * * WARNING: `high` should not be greater than the array's length. */ function _lowerBinaryLookup( Checkpoint208[] storage self, uint48 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key < key) { low = mid + 1; } else { high = mid; } } return high; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess( Checkpoint208[] storage self, uint256 pos ) private pure returns (Checkpoint208 storage result) { assembly { mstore(0, self.slot) result.slot := add(keccak256(0, 0x20), pos) } } struct Trace160 { Checkpoint160[] _checkpoints; } struct Checkpoint160 { uint96 _key; uint160 _value; } /** * @dev Pushes a (`key`, `value`) pair into a Trace160 so that it is stored as the checkpoint. * * Returns previous value and new value. * * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint96).max` key set will disable the * library. */ function push(Trace160 storage self, uint96 key, uint160 value) internal returns (uint160, uint160) { return _insert(self._checkpoints, key, value); } /** * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if * there is none. */ function lowerLookup(Trace160 storage self, uint96 key) internal view returns (uint160) { uint256 len = self._checkpoints.length; uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len); return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. */ function upperLookup(Trace160 storage self, uint96 key) internal view returns (uint160) { uint256 len = self._checkpoints.length; uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. * * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high * keys). */ function upperLookupRecent(Trace160 storage self, uint96 key) internal view returns (uint160) { uint256 len = self._checkpoints.length; uint256 low = 0; uint256 high = len; if (len > 5) { uint256 mid = len - Math.sqrt(len); if (key < _unsafeAccess(self._checkpoints, mid)._key) { high = mid; } else { low = mid + 1; } } uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints. */ function latest(Trace160 storage self) internal view returns (uint160) { uint256 pos = self._checkpoints.length; return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value * in the most recent checkpoint. */ function latestCheckpoint(Trace160 storage self) internal view returns (bool exists, uint96 _key, uint160 _value) { uint256 pos = self._checkpoints.length; if (pos == 0) { return (false, 0, 0); } else { Checkpoint160 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1); return (true, ckpt._key, ckpt._value); } } /** * @dev Returns the number of checkpoint. */ function length(Trace160 storage self) internal view returns (uint256) { return self._checkpoints.length; } /** * @dev Returns checkpoint at given position. */ function at(Trace160 storage self, uint32 pos) internal view returns (Checkpoint160 memory) { return self._checkpoints[pos]; } /** * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint, * or by updating the last one. */ function _insert(Checkpoint160[] storage self, uint96 key, uint160 value) private returns (uint160, uint160) { uint256 pos = self.length; if (pos > 0) { // Copying to memory is important here. Checkpoint160 memory last = _unsafeAccess(self, pos - 1); // Checkpoint keys must be non-decreasing. if (last._key > key) { revert CheckpointUnorderedInsertion(); } // Update or push new checkpoint if (last._key == key) { _unsafeAccess(self, pos - 1)._value = value; } else { self.push(Checkpoint160({_key: key, _value: value})); } return (last._value, value); } else { self.push(Checkpoint160({_key: key, _value: value})); return (0, value); } } /** * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high` * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive * `high`. * * WARNING: `high` should not be greater than the array's length. */ function _upperBinaryLookup( Checkpoint160[] storage self, uint96 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key > key) { high = mid; } else { low = mid + 1; } } return high; } /** * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and * exclusive `high`. * * WARNING: `high` should not be greater than the array's length. */ function _lowerBinaryLookup( Checkpoint160[] storage self, uint96 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key < key) { low = mid + 1; } else { high = mid; } } return high; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess( Checkpoint160[] storage self, uint256 pos ) private pure returns (Checkpoint160 storage result) { assembly { mstore(0, self.slot) result.slot := add(keccak256(0, 0x20), pos) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/types/Time.sol) pragma solidity ^0.8.20; import {Math} from "../math/Math.sol"; import {SafeCast} from "../math/SafeCast.sol"; /** * @dev This library provides helpers for manipulating time-related objects. * * It uses the following types: * - `uint48` for timepoints * - `uint32` for durations * * While the library doesn't provide specific types for timepoints and duration, it does provide: * - a `Delay` type to represent duration that can be programmed to change value automatically at a given point * - additional helper functions */ library Time { using Time for *; /** * @dev Get the block timestamp as a Timepoint. */ function timestamp() internal view returns (uint48) { return SafeCast.toUint48(block.timestamp); } /** * @dev Get the block number as a Timepoint. */ function blockNumber() internal view returns (uint48) { return SafeCast.toUint48(block.number); } // ==================================================== Delay ===================================================== /** * @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the * future. The "effect" timepoint describes when the transitions happens from the "old" value to the "new" value. * This allows updating the delay applied to some operation while keeping some guarantees. * * In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for * some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set * the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should * still apply for some time. * * * The `Delay` type is 112 bits long, and packs the following: * * ``` * | [uint48]: effect date (timepoint) * | | [uint32]: value before (duration) * ↓ ↓ ↓ [uint32]: value after (duration) * 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC * ``` * * NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently * supported. */ type Delay is uint112; /** * @dev Wrap a duration into a Delay to add the one-step "update in the future" feature */ function toDelay(uint32 duration) internal pure returns (Delay) { return Delay.wrap(duration); } /** * @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled * change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered. */ function _getFullAt(Delay self, uint48 timepoint) private pure returns (uint32, uint32, uint48) { (uint32 valueBefore, uint32 valueAfter, uint48 effect) = self.unpack(); return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect); } /** * @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the * effect timepoint is 0, then the pending value should not be considered. */ function getFull(Delay self) internal view returns (uint32, uint32, uint48) { return _getFullAt(self, timestamp()); } /** * @dev Get the current value. */ function get(Delay self) internal view returns (uint32) { (uint32 delay, , ) = self.getFull(); return delay; } /** * @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to * enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the * new delay becomes effective. */ function withUpdate( Delay self, uint32 newValue, uint32 minSetback ) internal view returns (Delay updatedDelay, uint48 effect) { uint32 value = self.get(); uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0)); effect = timestamp() + setback; return (pack(value, newValue, effect), effect); } /** * @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint). */ function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) { uint112 raw = Delay.unwrap(self); valueAfter = uint32(raw); valueBefore = uint32(raw >> 32); effect = uint48(raw >> 64); return (valueBefore, valueAfter, effect); } /** * @dev pack the components into a Delay object. */ function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) { return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter)); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; // Common.sol // // Common mathematical functions used in both SD59x18 and UD60x18. Note that these global functions do not // always operate with SD59x18 and UD60x18 numbers. /*////////////////////////////////////////////////////////////////////////// CUSTOM ERRORS //////////////////////////////////////////////////////////////////////////*/ /// @notice Thrown when the resultant value in {mulDiv} overflows uint256. error PRBMath_MulDiv_Overflow(uint256 x, uint256 y, uint256 denominator); /// @notice Thrown when the resultant value in {mulDiv18} overflows uint256. error PRBMath_MulDiv18_Overflow(uint256 x, uint256 y); /// @notice Thrown when one of the inputs passed to {mulDivSigned} is `type(int256).min`. error PRBMath_MulDivSigned_InputTooSmall(); /// @notice Thrown when the resultant value in {mulDivSigned} overflows int256. error PRBMath_MulDivSigned_Overflow(int256 x, int256 y); /*////////////////////////////////////////////////////////////////////////// CONSTANTS //////////////////////////////////////////////////////////////////////////*/ /// @dev The maximum value a uint128 number can have. uint128 constant MAX_UINT128 = type(uint128).max; /// @dev The maximum value a uint40 number can have. uint40 constant MAX_UINT40 = type(uint40).max; /// @dev The unit number, which the decimal precision of the fixed-point types. uint256 constant UNIT = 1e18; /// @dev The unit number inverted mod 2^256. uint256 constant UNIT_INVERSE = 78156646155174841979727994598816262306175212592076161876661_508869554232690281; /// @dev The the largest power of two that divides the decimal value of `UNIT`. The logarithm of this value is the least significant /// bit in the binary representation of `UNIT`. uint256 constant UNIT_LPOTD = 262144; /*////////////////////////////////////////////////////////////////////////// FUNCTIONS //////////////////////////////////////////////////////////////////////////*/ /// @notice Calculates the binary exponent of x using the binary fraction method. /// @dev Has to use 192.64-bit fixed-point numbers. See https://ethereum.stackexchange.com/a/96594/24693. /// @param x The exponent as an unsigned 192.64-bit fixed-point number. /// @return result The result as an unsigned 60.18-decimal fixed-point number. /// @custom:smtchecker abstract-function-nondet function exp2(uint256 x) pure returns (uint256 result) { unchecked { // Start from 0.5 in the 192.64-bit fixed-point format. result = 0x800000000000000000000000000000000000000000000000; // The following logic multiplies the result by $\sqrt{2^{-i}}$ when the bit at position i is 1. Key points: // // 1. Intermediate results will not overflow, as the starting point is 2^191 and all magic factors are under 2^65. // 2. The rationale for organizing the if statements into groups of 8 is gas savings. If the result of performing // a bitwise AND operation between x and any value in the array [0x80; 0x40; 0x20; 0x10; 0x08; 0x04; 0x02; 0x01] is 1, // we know that `x & 0xFF` is also 1. if (x & 0xFF00000000000000 > 0) { if (x & 0x8000000000000000 > 0) { result = (result * 0x16A09E667F3BCC909) >> 64; } if (x & 0x4000000000000000 > 0) { result = (result * 0x1306FE0A31B7152DF) >> 64; } if (x & 0x2000000000000000 > 0) { result = (result * 0x1172B83C7D517ADCE) >> 64; } if (x & 0x1000000000000000 > 0) { result = (result * 0x10B5586CF9890F62A) >> 64; } if (x & 0x800000000000000 > 0) { result = (result * 0x1059B0D31585743AE) >> 64; } if (x & 0x400000000000000 > 0) { result = (result * 0x102C9A3E778060EE7) >> 64; } if (x & 0x200000000000000 > 0) { result = (result * 0x10163DA9FB33356D8) >> 64; } if (x & 0x100000000000000 > 0) { result = (result * 0x100B1AFA5ABCBED61) >> 64; } } if (x & 0xFF000000000000 > 0) { if (x & 0x80000000000000 > 0) { result = (result * 0x10058C86DA1C09EA2) >> 64; } if (x & 0x40000000000000 > 0) { result = (result * 0x1002C605E2E8CEC50) >> 64; } if (x & 0x20000000000000 > 0) { result = (result * 0x100162F3904051FA1) >> 64; } if (x & 0x10000000000000 > 0) { result = (result * 0x1000B175EFFDC76BA) >> 64; } if (x & 0x8000000000000 > 0) { result = (result * 0x100058BA01FB9F96D) >> 64; } if (x & 0x4000000000000 > 0) { result = (result * 0x10002C5CC37DA9492) >> 64; } if (x & 0x2000000000000 > 0) { result = (result * 0x1000162E525EE0547) >> 64; } if (x & 0x1000000000000 > 0) { result = (result * 0x10000B17255775C04) >> 64; } } if (x & 0xFF0000000000 > 0) { if (x & 0x800000000000 > 0) { result = (result * 0x1000058B91B5BC9AE) >> 64; } if (x & 0x400000000000 > 0) { result = (result * 0x100002C5C89D5EC6D) >> 64; } if (x & 0x200000000000 > 0) { result = (result * 0x10000162E43F4F831) >> 64; } if (x & 0x100000000000 > 0) { result = (result * 0x100000B1721BCFC9A) >> 64; } if (x & 0x80000000000 > 0) { result = (result * 0x10000058B90CF1E6E) >> 64; } if (x & 0x40000000000 > 0) { result = (result * 0x1000002C5C863B73F) >> 64; } if (x & 0x20000000000 > 0) { result = (result * 0x100000162E430E5A2) >> 64; } if (x & 0x10000000000 > 0) { result = (result * 0x1000000B172183551) >> 64; } } if (x & 0xFF00000000 > 0) { if (x & 0x8000000000 > 0) { result = (result * 0x100000058B90C0B49) >> 64; } if (x & 0x4000000000 > 0) { result = (result * 0x10000002C5C8601CC) >> 64; } if (x & 0x2000000000 > 0) { result = (result * 0x1000000162E42FFF0) >> 64; } if (x & 0x1000000000 > 0) { result = (result * 0x10000000B17217FBB) >> 64; } if (x & 0x800000000 > 0) { result = (result * 0x1000000058B90BFCE) >> 64; } if (x & 0x400000000 > 0) { result = (result * 0x100000002C5C85FE3) >> 64; } if (x & 0x200000000 > 0) { result = (result * 0x10000000162E42FF1) >> 64; } if (x & 0x100000000 > 0) { result = (result * 0x100000000B17217F8) >> 64; } } if (x & 0xFF000000 > 0) { if (x & 0x80000000 > 0) { result = (result * 0x10000000058B90BFC) >> 64; } if (x & 0x40000000 > 0) { result = (result * 0x1000000002C5C85FE) >> 64; } if (x & 0x20000000 > 0) { result = (result * 0x100000000162E42FF) >> 64; } if (x & 0x10000000 > 0) { result = (result * 0x1000000000B17217F) >> 64; } if (x & 0x8000000 > 0) { result = (result * 0x100000000058B90C0) >> 64; } if (x & 0x4000000 > 0) { result = (result * 0x10000000002C5C860) >> 64; } if (x & 0x2000000 > 0) { result = (result * 0x1000000000162E430) >> 64; } if (x & 0x1000000 > 0) { result = (result * 0x10000000000B17218) >> 64; } } if (x & 0xFF0000 > 0) { if (x & 0x800000 > 0) { result = (result * 0x1000000000058B90C) >> 64; } if (x & 0x400000 > 0) { result = (result * 0x100000000002C5C86) >> 64; } if (x & 0x200000 > 0) { result = (result * 0x10000000000162E43) >> 64; } if (x & 0x100000 > 0) { result = (result * 0x100000000000B1721) >> 64; } if (x & 0x80000 > 0) { result = (result * 0x10000000000058B91) >> 64; } if (x & 0x40000 > 0) { result = (result * 0x1000000000002C5C8) >> 64; } if (x & 0x20000 > 0) { result = (result * 0x100000000000162E4) >> 64; } if (x & 0x10000 > 0) { result = (result * 0x1000000000000B172) >> 64; } } if (x & 0xFF00 > 0) { if (x & 0x8000 > 0) { result = (result * 0x100000000000058B9) >> 64; } if (x & 0x4000 > 0) { result = (result * 0x10000000000002C5D) >> 64; } if (x & 0x2000 > 0) { result = (result * 0x1000000000000162E) >> 64; } if (x & 0x1000 > 0) { result = (result * 0x10000000000000B17) >> 64; } if (x & 0x800 > 0) { result = (result * 0x1000000000000058C) >> 64; } if (x & 0x400 > 0) { result = (result * 0x100000000000002C6) >> 64; } if (x & 0x200 > 0) { result = (result * 0x10000000000000163) >> 64; } if (x & 0x100 > 0) { result = (result * 0x100000000000000B1) >> 64; } } if (x & 0xFF > 0) { if (x & 0x80 > 0) { result = (result * 0x10000000000000059) >> 64; } if (x & 0x40 > 0) { result = (result * 0x1000000000000002C) >> 64; } if (x & 0x20 > 0) { result = (result * 0x10000000000000016) >> 64; } if (x & 0x10 > 0) { result = (result * 0x1000000000000000B) >> 64; } if (x & 0x8 > 0) { result = (result * 0x10000000000000006) >> 64; } if (x & 0x4 > 0) { result = (result * 0x10000000000000003) >> 64; } if (x & 0x2 > 0) { result = (result * 0x10000000000000001) >> 64; } if (x & 0x1 > 0) { result = (result * 0x10000000000000001) >> 64; } } // In the code snippet below, two operations are executed simultaneously: // // 1. The result is multiplied by $(2^n + 1)$, where $2^n$ represents the integer part, and the additional 1 // accounts for the initial guess of 0.5. This is achieved by subtracting from 191 instead of 192. // 2. The result is then converted to an unsigned 60.18-decimal fixed-point format. // // The underlying logic is based on the relationship $2^{191-ip} = 2^{ip} / 2^{191}$, where $ip$ denotes the, // integer part, $2^n$. result *= UNIT; result >>= (191 - (x >> 64)); } } /// @notice Finds the zero-based index of the first 1 in the binary representation of x. /// /// @dev See the note on "msb" in this Wikipedia article: https://en.wikipedia.org/wiki/Find_first_set /// /// Each step in this implementation is equivalent to this high-level code: /// /// ```solidity /// if (x >= 2 ** 128) { /// x >>= 128; /// result += 128; /// } /// ``` /// /// Where 128 is replaced with each respective power of two factor. See the full high-level implementation here: /// https://gist.github.com/PaulRBerg/f932f8693f2733e30c4d479e8e980948 /// /// The Yul instructions used below are: /// /// - "gt" is "greater than" /// - "or" is the OR bitwise operator /// - "shl" is "shift left" /// - "shr" is "shift right" /// /// @param x The uint256 number for which to find the index of the most significant bit. /// @return result The index of the most significant bit as a uint256. /// @custom:smtchecker abstract-function-nondet function msb(uint256 x) pure returns (uint256 result) { // 2^128 assembly ("memory-safe") { let factor := shl(7, gt(x, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) x := shr(factor, x) result := or(result, factor) } // 2^64 assembly ("memory-safe") { let factor := shl(6, gt(x, 0xFFFFFFFFFFFFFFFF)) x := shr(factor, x) result := or(result, factor) } // 2^32 assembly ("memory-safe") { let factor := shl(5, gt(x, 0xFFFFFFFF)) x := shr(factor, x) result := or(result, factor) } // 2^16 assembly ("memory-safe") { let factor := shl(4, gt(x, 0xFFFF)) x := shr(factor, x) result := or(result, factor) } // 2^8 assembly ("memory-safe") { let factor := shl(3, gt(x, 0xFF)) x := shr(factor, x) result := or(result, factor) } // 2^4 assembly ("memory-safe") { let factor := shl(2, gt(x, 0xF)) x := shr(factor, x) result := or(result, factor) } // 2^2 assembly ("memory-safe") { let factor := shl(1, gt(x, 0x3)) x := shr(factor, x) result := or(result, factor) } // 2^1 // No need to shift x any more. assembly ("memory-safe") { let factor := gt(x, 0x1) result := or(result, factor) } } /// @notice Calculates x*y÷denominator with 512-bit precision. /// /// @dev Credits to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv. /// /// Notes: /// - The result is rounded toward zero. /// /// Requirements: /// - The denominator must not be zero. /// - The result must fit in uint256. /// /// @param x The multiplicand as a uint256. /// @param y The multiplier as a uint256. /// @param denominator The divisor as a uint256. /// @return result The result as a uint256. /// @custom:smtchecker abstract-function-nondet function mulDiv(uint256 x, uint256 y, uint256 denominator) 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 ("memory-safe") { 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) { unchecked { return prod0 / denominator; } } // Make sure the result is less than 2^256. Also prevents denominator == 0. if (prod1 >= denominator) { revert PRBMath_MulDiv_Overflow(x, y, denominator); } //////////////////////////////////////////////////////////////////////////// // 512 by 256 division //////////////////////////////////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly ("memory-safe") { // Compute remainder using the mulmod Yul instruction. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512-bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } unchecked { // Calculate the largest power of two divisor of the denominator using the unary operator ~. This operation cannot overflow // because the denominator cannot be zero at this point in the function execution. The result is always >= 1. // For more detail, see https://cs.stackexchange.com/q/138556/92363. uint256 lpotdod = denominator & (~denominator + 1); uint256 flippedLpotdod; assembly ("memory-safe") { // Factor powers of two out of denominator. denominator := div(denominator, lpotdod) // Divide [prod1 prod0] by lpotdod. prod0 := div(prod0, lpotdod) // Get the flipped value `2^256 / lpotdod`. If the `lpotdod` is zero, the flipped value is one. // `sub(0, lpotdod)` produces the two's complement version of `lpotdod`, which is equivalent to flipping all the bits. // However, `div` interprets this value as an unsigned value: https://ethereum.stackexchange.com/q/147168/24693 flippedLpotdod := add(div(sub(0, lpotdod), lpotdod), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * flippedLpotdod; // 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; // Use the 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 preconditions 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; } } /// @notice Calculates x*y÷1e18 with 512-bit precision. /// /// @dev A variant of {mulDiv} with constant folding, i.e. in which the denominator is hard coded to 1e18. /// /// Notes: /// - The body is purposely left uncommented; to understand how this works, see the documentation in {mulDiv}. /// - The result is rounded toward zero. /// - We take as an axiom that the result cannot be `MAX_UINT256` when x and y solve the following system of equations: /// /// $$ /// \begin{cases} /// x * y = MAX\_UINT256 * UNIT \\ /// (x * y) \% UNIT \geq \frac{UNIT}{2} /// \end{cases} /// $$ /// /// Requirements: /// - Refer to the requirements in {mulDiv}. /// - The result must fit in uint256. /// /// @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. /// @custom:smtchecker abstract-function-nondet function mulDiv18(uint256 x, uint256 y) pure returns (uint256 result) { uint256 prod0; uint256 prod1; assembly ("memory-safe") { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } if (prod1 == 0) { unchecked { return prod0 / UNIT; } } if (prod1 >= UNIT) { revert PRBMath_MulDiv18_Overflow(x, y); } uint256 remainder; assembly ("memory-safe") { remainder := mulmod(x, y, UNIT) result := mul( or( div(sub(prod0, remainder), UNIT_LPOTD), mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, UNIT_LPOTD), UNIT_LPOTD), 1)) ), UNIT_INVERSE ) } } /// @notice Calculates x*y÷denominator with 512-bit precision. /// /// @dev This is an extension of {mulDiv} for signed numbers, which works by computing the signs and the absolute values separately. /// /// Notes: /// - The result is rounded toward zero. /// /// Requirements: /// - Refer to the requirements in {mulDiv}. /// - None of the inputs can be `type(int256).min`. /// - The result must fit in 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. /// @custom:smtchecker abstract-function-nondet function mulDivSigned(int256 x, int256 y, int256 denominator) pure returns (int256 result) { if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) { revert PRBMath_MulDivSigned_InputTooSmall(); } // Get hold of the absolute values of x, y and the denominator. uint256 xAbs; uint256 yAbs; uint256 dAbs; unchecked { xAbs = x < 0 ? uint256(-x) : uint256(x); yAbs = y < 0 ? uint256(-y) : uint256(y); dAbs = denominator < 0 ? uint256(-denominator) : uint256(denominator); } // Compute the absolute value of x*y÷denominator. The result must fit in int256. uint256 resultAbs = mulDiv(xAbs, yAbs, dAbs); if (resultAbs > uint256(type(int256).max)) { revert PRBMath_MulDivSigned_Overflow(x, y); } // Get the signs of x, y and the denominator. uint256 sx; uint256 sy; uint256 sd; assembly ("memory-safe") { // "sgt" is the "signed greater than" assembly instruction and "sub(0,1)" is -1 in two's complement. sx := sgt(x, sub(0, 1)) sy := sgt(y, sub(0, 1)) sd := sgt(denominator, sub(0, 1)) } // XOR over sx, sy and sd. What this does is to check whether there are 1 or 3 negative signs in the inputs. // If there are, the result should be negative. Otherwise, it should be positive. unchecked { result = sx ^ sy ^ sd == 0 ? -int256(resultAbs) : int256(resultAbs); } } /// @notice Calculates the square root of x using the Babylonian method. /// /// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. /// /// Notes: /// - If x is not a perfect square, the result is rounded down. /// - Credits to OpenZeppelin for the explanations in comments below. /// /// @param x The uint256 number for which to calculate the square root. /// @return result The result as a uint256. /// @custom:smtchecker abstract-function-nondet function sqrt(uint256 x) pure returns (uint256 result) { if (x == 0) { return 0; } // For our first guess, we calculate the biggest power of 2 which is smaller than the square root of x. // // We know that the "msb" (most significant bit) of x is a power of 2 such that we have: // // $$ // msb(x) <= x <= 2*msb(x)$ // $$ // // We write $msb(x)$ as $2^k$, and we get: // // $$ // k = log_2(x) // $$ // // Thus, we can write the initial inequality as: // // $$ // 2^{log_2(x)} <= x <= 2*2^{log_2(x)+1} \\ // sqrt(2^k) <= sqrt(x) < sqrt(2^{k+1}) \\ // 2^{k/2} <= sqrt(x) < 2^{(k+1)/2} <= 2^{(k/2)+1} // $$ // // Consequently, $2^{log_2(x) /2} is a good first approximation of sqrt(x) with at least one correct bit. uint256 xAux = uint256(x); result = 1; if (xAux >= 2 ** 128) { xAux >>= 128; result <<= 64; } if (xAux >= 2 ** 64) { xAux >>= 64; result <<= 32; } if (xAux >= 2 ** 32) { xAux >>= 32; result <<= 16; } if (xAux >= 2 ** 16) { xAux >>= 16; result <<= 8; } if (xAux >= 2 ** 8) { xAux >>= 8; result <<= 4; } if (xAux >= 2 ** 4) { xAux >>= 4; result <<= 2; } if (xAux >= 2 ** 2) { result <<= 1; } // At this point, `result` is an estimation with at least one bit of precision. We know the true value has at // most 128 bits, since it is the square root of a uint256. Newton's method converges quadratically (precision // doubles at every iteration). We thus need at most 7 iteration to turn our partial result with one bit of // precision into the expected uint128 result. 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; // If x is not a perfect square, round the result toward zero. uint256 roundedResult = x / result; if (result >= roundedResult) { result = roundedResult; } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "../Common.sol" as Common; import "./Errors.sol" as CastingErrors; import { SD59x18 } from "../sd59x18/ValueType.sol"; import { UD2x18 } from "../ud2x18/ValueType.sol"; import { UD60x18 } from "../ud60x18/ValueType.sol"; import { SD1x18 } from "./ValueType.sol"; /// @notice Casts an SD1x18 number into SD59x18. /// @dev There is no overflow check because the domain of SD1x18 is a subset of SD59x18. function intoSD59x18(SD1x18 x) pure returns (SD59x18 result) { result = SD59x18.wrap(int256(SD1x18.unwrap(x))); } /// @notice Casts an SD1x18 number into UD2x18. /// - x must be positive. function intoUD2x18(SD1x18 x) pure returns (UD2x18 result) { int64 xInt = SD1x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD1x18_ToUD2x18_Underflow(x); } result = UD2x18.wrap(uint64(xInt)); } /// @notice Casts an SD1x18 number into UD60x18. /// @dev Requirements: /// - x must be positive. function intoUD60x18(SD1x18 x) pure returns (UD60x18 result) { int64 xInt = SD1x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD1x18_ToUD60x18_Underflow(x); } result = UD60x18.wrap(uint64(xInt)); } /// @notice Casts an SD1x18 number into uint256. /// @dev Requirements: /// - x must be positive. function intoUint256(SD1x18 x) pure returns (uint256 result) { int64 xInt = SD1x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD1x18_ToUint256_Underflow(x); } result = uint256(uint64(xInt)); } /// @notice Casts an SD1x18 number into uint128. /// @dev Requirements: /// - x must be positive. function intoUint128(SD1x18 x) pure returns (uint128 result) { int64 xInt = SD1x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD1x18_ToUint128_Underflow(x); } result = uint128(uint64(xInt)); } /// @notice Casts an SD1x18 number into uint40. /// @dev Requirements: /// - x must be positive. /// - x must be less than or equal to `MAX_UINT40`. function intoUint40(SD1x18 x) pure returns (uint40 result) { int64 xInt = SD1x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD1x18_ToUint40_Underflow(x); } if (xInt > int64(uint64(Common.MAX_UINT40))) { revert CastingErrors.PRBMath_SD1x18_ToUint40_Overflow(x); } result = uint40(uint64(xInt)); } /// @notice Alias for {wrap}. function sd1x18(int64 x) pure returns (SD1x18 result) { result = SD1x18.wrap(x); } /// @notice Unwraps an SD1x18 number into int64. function unwrap(SD1x18 x) pure returns (int64 result) { result = SD1x18.unwrap(x); } /// @notice Wraps an int64 number into SD1x18. function wrap(int64 x) pure returns (SD1x18 result) { result = SD1x18.wrap(x); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { SD1x18 } from "./ValueType.sol"; /// @dev Euler's number as an SD1x18 number. SD1x18 constant E = SD1x18.wrap(2_718281828459045235); /// @dev The maximum value an SD1x18 number can have. int64 constant uMAX_SD1x18 = 9_223372036854775807; SD1x18 constant MAX_SD1x18 = SD1x18.wrap(uMAX_SD1x18); /// @dev The maximum value an SD1x18 number can have. int64 constant uMIN_SD1x18 = -9_223372036854775808; SD1x18 constant MIN_SD1x18 = SD1x18.wrap(uMIN_SD1x18); /// @dev PI as an SD1x18 number. SD1x18 constant PI = SD1x18.wrap(3_141592653589793238); /// @dev The unit number, which gives the decimal precision of SD1x18. SD1x18 constant UNIT = SD1x18.wrap(1e18); int256 constant uUNIT = 1e18;
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { SD1x18 } from "./ValueType.sol"; /// @notice Thrown when trying to cast a SD1x18 number that doesn't fit in UD2x18. error PRBMath_SD1x18_ToUD2x18_Underflow(SD1x18 x); /// @notice Thrown when trying to cast a SD1x18 number that doesn't fit in UD60x18. error PRBMath_SD1x18_ToUD60x18_Underflow(SD1x18 x); /// @notice Thrown when trying to cast a SD1x18 number that doesn't fit in uint128. error PRBMath_SD1x18_ToUint128_Underflow(SD1x18 x); /// @notice Thrown when trying to cast a SD1x18 number that doesn't fit in uint256. error PRBMath_SD1x18_ToUint256_Underflow(SD1x18 x); /// @notice Thrown when trying to cast a SD1x18 number that doesn't fit in uint40. error PRBMath_SD1x18_ToUint40_Overflow(SD1x18 x); /// @notice Thrown when trying to cast a SD1x18 number that doesn't fit in uint40. error PRBMath_SD1x18_ToUint40_Underflow(SD1x18 x);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "./Casting.sol" as Casting; /// @notice The signed 1.18-decimal fixed-point number representation, which can have up to 1 digit and up to 18 /// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity /// type int64. This is useful when end users want to use int64 to save gas, e.g. with tight variable packing in contract /// storage. type SD1x18 is int64; /*////////////////////////////////////////////////////////////////////////// CASTING //////////////////////////////////////////////////////////////////////////*/ using { Casting.intoSD59x18, Casting.intoUD2x18, Casting.intoUD60x18, Casting.intoUint256, Casting.intoUint128, Casting.intoUint40, Casting.unwrap } for SD1x18 global;
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "./Errors.sol" as CastingErrors; import { MAX_UINT128, MAX_UINT40 } from "../Common.sol"; import { uMAX_SD1x18, uMIN_SD1x18 } from "../sd1x18/Constants.sol"; import { SD1x18 } from "../sd1x18/ValueType.sol"; import { uMAX_UD2x18 } from "../ud2x18/Constants.sol"; import { UD2x18 } from "../ud2x18/ValueType.sol"; import { UD60x18 } from "../ud60x18/ValueType.sol"; import { SD59x18 } from "./ValueType.sol"; /// @notice Casts an SD59x18 number into int256. /// @dev This is basically a functional alias for {unwrap}. function intoInt256(SD59x18 x) pure returns (int256 result) { result = SD59x18.unwrap(x); } /// @notice Casts an SD59x18 number into SD1x18. /// @dev Requirements: /// - x must be greater than or equal to `uMIN_SD1x18`. /// - x must be less than or equal to `uMAX_SD1x18`. function intoSD1x18(SD59x18 x) pure returns (SD1x18 result) { int256 xInt = SD59x18.unwrap(x); if (xInt < uMIN_SD1x18) { revert CastingErrors.PRBMath_SD59x18_IntoSD1x18_Underflow(x); } if (xInt > uMAX_SD1x18) { revert CastingErrors.PRBMath_SD59x18_IntoSD1x18_Overflow(x); } result = SD1x18.wrap(int64(xInt)); } /// @notice Casts an SD59x18 number into UD2x18. /// @dev Requirements: /// - x must be positive. /// - x must be less than or equal to `uMAX_UD2x18`. function intoUD2x18(SD59x18 x) pure returns (UD2x18 result) { int256 xInt = SD59x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD59x18_IntoUD2x18_Underflow(x); } if (xInt > int256(uint256(uMAX_UD2x18))) { revert CastingErrors.PRBMath_SD59x18_IntoUD2x18_Overflow(x); } result = UD2x18.wrap(uint64(uint256(xInt))); } /// @notice Casts an SD59x18 number into UD60x18. /// @dev Requirements: /// - x must be positive. function intoUD60x18(SD59x18 x) pure returns (UD60x18 result) { int256 xInt = SD59x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD59x18_IntoUD60x18_Underflow(x); } result = UD60x18.wrap(uint256(xInt)); } /// @notice Casts an SD59x18 number into uint256. /// @dev Requirements: /// - x must be positive. function intoUint256(SD59x18 x) pure returns (uint256 result) { int256 xInt = SD59x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD59x18_IntoUint256_Underflow(x); } result = uint256(xInt); } /// @notice Casts an SD59x18 number into uint128. /// @dev Requirements: /// - x must be positive. /// - x must be less than or equal to `uMAX_UINT128`. function intoUint128(SD59x18 x) pure returns (uint128 result) { int256 xInt = SD59x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD59x18_IntoUint128_Underflow(x); } if (xInt > int256(uint256(MAX_UINT128))) { revert CastingErrors.PRBMath_SD59x18_IntoUint128_Overflow(x); } result = uint128(uint256(xInt)); } /// @notice Casts an SD59x18 number into uint40. /// @dev Requirements: /// - x must be positive. /// - x must be less than or equal to `MAX_UINT40`. function intoUint40(SD59x18 x) pure returns (uint40 result) { int256 xInt = SD59x18.unwrap(x); if (xInt < 0) { revert CastingErrors.PRBMath_SD59x18_IntoUint40_Underflow(x); } if (xInt > int256(uint256(MAX_UINT40))) { revert CastingErrors.PRBMath_SD59x18_IntoUint40_Overflow(x); } result = uint40(uint256(xInt)); } /// @notice Alias for {wrap}. function sd(int256 x) pure returns (SD59x18 result) { result = SD59x18.wrap(x); } /// @notice Alias for {wrap}. function sd59x18(int256 x) pure returns (SD59x18 result) { result = SD59x18.wrap(x); } /// @notice Unwraps an SD59x18 number into int256. function unwrap(SD59x18 x) pure returns (int256 result) { result = SD59x18.unwrap(x); } /// @notice Wraps an int256 number into SD59x18. function wrap(int256 x) pure returns (SD59x18 result) { result = SD59x18.wrap(x); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { SD59x18 } from "./ValueType.sol"; // NOTICE: the "u" prefix stands for "unwrapped". /// @dev Euler's number as an SD59x18 number. SD59x18 constant E = SD59x18.wrap(2_718281828459045235); /// @dev The maximum input permitted in {exp}. int256 constant uEXP_MAX_INPUT = 133_084258667509499440; SD59x18 constant EXP_MAX_INPUT = SD59x18.wrap(uEXP_MAX_INPUT); /// @dev The maximum input permitted in {exp2}. int256 constant uEXP2_MAX_INPUT = 192e18 - 1; SD59x18 constant EXP2_MAX_INPUT = SD59x18.wrap(uEXP2_MAX_INPUT); /// @dev Half the UNIT number. int256 constant uHALF_UNIT = 0.5e18; SD59x18 constant HALF_UNIT = SD59x18.wrap(uHALF_UNIT); /// @dev $log_2(10)$ as an SD59x18 number. int256 constant uLOG2_10 = 3_321928094887362347; SD59x18 constant LOG2_10 = SD59x18.wrap(uLOG2_10); /// @dev $log_2(e)$ as an SD59x18 number. int256 constant uLOG2_E = 1_442695040888963407; SD59x18 constant LOG2_E = SD59x18.wrap(uLOG2_E); /// @dev The maximum value an SD59x18 number can have. int256 constant uMAX_SD59x18 = 57896044618658097711785492504343953926634992332820282019728_792003956564819967; SD59x18 constant MAX_SD59x18 = SD59x18.wrap(uMAX_SD59x18); /// @dev The maximum whole value an SD59x18 number can have. int256 constant uMAX_WHOLE_SD59x18 = 57896044618658097711785492504343953926634992332820282019728_000000000000000000; SD59x18 constant MAX_WHOLE_SD59x18 = SD59x18.wrap(uMAX_WHOLE_SD59x18); /// @dev The minimum value an SD59x18 number can have. int256 constant uMIN_SD59x18 = -57896044618658097711785492504343953926634992332820282019728_792003956564819968; SD59x18 constant MIN_SD59x18 = SD59x18.wrap(uMIN_SD59x18); /// @dev The minimum whole value an SD59x18 number can have. int256 constant uMIN_WHOLE_SD59x18 = -57896044618658097711785492504343953926634992332820282019728_000000000000000000; SD59x18 constant MIN_WHOLE_SD59x18 = SD59x18.wrap(uMIN_WHOLE_SD59x18); /// @dev PI as an SD59x18 number. SD59x18 constant PI = SD59x18.wrap(3_141592653589793238); /// @dev The unit number, which gives the decimal precision of SD59x18. int256 constant uUNIT = 1e18; SD59x18 constant UNIT = SD59x18.wrap(1e18); /// @dev The unit number squared. int256 constant uUNIT_SQUARED = 1e36; SD59x18 constant UNIT_SQUARED = SD59x18.wrap(uUNIT_SQUARED); /// @dev Zero as an SD59x18 number. SD59x18 constant ZERO = SD59x18.wrap(0);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { SD59x18 } from "./ValueType.sol"; /// @notice Thrown when taking the absolute value of `MIN_SD59x18`. error PRBMath_SD59x18_Abs_MinSD59x18(); /// @notice Thrown when ceiling a number overflows SD59x18. error PRBMath_SD59x18_Ceil_Overflow(SD59x18 x); /// @notice Thrown when converting a basic integer to the fixed-point format overflows SD59x18. error PRBMath_SD59x18_Convert_Overflow(int256 x); /// @notice Thrown when converting a basic integer to the fixed-point format underflows SD59x18. error PRBMath_SD59x18_Convert_Underflow(int256 x); /// @notice Thrown when dividing two numbers and one of them is `MIN_SD59x18`. error PRBMath_SD59x18_Div_InputTooSmall(); /// @notice Thrown when dividing two numbers and one of the intermediary unsigned results overflows SD59x18. error PRBMath_SD59x18_Div_Overflow(SD59x18 x, SD59x18 y); /// @notice Thrown when taking the natural exponent of a base greater than 133_084258667509499441. error PRBMath_SD59x18_Exp_InputTooBig(SD59x18 x); /// @notice Thrown when taking the binary exponent of a base greater than 192e18. error PRBMath_SD59x18_Exp2_InputTooBig(SD59x18 x); /// @notice Thrown when flooring a number underflows SD59x18. error PRBMath_SD59x18_Floor_Underflow(SD59x18 x); /// @notice Thrown when taking the geometric mean of two numbers and their product is negative. error PRBMath_SD59x18_Gm_NegativeProduct(SD59x18 x, SD59x18 y); /// @notice Thrown when taking the geometric mean of two numbers and multiplying them overflows SD59x18. error PRBMath_SD59x18_Gm_Overflow(SD59x18 x, SD59x18 y); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD1x18. error PRBMath_SD59x18_IntoSD1x18_Overflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD1x18. error PRBMath_SD59x18_IntoSD1x18_Underflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD2x18. error PRBMath_SD59x18_IntoUD2x18_Overflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD2x18. error PRBMath_SD59x18_IntoUD2x18_Underflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD60x18. error PRBMath_SD59x18_IntoUD60x18_Underflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint128. error PRBMath_SD59x18_IntoUint128_Overflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint128. error PRBMath_SD59x18_IntoUint128_Underflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint256. error PRBMath_SD59x18_IntoUint256_Underflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint40. error PRBMath_SD59x18_IntoUint40_Overflow(SD59x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint40. error PRBMath_SD59x18_IntoUint40_Underflow(SD59x18 x); /// @notice Thrown when taking the logarithm of a number less than or equal to zero. error PRBMath_SD59x18_Log_InputTooSmall(SD59x18 x); /// @notice Thrown when multiplying two numbers and one of the inputs is `MIN_SD59x18`. error PRBMath_SD59x18_Mul_InputTooSmall(); /// @notice Thrown when multiplying two numbers and the intermediary absolute result overflows SD59x18. error PRBMath_SD59x18_Mul_Overflow(SD59x18 x, SD59x18 y); /// @notice Thrown when raising a number to a power and the intermediary absolute result overflows SD59x18. error PRBMath_SD59x18_Powu_Overflow(SD59x18 x, uint256 y); /// @notice Thrown when taking the square root of a negative number. error PRBMath_SD59x18_Sqrt_NegativeInput(SD59x18 x); /// @notice Thrown when the calculating the square root overflows SD59x18. error PRBMath_SD59x18_Sqrt_Overflow(SD59x18 x);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { wrap } from "./Casting.sol"; import { SD59x18 } from "./ValueType.sol"; /// @notice Implements the checked addition operation (+) in the SD59x18 type. function add(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { return wrap(x.unwrap() + y.unwrap()); } /// @notice Implements the AND (&) bitwise operation in the SD59x18 type. function and(SD59x18 x, int256 bits) pure returns (SD59x18 result) { return wrap(x.unwrap() & bits); } /// @notice Implements the AND (&) bitwise operation in the SD59x18 type. function and2(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { return wrap(x.unwrap() & y.unwrap()); } /// @notice Implements the equal (=) operation in the SD59x18 type. function eq(SD59x18 x, SD59x18 y) pure returns (bool result) { result = x.unwrap() == y.unwrap(); } /// @notice Implements the greater than operation (>) in the SD59x18 type. function gt(SD59x18 x, SD59x18 y) pure returns (bool result) { result = x.unwrap() > y.unwrap(); } /// @notice Implements the greater than or equal to operation (>=) in the SD59x18 type. function gte(SD59x18 x, SD59x18 y) pure returns (bool result) { result = x.unwrap() >= y.unwrap(); } /// @notice Implements a zero comparison check function in the SD59x18 type. function isZero(SD59x18 x) pure returns (bool result) { result = x.unwrap() == 0; } /// @notice Implements the left shift operation (<<) in the SD59x18 type. function lshift(SD59x18 x, uint256 bits) pure returns (SD59x18 result) { result = wrap(x.unwrap() << bits); } /// @notice Implements the lower than operation (<) in the SD59x18 type. function lt(SD59x18 x, SD59x18 y) pure returns (bool result) { result = x.unwrap() < y.unwrap(); } /// @notice Implements the lower than or equal to operation (<=) in the SD59x18 type. function lte(SD59x18 x, SD59x18 y) pure returns (bool result) { result = x.unwrap() <= y.unwrap(); } /// @notice Implements the unchecked modulo operation (%) in the SD59x18 type. function mod(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { result = wrap(x.unwrap() % y.unwrap()); } /// @notice Implements the not equal operation (!=) in the SD59x18 type. function neq(SD59x18 x, SD59x18 y) pure returns (bool result) { result = x.unwrap() != y.unwrap(); } /// @notice Implements the NOT (~) bitwise operation in the SD59x18 type. function not(SD59x18 x) pure returns (SD59x18 result) { result = wrap(~x.unwrap()); } /// @notice Implements the OR (|) bitwise operation in the SD59x18 type. function or(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { result = wrap(x.unwrap() | y.unwrap()); } /// @notice Implements the right shift operation (>>) in the SD59x18 type. function rshift(SD59x18 x, uint256 bits) pure returns (SD59x18 result) { result = wrap(x.unwrap() >> bits); } /// @notice Implements the checked subtraction operation (-) in the SD59x18 type. function sub(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { result = wrap(x.unwrap() - y.unwrap()); } /// @notice Implements the checked unary minus operation (-) in the SD59x18 type. function unary(SD59x18 x) pure returns (SD59x18 result) { result = wrap(-x.unwrap()); } /// @notice Implements the unchecked addition operation (+) in the SD59x18 type. function uncheckedAdd(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { unchecked { result = wrap(x.unwrap() + y.unwrap()); } } /// @notice Implements the unchecked subtraction operation (-) in the SD59x18 type. function uncheckedSub(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { unchecked { result = wrap(x.unwrap() - y.unwrap()); } } /// @notice Implements the unchecked unary minus operation (-) in the SD59x18 type. function uncheckedUnary(SD59x18 x) pure returns (SD59x18 result) { unchecked { result = wrap(-x.unwrap()); } } /// @notice Implements the XOR (^) bitwise operation in the SD59x18 type. function xor(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { result = wrap(x.unwrap() ^ y.unwrap()); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "../Common.sol" as Common; import "./Errors.sol" as Errors; import { uEXP_MAX_INPUT, uEXP2_MAX_INPUT, uHALF_UNIT, uLOG2_10, uLOG2_E, uMAX_SD59x18, uMAX_WHOLE_SD59x18, uMIN_SD59x18, uMIN_WHOLE_SD59x18, UNIT, uUNIT, uUNIT_SQUARED, ZERO } from "./Constants.sol"; import { wrap } from "./Helpers.sol"; import { SD59x18 } from "./ValueType.sol"; /// @notice Calculates the absolute value of x. /// /// @dev Requirements: /// - x must be greater than `MIN_SD59x18`. /// /// @param x The SD59x18 number for which to calculate the absolute value. /// @param result The absolute value of x as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function abs(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt == uMIN_SD59x18) { revert Errors.PRBMath_SD59x18_Abs_MinSD59x18(); } result = xInt < 0 ? wrap(-xInt) : x; } /// @notice Calculates the arithmetic average of x and y. /// /// @dev Notes: /// - The result is rounded toward zero. /// /// @param x The first operand as an SD59x18 number. /// @param y The second operand as an SD59x18 number. /// @return result The arithmetic average as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function avg(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); int256 yInt = y.unwrap(); unchecked { // This operation is equivalent to `x / 2 + y / 2`, and it can never overflow. int256 sum = (xInt >> 1) + (yInt >> 1); if (sum < 0) { // If at least one of x and y is odd, add 1 to the result, because shifting negative numbers to the right // rounds toward negative infinity. The right part is equivalent to `sum + (x % 2 == 1 || y % 2 == 1)`. assembly ("memory-safe") { result := add(sum, and(or(xInt, yInt), 1)) } } else { // Add 1 if both x and y are odd to account for the double 0.5 remainder truncated after shifting. result = wrap(sum + (xInt & yInt & 1)); } } } /// @notice Yields the smallest whole number greater than or equal to x. /// /// @dev Optimized for fractional value inputs, because every whole value has (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 SD59x18 number to ceil. /// @param result The smallest whole number greater than or equal to x, as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function ceil(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt > uMAX_WHOLE_SD59x18) { revert Errors.PRBMath_SD59x18_Ceil_Overflow(x); } int256 remainder = xInt % uUNIT; if (remainder == 0) { result = x; } else { unchecked { // Solidity uses C fmod style, which returns a modulus with the same sign as x. int256 resultInt = xInt - remainder; if (xInt > 0) { resultInt += uUNIT; } result = wrap(resultInt); } } } /// @notice Divides two SD59x18 numbers, returning a new SD59x18 number. /// /// @dev This is an extension of {Common.mulDiv} for signed numbers, which works by computing the signs and the absolute /// values separately. /// /// Notes: /// - Refer to the notes in {Common.mulDiv}. /// - The result is rounded toward zero. /// /// Requirements: /// - Refer to the requirements in {Common.mulDiv}. /// - None of the inputs can be `MIN_SD59x18`. /// - The denominator must not be zero. /// - The result must fit in SD59x18. /// /// @param x The numerator as an SD59x18 number. /// @param y The denominator as an SD59x18 number. /// @param result The quotient as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function div(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); int256 yInt = y.unwrap(); if (xInt == uMIN_SD59x18 || yInt == uMIN_SD59x18) { revert Errors.PRBMath_SD59x18_Div_InputTooSmall(); } // Get hold of the absolute values of x and y. uint256 xAbs; uint256 yAbs; unchecked { xAbs = xInt < 0 ? uint256(-xInt) : uint256(xInt); yAbs = yInt < 0 ? uint256(-yInt) : uint256(yInt); } // Compute the absolute value (x*UNIT÷y). The resulting value must fit in SD59x18. uint256 resultAbs = Common.mulDiv(xAbs, uint256(uUNIT), yAbs); if (resultAbs > uint256(uMAX_SD59x18)) { revert Errors.PRBMath_SD59x18_Div_Overflow(x, y); } // Check if x and y have the same sign using two's complement representation. The left-most bit represents the sign (1 for // negative, 0 for positive or zero). bool sameSign = (xInt ^ yInt) > -1; // If the inputs have the same sign, the result should be positive. Otherwise, it should be negative. unchecked { result = wrap(sameSign ? int256(resultAbs) : -int256(resultAbs)); } } /// @notice Calculates the natural exponent of x using the following formula: /// /// $$ /// e^x = 2^{x * log_2{e}} /// $$ /// /// @dev Notes: /// - Refer to the notes in {exp2}. /// /// Requirements: /// - Refer to the requirements in {exp2}. /// - x must be less than 133_084258667509499441. /// /// @param x The exponent as an SD59x18 number. /// @return result The result as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function exp(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); // This check prevents values greater than 192e18 from being passed to {exp2}. if (xInt > uEXP_MAX_INPUT) { revert Errors.PRBMath_SD59x18_Exp_InputTooBig(x); } unchecked { // Inline the fixed-point multiplication to save gas. int256 doubleUnitProduct = xInt * uLOG2_E; result = exp2(wrap(doubleUnitProduct / uUNIT)); } } /// @notice Calculates the binary exponent of x using the binary fraction method using the following formula: /// /// $$ /// 2^{-x} = \frac{1}{2^x} /// $$ /// /// @dev See https://ethereum.stackexchange.com/q/79903/24693. /// /// Notes: /// - If x is less than -59_794705707972522261, the result is zero. /// /// Requirements: /// - x must be less than 192e18. /// - The result must fit in SD59x18. /// /// @param x The exponent as an SD59x18 number. /// @return result The result as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function exp2(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt < 0) { // The inverse of any number less than this is truncated to zero. if (xInt < -59_794705707972522261) { return ZERO; } unchecked { // Inline the fixed-point inversion to save gas. result = wrap(uUNIT_SQUARED / exp2(wrap(-xInt)).unwrap()); } } else { // Numbers greater than or equal to 192e18 don't fit in the 192.64-bit format. if (xInt > uEXP2_MAX_INPUT) { revert Errors.PRBMath_SD59x18_Exp2_InputTooBig(x); } unchecked { // Convert x to the 192.64-bit fixed-point format. uint256 x_192x64 = uint256((xInt << 64) / uUNIT); // It is safe to cast the result to int256 due to the checks above. result = wrap(int256(Common.exp2(x_192x64))); } } } /// @notice Yields the greatest whole number less than or equal to x. /// /// @dev Optimized 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 SD59x18 number to floor. /// @param result The greatest whole number less than or equal to x, as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function floor(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt < uMIN_WHOLE_SD59x18) { revert Errors.PRBMath_SD59x18_Floor_Underflow(x); } int256 remainder = xInt % uUNIT; if (remainder == 0) { result = x; } else { unchecked { // Solidity uses C fmod style, which returns a modulus with the same sign as x. int256 resultInt = xInt - remainder; if (xInt < 0) { resultInt -= uUNIT; } result = wrap(resultInt); } } } /// @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 SD59x18 number to get the fractional part of. /// @param result The fractional part of x as an SD59x18 number. function frac(SD59x18 x) pure returns (SD59x18 result) { result = wrap(x.unwrap() % uUNIT); } /// @notice Calculates the geometric mean of x and y, i.e. $\sqrt{x * y}$. /// /// @dev Notes: /// - The result is rounded toward zero. /// /// Requirements: /// - x * y must fit in SD59x18. /// - x * y must not be negative, since complex numbers are not supported. /// /// @param x The first operand as an SD59x18 number. /// @param y The second operand as an SD59x18 number. /// @return result The result as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function gm(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); int256 yInt = y.unwrap(); if (xInt == 0 || yInt == 0) { return ZERO; } unchecked { // Equivalent to `xy / x != y`. Checking for overflow this way is faster than letting Solidity do it. int256 xyInt = xInt * yInt; if (xyInt / xInt != yInt) { revert Errors.PRBMath_SD59x18_Gm_Overflow(x, y); } // The product must not be negative, since complex numbers are not supported. if (xyInt < 0) { revert Errors.PRBMath_SD59x18_Gm_NegativeProduct(x, y); } // We don't need to multiply the result by `UNIT` here because the x*y product picked up a factor of `UNIT` // during multiplication. See the comments in {Common.sqrt}. uint256 resultUint = Common.sqrt(uint256(xyInt)); result = wrap(int256(resultUint)); } } /// @notice Calculates the inverse of x. /// /// @dev Notes: /// - The result is rounded toward zero. /// /// Requirements: /// - x must not be zero. /// /// @param x The SD59x18 number for which to calculate the inverse. /// @return result The inverse as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function inv(SD59x18 x) pure returns (SD59x18 result) { result = wrap(uUNIT_SQUARED / x.unwrap()); } /// @notice Calculates the natural logarithm of x using the following formula: /// /// $$ /// ln{x} = log_2{x} / log_2{e} /// $$ /// /// @dev Notes: /// - Refer to the notes in {log2}. /// - The precision isn't sufficiently fine-grained to return exactly `UNIT` when the input is `E`. /// /// Requirements: /// - Refer to the requirements in {log2}. /// /// @param x The SD59x18 number for which to calculate the natural logarithm. /// @return result The natural logarithm as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function ln(SD59x18 x) pure returns (SD59x18 result) { // Inline the fixed-point multiplication to save gas. This is overflow-safe because the maximum value that // {log2} can return is ~195_205294292027477728. result = wrap(log2(x).unwrap() * uUNIT / uLOG2_E); } /// @notice Calculates the common logarithm of x using the following formula: /// /// $$ /// log_{10}{x} = log_2{x} / log_2{10} /// $$ /// /// However, if x is an exact power of ten, a hard coded value is returned. /// /// @dev Notes: /// - Refer to the notes in {log2}. /// /// Requirements: /// - Refer to the requirements in {log2}. /// /// @param x The SD59x18 number for which to calculate the common logarithm. /// @return result The common logarithm as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function log10(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt < 0) { revert Errors.PRBMath_SD59x18_Log_InputTooSmall(x); } // Note that the `mul` in this block is the standard multiplication operation, not {SD59x18.mul}. // prettier-ignore assembly ("memory-safe") { switch x case 1 { result := mul(uUNIT, sub(0, 18)) } case 10 { result := mul(uUNIT, sub(1, 18)) } case 100 { result := mul(uUNIT, sub(2, 18)) } case 1000 { result := mul(uUNIT, sub(3, 18)) } case 10000 { result := mul(uUNIT, sub(4, 18)) } case 100000 { result := mul(uUNIT, sub(5, 18)) } case 1000000 { result := mul(uUNIT, sub(6, 18)) } case 10000000 { result := mul(uUNIT, sub(7, 18)) } case 100000000 { result := mul(uUNIT, sub(8, 18)) } case 1000000000 { result := mul(uUNIT, sub(9, 18)) } case 10000000000 { result := mul(uUNIT, sub(10, 18)) } case 100000000000 { result := mul(uUNIT, sub(11, 18)) } case 1000000000000 { result := mul(uUNIT, sub(12, 18)) } case 10000000000000 { result := mul(uUNIT, sub(13, 18)) } case 100000000000000 { result := mul(uUNIT, sub(14, 18)) } case 1000000000000000 { result := mul(uUNIT, sub(15, 18)) } case 10000000000000000 { result := mul(uUNIT, sub(16, 18)) } case 100000000000000000 { result := mul(uUNIT, sub(17, 18)) } case 1000000000000000000 { result := 0 } case 10000000000000000000 { result := uUNIT } case 100000000000000000000 { result := mul(uUNIT, 2) } case 1000000000000000000000 { result := mul(uUNIT, 3) } case 10000000000000000000000 { result := mul(uUNIT, 4) } case 100000000000000000000000 { result := mul(uUNIT, 5) } case 1000000000000000000000000 { result := mul(uUNIT, 6) } case 10000000000000000000000000 { result := mul(uUNIT, 7) } case 100000000000000000000000000 { result := mul(uUNIT, 8) } case 1000000000000000000000000000 { result := mul(uUNIT, 9) } case 10000000000000000000000000000 { result := mul(uUNIT, 10) } case 100000000000000000000000000000 { result := mul(uUNIT, 11) } case 1000000000000000000000000000000 { result := mul(uUNIT, 12) } case 10000000000000000000000000000000 { result := mul(uUNIT, 13) } case 100000000000000000000000000000000 { result := mul(uUNIT, 14) } case 1000000000000000000000000000000000 { result := mul(uUNIT, 15) } case 10000000000000000000000000000000000 { result := mul(uUNIT, 16) } case 100000000000000000000000000000000000 { result := mul(uUNIT, 17) } case 1000000000000000000000000000000000000 { result := mul(uUNIT, 18) } case 10000000000000000000000000000000000000 { result := mul(uUNIT, 19) } case 100000000000000000000000000000000000000 { result := mul(uUNIT, 20) } case 1000000000000000000000000000000000000000 { result := mul(uUNIT, 21) } case 10000000000000000000000000000000000000000 { result := mul(uUNIT, 22) } case 100000000000000000000000000000000000000000 { result := mul(uUNIT, 23) } case 1000000000000000000000000000000000000000000 { result := mul(uUNIT, 24) } case 10000000000000000000000000000000000000000000 { result := mul(uUNIT, 25) } case 100000000000000000000000000000000000000000000 { result := mul(uUNIT, 26) } case 1000000000000000000000000000000000000000000000 { result := mul(uUNIT, 27) } case 10000000000000000000000000000000000000000000000 { result := mul(uUNIT, 28) } case 100000000000000000000000000000000000000000000000 { result := mul(uUNIT, 29) } case 1000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 30) } case 10000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 31) } case 100000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 32) } case 1000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 33) } case 10000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 34) } case 100000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 35) } case 1000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 36) } case 10000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 37) } case 100000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 38) } case 1000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 39) } case 10000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 40) } case 100000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 41) } case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 42) } case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 43) } case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 44) } case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 45) } case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 46) } case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 47) } case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 48) } case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 49) } case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 50) } case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 51) } case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 52) } case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 53) } case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 54) } case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 55) } case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 56) } case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 57) } case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 58) } default { result := uMAX_SD59x18 } } if (result.unwrap() == uMAX_SD59x18) { unchecked { // Inline the fixed-point division to save gas. result = wrap(log2(x).unwrap() * uUNIT / uLOG2_10); } } } /// @notice Calculates the binary logarithm of x using the iterative approximation algorithm: /// /// $$ /// log_2{x} = n + log_2{y}, \text{ where } y = x*2^{-n}, \ y \in [1, 2) /// $$ /// /// For $0 \leq x \lt 1$, the input is inverted: /// /// $$ /// log_2{x} = -log_2{\frac{1}{x}} /// $$ /// /// @dev See https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation. /// /// Notes: /// - Due to the lossy precision of the iterative approximation, the results are not perfectly accurate to the last decimal. /// /// Requirements: /// - x must be greater than zero. /// /// @param x The SD59x18 number for which to calculate the binary logarithm. /// @return result The binary logarithm as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function log2(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt <= 0) { revert Errors.PRBMath_SD59x18_Log_InputTooSmall(x); } unchecked { int256 sign; if (xInt >= uUNIT) { sign = 1; } else { sign = -1; // Inline the fixed-point inversion to save gas. xInt = uUNIT_SQUARED / xInt; } // Calculate the integer part of the logarithm. uint256 n = Common.msb(uint256(xInt / uUNIT)); // This is the integer part of the logarithm as an SD59x18 number. The operation can't overflow // because n is at most 255, `UNIT` is 1e18, and the sign is either 1 or -1. int256 resultInt = int256(n) * uUNIT; // Calculate $y = x * 2^{-n}$. int256 y = xInt >> n; // If y is the unit number, the fractional part is zero. if (y == uUNIT) { return wrap(resultInt * sign); } // Calculate the fractional part via the iterative approximation. // The `delta >>= 1` part is equivalent to `delta /= 2`, but shifting bits is more gas efficient. int256 DOUBLE_UNIT = 2e18; for (int256 delta = uHALF_UNIT; delta > 0; delta >>= 1) { y = (y * y) / uUNIT; // Is y^2 >= 2e18 and so in the range [2e18, 4e18)? if (y >= DOUBLE_UNIT) { // Add the 2^{-m} factor to the logarithm. resultInt = resultInt + delta; // Halve y, which corresponds to z/2 in the Wikipedia article. y >>= 1; } } resultInt *= sign; result = wrap(resultInt); } } /// @notice Multiplies two SD59x18 numbers together, returning a new SD59x18 number. /// /// @dev Notes: /// - Refer to the notes in {Common.mulDiv18}. /// /// Requirements: /// - Refer to the requirements in {Common.mulDiv18}. /// - None of the inputs can be `MIN_SD59x18`. /// - The result must fit in SD59x18. /// /// @param x The multiplicand as an SD59x18 number. /// @param y The multiplier as an SD59x18 number. /// @return result The product as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function mul(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); int256 yInt = y.unwrap(); if (xInt == uMIN_SD59x18 || yInt == uMIN_SD59x18) { revert Errors.PRBMath_SD59x18_Mul_InputTooSmall(); } // Get hold of the absolute values of x and y. uint256 xAbs; uint256 yAbs; unchecked { xAbs = xInt < 0 ? uint256(-xInt) : uint256(xInt); yAbs = yInt < 0 ? uint256(-yInt) : uint256(yInt); } // Compute the absolute value (x*y÷UNIT). The resulting value must fit in SD59x18. uint256 resultAbs = Common.mulDiv18(xAbs, yAbs); if (resultAbs > uint256(uMAX_SD59x18)) { revert Errors.PRBMath_SD59x18_Mul_Overflow(x, y); } // Check if x and y have the same sign using two's complement representation. The left-most bit represents the sign (1 for // negative, 0 for positive or zero). bool sameSign = (xInt ^ yInt) > -1; // If the inputs have the same sign, the result should be positive. Otherwise, it should be negative. unchecked { result = wrap(sameSign ? int256(resultAbs) : -int256(resultAbs)); } } /// @notice Raises x to the power of y using the following formula: /// /// $$ /// x^y = 2^{log_2{x} * y} /// $$ /// /// @dev Notes: /// - Refer to the notes in {exp2}, {log2}, and {mul}. /// - Returns `UNIT` for 0^0. /// /// Requirements: /// - Refer to the requirements in {exp2}, {log2}, and {mul}. /// /// @param x The base as an SD59x18 number. /// @param y Exponent to raise x to, as an SD59x18 number /// @return result x raised to power y, as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function pow(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); int256 yInt = y.unwrap(); // If both x and y are zero, the result is `UNIT`. If just x is zero, the result is always zero. if (xInt == 0) { return yInt == 0 ? UNIT : ZERO; } // If x is `UNIT`, the result is always `UNIT`. else if (xInt == uUNIT) { return UNIT; } // If y is zero, the result is always `UNIT`. if (yInt == 0) { return UNIT; } // If y is `UNIT`, the result is always x. else if (yInt == uUNIT) { return x; } // Calculate the result using the formula. result = exp2(mul(log2(x), y)); } /// @notice Raises x (an SD59x18 number) to the power y (an unsigned basic integer) using the well-known /// algorithm "exponentiation by squaring". /// /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring. /// /// Notes: /// - Refer to the notes in {Common.mulDiv18}. /// - Returns `UNIT` for 0^0. /// /// Requirements: /// - Refer to the requirements in {abs} and {Common.mulDiv18}. /// - The result must fit in SD59x18. /// /// @param x The base as an SD59x18 number. /// @param y The exponent as a uint256. /// @return result The result as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function powu(SD59x18 x, uint256 y) pure returns (SD59x18 result) { uint256 xAbs = uint256(abs(x).unwrap()); // Calculate the first iteration of the loop in advance. uint256 resultAbs = y & 1 > 0 ? xAbs : uint256(uUNIT); // Equivalent to `for(y /= 2; y > 0; y /= 2)`. uint256 yAux = y; for (yAux >>= 1; yAux > 0; yAux >>= 1) { xAbs = Common.mulDiv18(xAbs, xAbs); // Equivalent to `y % 2 == 1`. if (yAux & 1 > 0) { resultAbs = Common.mulDiv18(resultAbs, xAbs); } } // The result must fit in SD59x18. if (resultAbs > uint256(uMAX_SD59x18)) { revert Errors.PRBMath_SD59x18_Powu_Overflow(x, y); } unchecked { // Is the base negative and the exponent odd? If yes, the result should be negative. int256 resultInt = int256(resultAbs); bool isNegative = x.unwrap() < 0 && y & 1 == 1; if (isNegative) { resultInt = -resultInt; } result = wrap(resultInt); } } /// @notice Calculates the square root of x using the Babylonian method. /// /// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. /// /// Notes: /// - Only the positive root is returned. /// - The result is rounded toward zero. /// /// Requirements: /// - x cannot be negative, since complex numbers are not supported. /// - x must be less than `MAX_SD59x18 / UNIT`. /// /// @param x The SD59x18 number for which to calculate the square root. /// @return result The result as an SD59x18 number. /// @custom:smtchecker abstract-function-nondet function sqrt(SD59x18 x) pure returns (SD59x18 result) { int256 xInt = x.unwrap(); if (xInt < 0) { revert Errors.PRBMath_SD59x18_Sqrt_NegativeInput(x); } if (xInt > uMAX_SD59x18 / uUNIT) { revert Errors.PRBMath_SD59x18_Sqrt_Overflow(x); } unchecked { // Multiply x by `UNIT` to account for the factor of `UNIT` picked up when multiplying two SD59x18 numbers. // In this case, the two numbers are both the square root. uint256 resultUint = Common.sqrt(uint256(xInt * uUNIT)); result = wrap(int256(resultUint)); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "./Casting.sol" as Casting; import "./Helpers.sol" as Helpers; import "./Math.sol" as Math; /// @notice The signed 59.18-decimal fixed-point number representation, which can have up to 59 digits and up to 18 /// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity /// type int256. type SD59x18 is int256; /*////////////////////////////////////////////////////////////////////////// CASTING //////////////////////////////////////////////////////////////////////////*/ using { Casting.intoInt256, Casting.intoSD1x18, Casting.intoUD2x18, Casting.intoUD60x18, Casting.intoUint256, Casting.intoUint128, Casting.intoUint40, Casting.unwrap } for SD59x18 global; /*////////////////////////////////////////////////////////////////////////// MATHEMATICAL FUNCTIONS //////////////////////////////////////////////////////////////////////////*/ using { Math.abs, Math.avg, Math.ceil, Math.div, Math.exp, Math.exp2, Math.floor, Math.frac, Math.gm, Math.inv, Math.log10, Math.log2, Math.ln, Math.mul, Math.pow, Math.powu, Math.sqrt } for SD59x18 global; /*////////////////////////////////////////////////////////////////////////// HELPER FUNCTIONS //////////////////////////////////////////////////////////////////////////*/ using { Helpers.add, Helpers.and, Helpers.eq, Helpers.gt, Helpers.gte, Helpers.isZero, Helpers.lshift, Helpers.lt, Helpers.lte, Helpers.mod, Helpers.neq, Helpers.not, Helpers.or, Helpers.rshift, Helpers.sub, Helpers.uncheckedAdd, Helpers.uncheckedSub, Helpers.uncheckedUnary, Helpers.xor } for SD59x18 global; /*////////////////////////////////////////////////////////////////////////// OPERATORS //////////////////////////////////////////////////////////////////////////*/ // The global "using for" directive makes it possible to use these operators on the SD59x18 type. using { Helpers.add as +, Helpers.and2 as &, Math.div as /, Helpers.eq as ==, Helpers.gt as >, Helpers.gte as >=, Helpers.lt as <, Helpers.lte as <=, Helpers.mod as %, Math.mul as *, Helpers.neq as !=, Helpers.not as ~, Helpers.or as |, Helpers.sub as -, Helpers.unary as -, Helpers.xor as ^ } for SD59x18 global;
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "../Common.sol" as Common; import "./Errors.sol" as Errors; import { uMAX_SD1x18 } from "../sd1x18/Constants.sol"; import { SD1x18 } from "../sd1x18/ValueType.sol"; import { SD59x18 } from "../sd59x18/ValueType.sol"; import { UD60x18 } from "../ud60x18/ValueType.sol"; import { UD2x18 } from "./ValueType.sol"; /// @notice Casts a UD2x18 number into SD1x18. /// - x must be less than or equal to `uMAX_SD1x18`. function intoSD1x18(UD2x18 x) pure returns (SD1x18 result) { uint64 xUint = UD2x18.unwrap(x); if (xUint > uint64(uMAX_SD1x18)) { revert Errors.PRBMath_UD2x18_IntoSD1x18_Overflow(x); } result = SD1x18.wrap(int64(xUint)); } /// @notice Casts a UD2x18 number into SD59x18. /// @dev There is no overflow check because the domain of UD2x18 is a subset of SD59x18. function intoSD59x18(UD2x18 x) pure returns (SD59x18 result) { result = SD59x18.wrap(int256(uint256(UD2x18.unwrap(x)))); } /// @notice Casts a UD2x18 number into UD60x18. /// @dev There is no overflow check because the domain of UD2x18 is a subset of UD60x18. function intoUD60x18(UD2x18 x) pure returns (UD60x18 result) { result = UD60x18.wrap(UD2x18.unwrap(x)); } /// @notice Casts a UD2x18 number into uint128. /// @dev There is no overflow check because the domain of UD2x18 is a subset of uint128. function intoUint128(UD2x18 x) pure returns (uint128 result) { result = uint128(UD2x18.unwrap(x)); } /// @notice Casts a UD2x18 number into uint256. /// @dev There is no overflow check because the domain of UD2x18 is a subset of uint256. function intoUint256(UD2x18 x) pure returns (uint256 result) { result = uint256(UD2x18.unwrap(x)); } /// @notice Casts a UD2x18 number into uint40. /// @dev Requirements: /// - x must be less than or equal to `MAX_UINT40`. function intoUint40(UD2x18 x) pure returns (uint40 result) { uint64 xUint = UD2x18.unwrap(x); if (xUint > uint64(Common.MAX_UINT40)) { revert Errors.PRBMath_UD2x18_IntoUint40_Overflow(x); } result = uint40(xUint); } /// @notice Alias for {wrap}. function ud2x18(uint64 x) pure returns (UD2x18 result) { result = UD2x18.wrap(x); } /// @notice Unwrap a UD2x18 number into uint64. function unwrap(UD2x18 x) pure returns (uint64 result) { result = UD2x18.unwrap(x); } /// @notice Wraps a uint64 number into UD2x18. function wrap(uint64 x) pure returns (UD2x18 result) { result = UD2x18.wrap(x); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { UD2x18 } from "./ValueType.sol"; /// @dev Euler's number as a UD2x18 number. UD2x18 constant E = UD2x18.wrap(2_718281828459045235); /// @dev The maximum value a UD2x18 number can have. uint64 constant uMAX_UD2x18 = 18_446744073709551615; UD2x18 constant MAX_UD2x18 = UD2x18.wrap(uMAX_UD2x18); /// @dev PI as a UD2x18 number. UD2x18 constant PI = UD2x18.wrap(3_141592653589793238); /// @dev The unit number, which gives the decimal precision of UD2x18. uint256 constant uUNIT = 1e18; UD2x18 constant UNIT = UD2x18.wrap(1e18);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { UD2x18 } from "./ValueType.sol"; /// @notice Thrown when trying to cast a UD2x18 number that doesn't fit in SD1x18. error PRBMath_UD2x18_IntoSD1x18_Overflow(UD2x18 x); /// @notice Thrown when trying to cast a UD2x18 number that doesn't fit in uint40. error PRBMath_UD2x18_IntoUint40_Overflow(UD2x18 x);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "./Casting.sol" as Casting; /// @notice The unsigned 2.18-decimal fixed-point number representation, which can have up to 2 digits and up to 18 /// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity /// type uint64. This is useful when end users want to use uint64 to save gas, e.g. with tight variable packing in contract /// storage. type UD2x18 is uint64; /*////////////////////////////////////////////////////////////////////////// CASTING //////////////////////////////////////////////////////////////////////////*/ using { Casting.intoSD1x18, Casting.intoSD59x18, Casting.intoUD60x18, Casting.intoUint256, Casting.intoUint128, Casting.intoUint40, Casting.unwrap } for UD2x18 global;
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; /* ██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗ ██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║ ██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║ ██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║ ██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║ ╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ██╗ ██╗██████╗ ██████╗ ██████╗ ██╗ ██╗ ██╗ █████╗ ██║ ██║██╔══██╗██╔════╝ ██╔═████╗╚██╗██╔╝███║██╔══██╗ ██║ ██║██║ ██║███████╗ ██║██╔██║ ╚███╔╝ ╚██║╚█████╔╝ ██║ ██║██║ ██║██╔═══██╗████╔╝██║ ██╔██╗ ██║██╔══██╗ ╚██████╔╝██████╔╝╚██████╔╝╚██████╔╝██╔╝ ██╗ ██║╚█████╔╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚════╝ */ import "./ud60x18/Casting.sol"; import "./ud60x18/Constants.sol"; import "./ud60x18/Conversions.sol"; import "./ud60x18/Errors.sol"; import "./ud60x18/Helpers.sol"; import "./ud60x18/Math.sol"; import "./ud60x18/ValueType.sol";
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "./Errors.sol" as CastingErrors; import { MAX_UINT128, MAX_UINT40 } from "../Common.sol"; import { uMAX_SD1x18 } from "../sd1x18/Constants.sol"; import { SD1x18 } from "../sd1x18/ValueType.sol"; import { uMAX_SD59x18 } from "../sd59x18/Constants.sol"; import { SD59x18 } from "../sd59x18/ValueType.sol"; import { uMAX_UD2x18 } from "../ud2x18/Constants.sol"; import { UD2x18 } from "../ud2x18/ValueType.sol"; import { UD60x18 } from "./ValueType.sol"; /// @notice Casts a UD60x18 number into SD1x18. /// @dev Requirements: /// - x must be less than or equal to `uMAX_SD1x18`. function intoSD1x18(UD60x18 x) pure returns (SD1x18 result) { uint256 xUint = UD60x18.unwrap(x); if (xUint > uint256(int256(uMAX_SD1x18))) { revert CastingErrors.PRBMath_UD60x18_IntoSD1x18_Overflow(x); } result = SD1x18.wrap(int64(uint64(xUint))); } /// @notice Casts a UD60x18 number into UD2x18. /// @dev Requirements: /// - x must be less than or equal to `uMAX_UD2x18`. function intoUD2x18(UD60x18 x) pure returns (UD2x18 result) { uint256 xUint = UD60x18.unwrap(x); if (xUint > uMAX_UD2x18) { revert CastingErrors.PRBMath_UD60x18_IntoUD2x18_Overflow(x); } result = UD2x18.wrap(uint64(xUint)); } /// @notice Casts a UD60x18 number into SD59x18. /// @dev Requirements: /// - x must be less than or equal to `uMAX_SD59x18`. function intoSD59x18(UD60x18 x) pure returns (SD59x18 result) { uint256 xUint = UD60x18.unwrap(x); if (xUint > uint256(uMAX_SD59x18)) { revert CastingErrors.PRBMath_UD60x18_IntoSD59x18_Overflow(x); } result = SD59x18.wrap(int256(xUint)); } /// @notice Casts a UD60x18 number into uint128. /// @dev This is basically an alias for {unwrap}. function intoUint256(UD60x18 x) pure returns (uint256 result) { result = UD60x18.unwrap(x); } /// @notice Casts a UD60x18 number into uint128. /// @dev Requirements: /// - x must be less than or equal to `MAX_UINT128`. function intoUint128(UD60x18 x) pure returns (uint128 result) { uint256 xUint = UD60x18.unwrap(x); if (xUint > MAX_UINT128) { revert CastingErrors.PRBMath_UD60x18_IntoUint128_Overflow(x); } result = uint128(xUint); } /// @notice Casts a UD60x18 number into uint40. /// @dev Requirements: /// - x must be less than or equal to `MAX_UINT40`. function intoUint40(UD60x18 x) pure returns (uint40 result) { uint256 xUint = UD60x18.unwrap(x); if (xUint > MAX_UINT40) { revert CastingErrors.PRBMath_UD60x18_IntoUint40_Overflow(x); } result = uint40(xUint); } /// @notice Alias for {wrap}. function ud(uint256 x) pure returns (UD60x18 result) { result = UD60x18.wrap(x); } /// @notice Alias for {wrap}. function ud60x18(uint256 x) pure returns (UD60x18 result) { result = UD60x18.wrap(x); } /// @notice Unwraps a UD60x18 number into uint256. function unwrap(UD60x18 x) pure returns (uint256 result) { result = UD60x18.unwrap(x); } /// @notice Wraps a uint256 number into the UD60x18 value type. function wrap(uint256 x) pure returns (UD60x18 result) { result = UD60x18.wrap(x); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { UD60x18 } from "./ValueType.sol"; // NOTICE: the "u" prefix stands for "unwrapped". /// @dev Euler's number as a UD60x18 number. UD60x18 constant E = UD60x18.wrap(2_718281828459045235); /// @dev The maximum input permitted in {exp}. uint256 constant uEXP_MAX_INPUT = 133_084258667509499440; UD60x18 constant EXP_MAX_INPUT = UD60x18.wrap(uEXP_MAX_INPUT); /// @dev The maximum input permitted in {exp2}. uint256 constant uEXP2_MAX_INPUT = 192e18 - 1; UD60x18 constant EXP2_MAX_INPUT = UD60x18.wrap(uEXP2_MAX_INPUT); /// @dev Half the UNIT number. uint256 constant uHALF_UNIT = 0.5e18; UD60x18 constant HALF_UNIT = UD60x18.wrap(uHALF_UNIT); /// @dev $log_2(10)$ as a UD60x18 number. uint256 constant uLOG2_10 = 3_321928094887362347; UD60x18 constant LOG2_10 = UD60x18.wrap(uLOG2_10); /// @dev $log_2(e)$ as a UD60x18 number. uint256 constant uLOG2_E = 1_442695040888963407; UD60x18 constant LOG2_E = UD60x18.wrap(uLOG2_E); /// @dev The maximum value a UD60x18 number can have. uint256 constant uMAX_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_584007913129639935; UD60x18 constant MAX_UD60x18 = UD60x18.wrap(uMAX_UD60x18); /// @dev The maximum whole value a UD60x18 number can have. uint256 constant uMAX_WHOLE_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_000000000000000000; UD60x18 constant MAX_WHOLE_UD60x18 = UD60x18.wrap(uMAX_WHOLE_UD60x18); /// @dev PI as a UD60x18 number. UD60x18 constant PI = UD60x18.wrap(3_141592653589793238); /// @dev The unit number, which gives the decimal precision of UD60x18. uint256 constant uUNIT = 1e18; UD60x18 constant UNIT = UD60x18.wrap(uUNIT); /// @dev The unit number squared. uint256 constant uUNIT_SQUARED = 1e36; UD60x18 constant UNIT_SQUARED = UD60x18.wrap(uUNIT_SQUARED); /// @dev Zero as a UD60x18 number. UD60x18 constant ZERO = UD60x18.wrap(0);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { uMAX_UD60x18, uUNIT } from "./Constants.sol"; import { PRBMath_UD60x18_Convert_Overflow } from "./Errors.sol"; import { UD60x18 } from "./ValueType.sol"; /// @notice Converts a UD60x18 number to a simple integer by dividing it by `UNIT`. /// @dev The result is rounded toward zero. /// @param x The UD60x18 number to convert. /// @return result The same number in basic integer form. function convert(UD60x18 x) pure returns (uint256 result) { result = UD60x18.unwrap(x) / uUNIT; } /// @notice Converts a simple integer to UD60x18 by multiplying it by `UNIT`. /// /// @dev Requirements: /// - x must be less than or equal to `MAX_UD60x18 / UNIT`. /// /// @param x The basic integer to convert. /// @param result The same number converted to UD60x18. function convert(uint256 x) pure returns (UD60x18 result) { if (x > uMAX_UD60x18 / uUNIT) { revert PRBMath_UD60x18_Convert_Overflow(x); } unchecked { result = UD60x18.wrap(x * uUNIT); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { UD60x18 } from "./ValueType.sol"; /// @notice Thrown when ceiling a number overflows UD60x18. error PRBMath_UD60x18_Ceil_Overflow(UD60x18 x); /// @notice Thrown when converting a basic integer to the fixed-point format overflows UD60x18. error PRBMath_UD60x18_Convert_Overflow(uint256 x); /// @notice Thrown when taking the natural exponent of a base greater than 133_084258667509499441. error PRBMath_UD60x18_Exp_InputTooBig(UD60x18 x); /// @notice Thrown when taking the binary exponent of a base greater than 192e18. error PRBMath_UD60x18_Exp2_InputTooBig(UD60x18 x); /// @notice Thrown when taking the geometric mean of two numbers and multiplying them overflows UD60x18. error PRBMath_UD60x18_Gm_Overflow(UD60x18 x, UD60x18 y); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD1x18. error PRBMath_UD60x18_IntoSD1x18_Overflow(UD60x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD59x18. error PRBMath_UD60x18_IntoSD59x18_Overflow(UD60x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD2x18. error PRBMath_UD60x18_IntoUD2x18_Overflow(UD60x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint128. error PRBMath_UD60x18_IntoUint128_Overflow(UD60x18 x); /// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint40. error PRBMath_UD60x18_IntoUint40_Overflow(UD60x18 x); /// @notice Thrown when taking the logarithm of a number less than 1. error PRBMath_UD60x18_Log_InputTooSmall(UD60x18 x); /// @notice Thrown when calculating the square root overflows UD60x18. error PRBMath_UD60x18_Sqrt_Overflow(UD60x18 x);
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import { wrap } from "./Casting.sol"; import { UD60x18 } from "./ValueType.sol"; /// @notice Implements the checked addition operation (+) in the UD60x18 type. function add(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(x.unwrap() + y.unwrap()); } /// @notice Implements the AND (&) bitwise operation in the UD60x18 type. function and(UD60x18 x, uint256 bits) pure returns (UD60x18 result) { result = wrap(x.unwrap() & bits); } /// @notice Implements the AND (&) bitwise operation in the UD60x18 type. function and2(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(x.unwrap() & y.unwrap()); } /// @notice Implements the equal operation (==) in the UD60x18 type. function eq(UD60x18 x, UD60x18 y) pure returns (bool result) { result = x.unwrap() == y.unwrap(); } /// @notice Implements the greater than operation (>) in the UD60x18 type. function gt(UD60x18 x, UD60x18 y) pure returns (bool result) { result = x.unwrap() > y.unwrap(); } /// @notice Implements the greater than or equal to operation (>=) in the UD60x18 type. function gte(UD60x18 x, UD60x18 y) pure returns (bool result) { result = x.unwrap() >= y.unwrap(); } /// @notice Implements a zero comparison check function in the UD60x18 type. function isZero(UD60x18 x) pure returns (bool result) { // This wouldn't work if x could be negative. result = x.unwrap() == 0; } /// @notice Implements the left shift operation (<<) in the UD60x18 type. function lshift(UD60x18 x, uint256 bits) pure returns (UD60x18 result) { result = wrap(x.unwrap() << bits); } /// @notice Implements the lower than operation (<) in the UD60x18 type. function lt(UD60x18 x, UD60x18 y) pure returns (bool result) { result = x.unwrap() < y.unwrap(); } /// @notice Implements the lower than or equal to operation (<=) in the UD60x18 type. function lte(UD60x18 x, UD60x18 y) pure returns (bool result) { result = x.unwrap() <= y.unwrap(); } /// @notice Implements the checked modulo operation (%) in the UD60x18 type. function mod(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(x.unwrap() % y.unwrap()); } /// @notice Implements the not equal operation (!=) in the UD60x18 type. function neq(UD60x18 x, UD60x18 y) pure returns (bool result) { result = x.unwrap() != y.unwrap(); } /// @notice Implements the NOT (~) bitwise operation in the UD60x18 type. function not(UD60x18 x) pure returns (UD60x18 result) { result = wrap(~x.unwrap()); } /// @notice Implements the OR (|) bitwise operation in the UD60x18 type. function or(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(x.unwrap() | y.unwrap()); } /// @notice Implements the right shift operation (>>) in the UD60x18 type. function rshift(UD60x18 x, uint256 bits) pure returns (UD60x18 result) { result = wrap(x.unwrap() >> bits); } /// @notice Implements the checked subtraction operation (-) in the UD60x18 type. function sub(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(x.unwrap() - y.unwrap()); } /// @notice Implements the unchecked addition operation (+) in the UD60x18 type. function uncheckedAdd(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { unchecked { result = wrap(x.unwrap() + y.unwrap()); } } /// @notice Implements the unchecked subtraction operation (-) in the UD60x18 type. function uncheckedSub(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { unchecked { result = wrap(x.unwrap() - y.unwrap()); } } /// @notice Implements the XOR (^) bitwise operation in the UD60x18 type. function xor(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(x.unwrap() ^ y.unwrap()); }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "../Common.sol" as Common; import "./Errors.sol" as Errors; import { wrap } from "./Casting.sol"; import { uEXP_MAX_INPUT, uEXP2_MAX_INPUT, uHALF_UNIT, uLOG2_10, uLOG2_E, uMAX_UD60x18, uMAX_WHOLE_UD60x18, UNIT, uUNIT, uUNIT_SQUARED, ZERO } from "./Constants.sol"; import { UD60x18 } from "./ValueType.sol"; /*////////////////////////////////////////////////////////////////////////// MATHEMATICAL FUNCTIONS //////////////////////////////////////////////////////////////////////////*/ /// @notice Calculates the arithmetic average of x and y using the following formula: /// /// $$ /// avg(x, y) = (x & y) + ((xUint ^ yUint) / 2) /// $$ /// /// In English, this is what this formula does: /// /// 1. AND x and y. /// 2. Calculate half of XOR x and y. /// 3. Add the two results together. /// /// This technique is known as SWAR, which stands for "SIMD within a register". You can read more about it here: /// https://devblogs.microsoft.com/oldnewthing/20220207-00/?p=106223 /// /// @dev Notes: /// - The result is rounded toward zero. /// /// @param x The first operand as a UD60x18 number. /// @param y The second operand as a UD60x18 number. /// @return result The arithmetic average as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function avg(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); uint256 yUint = y.unwrap(); unchecked { result = wrap((xUint & yUint) + ((xUint ^ yUint) >> 1)); } } /// @notice Yields the smallest whole number greater than or equal to x. /// /// @dev This is optimized 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 UD60x18 number to ceil. /// @param result The smallest whole number greater than or equal to x, as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function ceil(UD60x18 x) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); if (xUint > uMAX_WHOLE_UD60x18) { revert Errors.PRBMath_UD60x18_Ceil_Overflow(x); } assembly ("memory-safe") { // Equivalent to `x % UNIT`. let remainder := mod(x, uUNIT) // Equivalent to `UNIT - remainder`. let delta := sub(uUNIT, remainder) // Equivalent to `x + remainder > 0 ? delta : 0`. result := add(x, mul(delta, gt(remainder, 0))) } } /// @notice Divides two UD60x18 numbers, returning a new UD60x18 number. /// /// @dev Uses {Common.mulDiv} to enable overflow-safe multiplication and division. /// /// Notes: /// - Refer to the notes in {Common.mulDiv}. /// /// Requirements: /// - Refer to the requirements in {Common.mulDiv}. /// /// @param x The numerator as a UD60x18 number. /// @param y The denominator as a UD60x18 number. /// @param result The quotient as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function div(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(Common.mulDiv(x.unwrap(), uUNIT, y.unwrap())); } /// @notice Calculates the natural exponent of x using the following formula: /// /// $$ /// e^x = 2^{x * log_2{e}} /// $$ /// /// @dev Requirements: /// - x must be less than 133_084258667509499441. /// /// @param x The exponent as a UD60x18 number. /// @return result The result as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function exp(UD60x18 x) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); // This check prevents values greater than 192e18 from being passed to {exp2}. if (xUint > uEXP_MAX_INPUT) { revert Errors.PRBMath_UD60x18_Exp_InputTooBig(x); } unchecked { // Inline the fixed-point multiplication to save gas. uint256 doubleUnitProduct = xUint * uLOG2_E; result = exp2(wrap(doubleUnitProduct / uUNIT)); } } /// @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 less than 192e18. /// - The result must fit in UD60x18. /// /// @param x The exponent as a UD60x18 number. /// @return result The result as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function exp2(UD60x18 x) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); // Numbers greater than or equal to 192e18 don't fit in the 192.64-bit format. if (xUint > uEXP2_MAX_INPUT) { revert Errors.PRBMath_UD60x18_Exp2_InputTooBig(x); } // Convert x to the 192.64-bit fixed-point format. uint256 x_192x64 = (xUint << 64) / uUNIT; // Pass x to the {Common.exp2} function, which uses the 192.64-bit fixed-point number representation. result = wrap(Common.exp2(x_192x64)); } /// @notice Yields the greatest whole number less than or equal to x. /// @dev Optimized for fractional value inputs, because every whole value has (1e18 - 1) fractional counterparts. /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions. /// @param x The UD60x18 number to floor. /// @param result The greatest whole number less than or equal to x, as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function floor(UD60x18 x) pure returns (UD60x18 result) { assembly ("memory-safe") { // Equivalent to `x % UNIT`. let remainder := mod(x, uUNIT) // Equivalent to `x - remainder > 0 ? remainder : 0)`. result := sub(x, mul(remainder, gt(remainder, 0))) } } /// @notice Yields the excess beyond the floor of x using the odd function definition. /// @dev See https://en.wikipedia.org/wiki/Fractional_part. /// @param x The UD60x18 number to get the fractional part of. /// @param result The fractional part of x as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function frac(UD60x18 x) pure returns (UD60x18 result) { assembly ("memory-safe") { result := mod(x, uUNIT) } } /// @notice Calculates the geometric mean of x and y, i.e. $\sqrt{x * y}$, rounding down. /// /// @dev Requirements: /// - x * y must fit in UD60x18. /// /// @param x The first operand as a UD60x18 number. /// @param y The second operand as a UD60x18 number. /// @return result The result as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function gm(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); uint256 yUint = y.unwrap(); if (xUint == 0 || yUint == 0) { return ZERO; } unchecked { // Checking for overflow this way is faster than letting Solidity do it. uint256 xyUint = xUint * yUint; if (xyUint / xUint != yUint) { revert Errors.PRBMath_UD60x18_Gm_Overflow(x, y); } // We don't need to multiply the result by `UNIT` here because the x*y product picked up a factor of `UNIT` // during multiplication. See the comments in {Common.sqrt}. result = wrap(Common.sqrt(xyUint)); } } /// @notice Calculates the inverse of x. /// /// @dev Notes: /// - The result is rounded toward zero. /// /// Requirements: /// - x must not be zero. /// /// @param x The UD60x18 number for which to calculate the inverse. /// @return result The inverse as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function inv(UD60x18 x) pure returns (UD60x18 result) { unchecked { result = wrap(uUNIT_SQUARED / x.unwrap()); } } /// @notice Calculates the natural logarithm of x using the following formula: /// /// $$ /// ln{x} = log_2{x} / log_2{e} /// $$ /// /// @dev Notes: /// - Refer to the notes in {log2}. /// - The precision isn't sufficiently fine-grained to return exactly `UNIT` when the input is `E`. /// /// Requirements: /// - Refer to the requirements in {log2}. /// /// @param x The UD60x18 number for which to calculate the natural logarithm. /// @return result The natural logarithm as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function ln(UD60x18 x) pure returns (UD60x18 result) { unchecked { // Inline the fixed-point multiplication to save gas. This is overflow-safe because the maximum value that // {log2} can return is ~196_205294292027477728. result = wrap(log2(x).unwrap() * uUNIT / uLOG2_E); } } /// @notice Calculates the common logarithm of x using the following formula: /// /// $$ /// log_{10}{x} = log_2{x} / log_2{10} /// $$ /// /// However, if x is an exact power of ten, a hard coded value is returned. /// /// @dev Notes: /// - Refer to the notes in {log2}. /// /// Requirements: /// - Refer to the requirements in {log2}. /// /// @param x The UD60x18 number for which to calculate the common logarithm. /// @return result The common logarithm as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function log10(UD60x18 x) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); if (xUint < uUNIT) { revert Errors.PRBMath_UD60x18_Log_InputTooSmall(x); } // Note that the `mul` in this assembly block is the standard multiplication operation, not {UD60x18.mul}. // prettier-ignore assembly ("memory-safe") { switch x case 1 { result := mul(uUNIT, sub(0, 18)) } case 10 { result := mul(uUNIT, sub(1, 18)) } case 100 { result := mul(uUNIT, sub(2, 18)) } case 1000 { result := mul(uUNIT, sub(3, 18)) } case 10000 { result := mul(uUNIT, sub(4, 18)) } case 100000 { result := mul(uUNIT, sub(5, 18)) } case 1000000 { result := mul(uUNIT, sub(6, 18)) } case 10000000 { result := mul(uUNIT, sub(7, 18)) } case 100000000 { result := mul(uUNIT, sub(8, 18)) } case 1000000000 { result := mul(uUNIT, sub(9, 18)) } case 10000000000 { result := mul(uUNIT, sub(10, 18)) } case 100000000000 { result := mul(uUNIT, sub(11, 18)) } case 1000000000000 { result := mul(uUNIT, sub(12, 18)) } case 10000000000000 { result := mul(uUNIT, sub(13, 18)) } case 100000000000000 { result := mul(uUNIT, sub(14, 18)) } case 1000000000000000 { result := mul(uUNIT, sub(15, 18)) } case 10000000000000000 { result := mul(uUNIT, sub(16, 18)) } case 100000000000000000 { result := mul(uUNIT, sub(17, 18)) } case 1000000000000000000 { result := 0 } case 10000000000000000000 { result := uUNIT } case 100000000000000000000 { result := mul(uUNIT, 2) } case 1000000000000000000000 { result := mul(uUNIT, 3) } case 10000000000000000000000 { result := mul(uUNIT, 4) } case 100000000000000000000000 { result := mul(uUNIT, 5) } case 1000000000000000000000000 { result := mul(uUNIT, 6) } case 10000000000000000000000000 { result := mul(uUNIT, 7) } case 100000000000000000000000000 { result := mul(uUNIT, 8) } case 1000000000000000000000000000 { result := mul(uUNIT, 9) } case 10000000000000000000000000000 { result := mul(uUNIT, 10) } case 100000000000000000000000000000 { result := mul(uUNIT, 11) } case 1000000000000000000000000000000 { result := mul(uUNIT, 12) } case 10000000000000000000000000000000 { result := mul(uUNIT, 13) } case 100000000000000000000000000000000 { result := mul(uUNIT, 14) } case 1000000000000000000000000000000000 { result := mul(uUNIT, 15) } case 10000000000000000000000000000000000 { result := mul(uUNIT, 16) } case 100000000000000000000000000000000000 { result := mul(uUNIT, 17) } case 1000000000000000000000000000000000000 { result := mul(uUNIT, 18) } case 10000000000000000000000000000000000000 { result := mul(uUNIT, 19) } case 100000000000000000000000000000000000000 { result := mul(uUNIT, 20) } case 1000000000000000000000000000000000000000 { result := mul(uUNIT, 21) } case 10000000000000000000000000000000000000000 { result := mul(uUNIT, 22) } case 100000000000000000000000000000000000000000 { result := mul(uUNIT, 23) } case 1000000000000000000000000000000000000000000 { result := mul(uUNIT, 24) } case 10000000000000000000000000000000000000000000 { result := mul(uUNIT, 25) } case 100000000000000000000000000000000000000000000 { result := mul(uUNIT, 26) } case 1000000000000000000000000000000000000000000000 { result := mul(uUNIT, 27) } case 10000000000000000000000000000000000000000000000 { result := mul(uUNIT, 28) } case 100000000000000000000000000000000000000000000000 { result := mul(uUNIT, 29) } case 1000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 30) } case 10000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 31) } case 100000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 32) } case 1000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 33) } case 10000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 34) } case 100000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 35) } case 1000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 36) } case 10000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 37) } case 100000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 38) } case 1000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 39) } case 10000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 40) } case 100000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 41) } case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 42) } case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 43) } case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 44) } case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 45) } case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 46) } case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 47) } case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 48) } case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 49) } case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 50) } case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 51) } case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 52) } case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 53) } case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 54) } case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 55) } case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 56) } case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 57) } case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 58) } case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 59) } default { result := uMAX_UD60x18 } } if (result.unwrap() == uMAX_UD60x18) { unchecked { // Inline the fixed-point division to save gas. result = wrap(log2(x).unwrap() * uUNIT / uLOG2_10); } } } /// @notice Calculates the binary logarithm of x using the iterative approximation algorithm: /// /// $$ /// log_2{x} = n + log_2{y}, \text{ where } y = x*2^{-n}, \ y \in [1, 2) /// $$ /// /// For $0 \leq x \lt 1$, the input is inverted: /// /// $$ /// log_2{x} = -log_2{\frac{1}{x}} /// $$ /// /// @dev See https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation /// /// Notes: /// - Due to the lossy precision of the iterative approximation, the results are not perfectly accurate to the last decimal. /// /// Requirements: /// - x must be greater than zero. /// /// @param x The UD60x18 number for which to calculate the binary logarithm. /// @return result The binary logarithm as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function log2(UD60x18 x) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); if (xUint < uUNIT) { revert Errors.PRBMath_UD60x18_Log_InputTooSmall(x); } unchecked { // Calculate the integer part of the logarithm. uint256 n = Common.msb(xUint / uUNIT); // This is the integer part of the logarithm as a UD60x18 number. The operation can't overflow because n // n is at most 255 and UNIT is 1e18. uint256 resultUint = n * uUNIT; // Calculate $y = x * 2^{-n}$. uint256 y = xUint >> n; // If y is the unit number, the fractional part is zero. if (y == uUNIT) { return wrap(resultUint); } // Calculate the fractional part via the iterative approximation. // The `delta >>= 1` part is equivalent to `delta /= 2`, but shifting bits is more gas efficient. uint256 DOUBLE_UNIT = 2e18; for (uint256 delta = uHALF_UNIT; delta > 0; delta >>= 1) { y = (y * y) / uUNIT; // Is y^2 >= 2e18 and so in the range [2e18, 4e18)? if (y >= DOUBLE_UNIT) { // Add the 2^{-m} factor to the logarithm. resultUint += delta; // Halve y, which corresponds to z/2 in the Wikipedia article. y >>= 1; } } result = wrap(resultUint); } } /// @notice Multiplies two UD60x18 numbers together, returning a new UD60x18 number. /// /// @dev Uses {Common.mulDiv} to enable overflow-safe multiplication and division. /// /// Notes: /// - Refer to the notes in {Common.mulDiv}. /// /// Requirements: /// - Refer to the requirements in {Common.mulDiv}. /// /// @dev See the documentation in {Common.mulDiv18}. /// @param x The multiplicand as a UD60x18 number. /// @param y The multiplier as a UD60x18 number. /// @return result The product as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function mul(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { result = wrap(Common.mulDiv18(x.unwrap(), y.unwrap())); } /// @notice Raises x to the power of y. /// /// For $1 \leq x \leq \infty$, the following standard formula is used: /// /// $$ /// x^y = 2^{log_2{x} * y} /// $$ /// /// For $0 \leq x \lt 1$, since the unsigned {log2} is undefined, an equivalent formula is used: /// /// $$ /// i = \frac{1}{x} /// w = 2^{log_2{i} * y} /// x^y = \frac{1}{w} /// $$ /// /// @dev Notes: /// - Refer to the notes in {log2} and {mul}. /// - Returns `UNIT` for 0^0. /// - It may not perform well with very small values of x. Consider using SD59x18 as an alternative. /// /// Requirements: /// - Refer to the requirements in {exp2}, {log2}, and {mul}. /// /// @param x The base as a UD60x18 number. /// @param y The exponent as a UD60x18 number. /// @return result The result as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function pow(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); uint256 yUint = y.unwrap(); // If both x and y are zero, the result is `UNIT`. If just x is zero, the result is always zero. if (xUint == 0) { return yUint == 0 ? UNIT : ZERO; } // If x is `UNIT`, the result is always `UNIT`. else if (xUint == uUNIT) { return UNIT; } // If y is zero, the result is always `UNIT`. if (yUint == 0) { return UNIT; } // If y is `UNIT`, the result is always x. else if (yUint == uUNIT) { return x; } // If x is greater than `UNIT`, use the standard formula. if (xUint > uUNIT) { result = exp2(mul(log2(x), y)); } // Conversely, if x is less than `UNIT`, use the equivalent formula. else { UD60x18 i = wrap(uUNIT_SQUARED / xUint); UD60x18 w = exp2(mul(log2(i), y)); result = wrap(uUNIT_SQUARED / w.unwrap()); } } /// @notice Raises x (a UD60x18 number) to the power y (an unsigned basic integer) using the well-known /// algorithm "exponentiation by squaring". /// /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring. /// /// Notes: /// - Refer to the notes in {Common.mulDiv18}. /// - Returns `UNIT` for 0^0. /// /// Requirements: /// - The result must fit in UD60x18. /// /// @param x The base as a UD60x18 number. /// @param y The exponent as a uint256. /// @return result The result as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function powu(UD60x18 x, uint256 y) pure returns (UD60x18 result) { // Calculate the first iteration of the loop in advance. uint256 xUint = x.unwrap(); uint256 resultUint = y & 1 > 0 ? xUint : uUNIT; // Equivalent to `for(y /= 2; y > 0; y /= 2)`. for (y >>= 1; y > 0; y >>= 1) { xUint = Common.mulDiv18(xUint, xUint); // Equivalent to `y % 2 == 1`. if (y & 1 > 0) { resultUint = Common.mulDiv18(resultUint, xUint); } } result = wrap(resultUint); } /// @notice Calculates the square root of x using the Babylonian method. /// /// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method. /// /// Notes: /// - The result is rounded toward zero. /// /// Requirements: /// - x must be less than `MAX_UD60x18 / UNIT`. /// /// @param x The UD60x18 number for which to calculate the square root. /// @return result The result as a UD60x18 number. /// @custom:smtchecker abstract-function-nondet function sqrt(UD60x18 x) pure returns (UD60x18 result) { uint256 xUint = x.unwrap(); unchecked { if (xUint > uMAX_UD60x18 / uUNIT) { revert Errors.PRBMath_UD60x18_Sqrt_Overflow(x); } // Multiply x by `UNIT` to account for the factor of `UNIT` picked up when multiplying two UD60x18 numbers. // In this case, the two numbers are both the square root. result = wrap(Common.sqrt(xUint * uUNIT)); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.8.19; import "./Casting.sol" as Casting; import "./Helpers.sol" as Helpers; import "./Math.sol" as Math; /// @notice The unsigned 60.18-decimal fixed-point number representation, which can have up to 60 digits and up to 18 /// decimals. The values of this are bound by the minimum and the maximum values permitted by the Solidity type uint256. /// @dev The value type is defined here so it can be imported in all other files. type UD60x18 is uint256; /*////////////////////////////////////////////////////////////////////////// CASTING //////////////////////////////////////////////////////////////////////////*/ using { Casting.intoSD1x18, Casting.intoUD2x18, Casting.intoSD59x18, Casting.intoUint128, Casting.intoUint256, Casting.intoUint40, Casting.unwrap } for UD60x18 global; /*////////////////////////////////////////////////////////////////////////// MATHEMATICAL FUNCTIONS //////////////////////////////////////////////////////////////////////////*/ // The global "using for" directive makes the functions in this library callable on the UD60x18 type. using { Math.avg, Math.ceil, Math.div, Math.exp, Math.exp2, Math.floor, Math.frac, Math.gm, Math.inv, Math.ln, Math.log10, Math.log2, Math.mul, Math.pow, Math.powu, Math.sqrt } for UD60x18 global; /*////////////////////////////////////////////////////////////////////////// HELPER FUNCTIONS //////////////////////////////////////////////////////////////////////////*/ // The global "using for" directive makes the functions in this library callable on the UD60x18 type. using { Helpers.add, Helpers.and, Helpers.eq, Helpers.gt, Helpers.gte, Helpers.isZero, Helpers.lshift, Helpers.lt, Helpers.lte, Helpers.mod, Helpers.neq, Helpers.not, Helpers.or, Helpers.rshift, Helpers.sub, Helpers.uncheckedAdd, Helpers.uncheckedSub, Helpers.xor } for UD60x18 global; /*////////////////////////////////////////////////////////////////////////// OPERATORS //////////////////////////////////////////////////////////////////////////*/ // The global "using for" directive makes it possible to use these operators on the UD60x18 type. using { Helpers.add as +, Helpers.and2 as &, Math.div as /, Helpers.eq as ==, Helpers.gt as >, Helpers.gte as >=, Helpers.lt as <, Helpers.lte as <=, Helpers.or as |, Helpers.mod as %, Math.mul as *, Helpers.neq as !=, Helpers.not as ~, Helpers.sub as -, Helpers.xor as ^ } for UD60x18 global;
{ "optimizer": { "enabled": true, "runs": 5500 }, "viaIR": true, "evmVersion": "paris", "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"__name","type":"string"},{"internalType":"string","name":"__symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"CheckpointUnorderedInsertion","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"uint256","name":"increasedSupply","type":"uint256"},{"internalType":"uint256","name":"cap","type":"uint256"}],"name":"ERC20ExceededSafeSupply","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"timepoint","type":"uint256"},{"internalType":"uint48","name":"clock","type":"uint48"}],"name":"ERC5805FutureLookup","type":"error"},{"inputs":[],"name":"ERC6372InconsistentClock","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[],"name":"MathOverflowedMulDiv","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"name":"PRBMath_MulDiv18_Overflow","type":"error"},{"inputs":[{"internalType":"UD60x18","name":"x","type":"uint256"}],"name":"PRBMath_UD60x18_Exp2_InputTooBig","type":"error"},{"inputs":[{"internalType":"UD60x18","name":"x","type":"uint256"}],"name":"PRBMath_UD60x18_Log_InputTooSmall","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"uint8","name":"bits","type":"uint8"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"SafeCastOverflowedUintDowncast","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[{"internalType":"uint256","name":"expiry","type":"uint256"}],"name":"VotesExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"batchIndex","type":"uint256"}],"name":"VotingEscrowIncentiveAlreadyClaimed","type":"error"},{"inputs":[{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"claimTimepoint","type":"uint256"}],"name":"VotingEscrowIncentiveTimepointInFuture","type":"error"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"VotingEscrowInvalidAddress","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"VotingEscrowInvalidAmount","type":"error"},{"inputs":[{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint256","name":"minDuration","type":"uint256"},{"internalType":"uint256","name":"maxDuration","type":"uint256"}],"name":"VotingEscrowInvalidDuration","type":"error"},{"inputs":[{"internalType":"uint256","name":"newEnd","type":"uint256"},{"internalType":"uint256","name":"oldEnd","type":"uint256"}],"name":"VotingEscrowInvalidEndTime","type":"error"},{"inputs":[{"internalType":"contract IERC20","name":"incentiveToken","type":"address"}],"name":"VotingEscrowInvalidExtendIncentiveToken","type":"error"},{"inputs":[{"internalType":"uint256","name":"legacyLockupEnd","type":"uint256"},{"internalType":"uint256","name":"minimumLockupEnd","type":"uint256"}],"name":"VotingEscrowLockupEndTooShortToSync","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"batchIndex","type":"uint256"}],"name":"VotingEscrowNoIncentivesToClaim","type":"error"},{"inputs":[],"name":"VotingEscrowNoSupplyAtTimepoint","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"extender","type":"address"},{"internalType":"uint256","name":"lockupId","type":"uint256"}],"name":"VotingEscrowNotApprovedExtender","type":"error"},{"inputs":[],"name":"VotingEscrowStakeAlreadyRedeemed","type":"error"},{"inputs":[{"internalType":"uint256","name":"currentTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"}],"name":"VotingEscrowStakeStillLocked","type":"error"},{"inputs":[],"name":"VotingEscrowTransferNotSupported","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"batchIndex","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"claimAmount","type":"uint256"}],"name":"ClaimIncentiveBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timepoint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"stakeDuration","type":"uint256"},{"indexed":false,"internalType":"contract IERC20","name":"incentiveToken","type":"address"}],"name":"CreateNewIncentiveBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousVotes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newVotes","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"address","name":"extender","type":"address"},{"indexed":false,"internalType":"uint256","name":"lockupId","type":"uint256"},{"indexed":false,"internalType":"bool","name":"newState","type":"bool"}],"name":"ExtenderApproval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"lockupId","type":"uint256"},{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"indexed":false,"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"","type":"tuple"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"uint256","name":"legacyLockupIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"Sync","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"lockupId","type":"uint256"},{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"indexed":false,"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"","type":"tuple"}],"name":"Unstake","type":"event"},{"inputs":[],"name":"CLOCK_MODE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"MAX_STAKE_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_STAKE_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_SYNC_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"YEAR_BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"extender","type":"address"},{"internalType":"uint256","name":"lockupId","type":"uint256"}],"name":"approveExtender","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint48","name":"_key","type":"uint48"},{"internalType":"uint208","name":"_value","type":"uint208"}],"internalType":"struct Checkpoints.Checkpoint208","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"batchIndex","type":"uint256"}],"name":"claimAndBatchInformation","outputs":[{"components":[{"internalType":"bool","name":"timepointInPast","type":"bool"},{"internalType":"bool","name":"hasClaimed","type":"bool"},{"internalType":"uint128","name":"claimAmount","type":"uint128"}],"internalType":"struct IMaverickV2VotingEscrowBase.ClaimInformation","name":"claimInformation","type":"tuple"},{"components":[{"internalType":"uint128","name":"totalIncentives","type":"uint128"},{"internalType":"uint128","name":"stakeDuration","type":"uint128"},{"internalType":"uint48","name":"claimTimepoint","type":"uint48"},{"internalType":"contract IERC20","name":"incentiveToken","type":"address"}],"internalType":"struct IMaverickV2VotingEscrowBase.BatchInformation","name":"batchInformation","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"batchIndex","type":"uint256"}],"name":"claimFromIncentiveBatch","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"},{"internalType":"uint128","name":"claimAmount","type":"uint128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"batchIndex","type":"uint256"},{"internalType":"uint256","name":"lockupId","type":"uint256"}],"name":"claimFromIncentiveBatchAndExtend","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"},{"internalType":"uint128","name":"claimAmount","type":"uint128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clock","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint48","name":"timepoint","type":"uint48"},{"internalType":"uint128","name":"stakeDuration","type":"uint128"},{"internalType":"contract IERC20","name":"incentiveToken","type":"address"}],"name":"createIncentiveBatch","outputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"lockupId","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"extendForAccount","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"newLockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockupId","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"extendForSender","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"newLockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getLockup","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastBalanceOf","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incentiveBatchCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"batchIndex","type":"uint256"}],"name":"incentiveBatchInformation","outputs":[{"components":[{"internalType":"uint128","name":"totalIncentives","type":"uint128"},{"internalType":"uint128","name":"stakeDuration","type":"uint128"},{"internalType":"uint48","name":"claimTimepoint","type":"uint48"},{"internalType":"contract IERC20","name":"incentiveToken","type":"address"}],"internalType":"struct IMaverickV2VotingEscrowBase.BatchInformation","name":"info","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"incentiveToken","type":"address"}],"name":"incentiveTotals","outputs":[{"components":[{"internalType":"uint128","name":"totalIncentives","type":"uint128"},{"internalType":"uint128","name":"claimedIncentives","type":"uint128"}],"internalType":"struct IMaverickV2VotingEscrowBase.TokenIncentiveTotals","name":"totals","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"extender","type":"address"},{"internalType":"uint256","name":"lockupId","type":"uint256"}],"name":"isApprovedExtender","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"legacyVeMav","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"lockupCount","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"lockupIds","type":"uint256[]"}],"name":"merge","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"newLockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"previewVotes","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"extender","type":"address"},{"internalType":"uint256","name":"lockupId","type":"uint256"}],"name":"revokeExtender","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"stake","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"stakeToSender","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"legacyLockupIndex","type":"uint256"}],"name":"sync","outputs":[{"internalType":"uint256","name":"newBalance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"legacyLockupIndex","type":"uint256"}],"name":"syncBalances","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockupId","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"unstake","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockupId","type":"uint256"}],"name":"unstakeToSender","outputs":[{"components":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint128","name":"end","type":"uint128"},{"internalType":"uint256","name":"votes","type":"uint256"}],"internalType":"struct IMaverickV2VotingEscrowBase.Lockup","name":"lockup","type":"tuple"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000576654d4156000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000576654d4156000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : __name (string): veMAV
Arg [1] : __symbol (string): veMAV
-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 76654d4156000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 76654d4156000000000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.