Overview
BERA Balance
0 BERABERA Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
Latest 1 internal transaction
| Parent Transaction Hash | Block | From | To | |||
|---|---|---|---|---|---|---|
| 2608608 | 33 days ago | Contract Creation | 0 BERA |
Loading...
Loading
Minimal Proxy Contract for 0xea6fc6221f06e2081fd06bf0408a2b65a581fcaa
Contract Name:
RewardVault
Compiler Version
v0.8.26+commit.8a97fa7a
Optimization Enabled:
Yes with 666 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
import { Utils } from "../../libraries/Utils.sol";
import { IBeaconDeposit } from "../interfaces/IBeaconDeposit.sol";
import { IRewardVault } from "../interfaces/IRewardVault.sol";
import { FactoryOwnable } from "../../base/FactoryOwnable.sol";
import { StakingRewards } from "../../base/StakingRewards.sol";
import { IBeraChef } from "../interfaces/IBeraChef.sol";
import { IDistributor } from "../interfaces/IDistributor.sol";
import { IBGTIncentiveDistributor } from "../interfaces/IBGTIncentiveDistributor.sol";
/// @title Rewards Vault
/// @author Berachain Team
/// @notice This contract is the vault for the Berachain rewards, it handles the staking and rewards accounting of BGT.
/// @dev This contract is taken from the stable and tested:
/// https://github.com/Synthetixio/synthetix/blob/develop/contracts/StakingRewards.sol
/// We are using this model instead of 4626 because we want to incentivize staying in the vault for x period of time to
/// to be considered a 'miner' and not a 'trader'.
contract RewardVault is
PausableUpgradeable,
ReentrancyGuardUpgradeable,
FactoryOwnable,
StakingRewards,
IRewardVault
{
using Utils for bytes4;
using SafeERC20 for IERC20;
using Utils for address;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRUCTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Struct to hold delegate stake data.
/// @param delegateTotalStaked The total amount staked by delegates.
/// @param stakedByDelegate The mapping of the amount staked by each delegate.
struct DelegateStake {
uint256 delegateTotalStaked;
mapping(address delegate => uint256 amount) stakedByDelegate;
}
/// @notice Struct to hold an incentive data.
/// @param minIncentiveRate The minimum amount of the token to incentivize per BGT emission.
/// @param incentiveRate The amount of the token to incentivize per BGT emission.
/// @param amountRemaining The amount of the token remaining to incentivize.
/// @param manager The address of the manager that can addIncentive for this incentive token.
struct Incentive {
uint256 minIncentiveRate;
uint256 incentiveRate;
uint256 amountRemaining;
address manager;
}
uint256 private constant MAX_INCENTIVE_RATE = 1e36; // for 18 decimal token, this will mean 1e18 incentiveTokens
// per BGT emission.
// Safe gas limit for low level call operations to avoid griefing.
// This is mostly for low level call like approve, receiveIncentive (IBGTIncentiveDistributor which uses
// transferFrom).
uint256 private constant SAFE_GAS_LIMIT = 500_000;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STORAGE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice The maximum count of incentive tokens that can be stored.
uint8 public maxIncentiveTokensCount;
/// @notice The address of the distributor contract.
address public distributor;
/// @notice The BeaconDeposit contract.
IBeaconDeposit public beaconDepositContract;
mapping(address account => DelegateStake) internal _delegateStake;
/// @notice The mapping of accounts to their operators.
mapping(address account => address operator) internal _operators;
/// @notice the mapping of incentive token to its incentive data.
mapping(address token => Incentive) public incentives;
/// @notice The list of whitelisted tokens.
address[] public whitelistedTokens;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
/// @inheritdoc IRewardVault
function initialize(
address _beaconDepositContract,
address _bgt,
address _distributor,
address _stakingToken
)
external
initializer
{
__FactoryOwnable_init(msg.sender);
__Pausable_init();
__ReentrancyGuard_init();
__StakingRewards_init(_stakingToken, _bgt, 3 days);
maxIncentiveTokensCount = 2;
// slither-disable-next-line missing-zero-check
distributor = _distributor;
beaconDepositContract = IBeaconDeposit(_beaconDepositContract);
emit DistributorSet(_distributor);
emit MaxIncentiveTokensCountUpdated(2);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* MODIFIERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
modifier onlyDistributor() {
if (msg.sender != distributor) NotDistributor.selector.revertWith();
_;
}
modifier onlyOperatorOrUser(address account) {
if (msg.sender != account) {
if (msg.sender != _operators[account]) NotOperator.selector.revertWith();
}
_;
}
modifier checkSelfStakedBalance(address account, uint256 amount) {
_checkSelfStakedBalance(account, amount);
_;
}
modifier onlyWhitelistedToken(address token) {
if (incentives[token].minIncentiveRate == 0) TokenNotWhitelisted.selector.revertWith();
_;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ADMIN FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IRewardVault
function setDistributor(address _rewardDistribution) external onlyFactoryOwner {
if (_rewardDistribution == address(0)) ZeroAddress.selector.revertWith();
distributor = _rewardDistribution;
emit DistributorSet(_rewardDistribution);
}
/// @inheritdoc IRewardVault
function notifyRewardAmount(bytes calldata pubkey, uint256 reward) external onlyDistributor {
_notifyRewardAmount(reward);
_processIncentives(pubkey, reward);
}
/// @inheritdoc IRewardVault
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyFactoryOwner {
if (tokenAddress == address(stakeToken)) CannotRecoverStakingToken.selector.revertWith();
if (incentives[tokenAddress].minIncentiveRate != 0) CannotRecoverIncentiveToken.selector.revertWith();
IERC20(tokenAddress).safeTransfer(msg.sender, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
/// @inheritdoc IRewardVault
function setRewardsDuration(uint256 _rewardsDuration) external onlyFactoryOwner {
_setRewardsDuration(_rewardsDuration);
}
/// @inheritdoc IRewardVault
function whitelistIncentiveToken(
address token,
uint256 minIncentiveRate,
address manager
)
external
onlyFactoryOwner
{
// validate `minIncentiveRate` value
if (minIncentiveRate == 0) MinIncentiveRateIsZero.selector.revertWith();
if (minIncentiveRate > MAX_INCENTIVE_RATE) IncentiveRateTooHigh.selector.revertWith();
// validate token and manager address
if (token == address(0) || manager == address(0)) ZeroAddress.selector.revertWith();
Incentive storage incentive = incentives[token];
if (whitelistedTokens.length == maxIncentiveTokensCount || incentive.minIncentiveRate != 0) {
TokenAlreadyWhitelistedOrLimitReached.selector.revertWith();
}
whitelistedTokens.push(token);
//set the incentive rate to the minIncentiveRate.
incentive.incentiveRate = minIncentiveRate;
incentive.minIncentiveRate = minIncentiveRate;
// set the manager
incentive.manager = manager;
emit IncentiveTokenWhitelisted(token, minIncentiveRate, manager);
}
/// @inheritdoc IRewardVault
function removeIncentiveToken(address token) external onlyFactoryVaultManager onlyWhitelistedToken(token) {
delete incentives[token];
// delete the token from the list.
_deleteWhitelistedTokenFromList(token);
emit IncentiveTokenRemoved(token);
}
/// @inheritdoc IRewardVault
function updateIncentiveManager(
address token,
address newManager
)
external
onlyFactoryOwner
onlyWhitelistedToken(token)
{
if (newManager == address(0)) ZeroAddress.selector.revertWith();
Incentive storage incentive = incentives[token];
// cache the current manager
address currentManager = incentive.manager;
incentive.manager = newManager;
emit IncentiveManagerChanged(token, newManager, currentManager);
}
/// @inheritdoc IRewardVault
function setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount) external onlyFactoryOwner {
if (_maxIncentiveTokensCount < whitelistedTokens.length) {
InvalidMaxIncentiveTokensCount.selector.revertWith();
}
maxIncentiveTokensCount = _maxIncentiveTokensCount;
emit MaxIncentiveTokensCountUpdated(_maxIncentiveTokensCount);
}
/// @inheritdoc IRewardVault
function pause() external onlyFactoryVaultPauser {
_pause();
}
/// @inheritdoc IRewardVault
function unpause() external onlyFactoryVaultManager {
_unpause();
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IRewardVault
function operator(address account) external view returns (address) {
return _operators[account];
}
/// @inheritdoc IRewardVault
function getWhitelistedTokensCount() external view returns (uint256) {
return whitelistedTokens.length;
}
/// @inheritdoc IRewardVault
function getWhitelistedTokens() public view returns (address[] memory) {
return whitelistedTokens;
}
/// @inheritdoc IRewardVault
function getTotalDelegateStaked(address account) external view returns (uint256) {
return _delegateStake[account].delegateTotalStaked;
}
/// @inheritdoc IRewardVault
function getDelegateStake(address account, address delegate) external view returns (uint256) {
return _delegateStake[account].stakedByDelegate[delegate];
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IRewardVault
function stake(uint256 amount) external nonReentrant whenNotPaused {
_stake(msg.sender, amount);
}
/// @inheritdoc IRewardVault
function delegateStake(address account, uint256 amount) external nonReentrant whenNotPaused {
if (msg.sender == account) NotDelegate.selector.revertWith();
_stake(account, amount);
unchecked {
DelegateStake storage info = _delegateStake[account];
// Overflow is not possible for `delegateTotalStaked` as it is bounded by the `totalSupply` which has
// been incremented in `_stake`.
info.delegateTotalStaked += amount;
// If the total staked by all delegates does not overflow, this increment is safe.
info.stakedByDelegate[msg.sender] += amount;
}
emit DelegateStaked(account, msg.sender, amount);
}
/// @inheritdoc IRewardVault
function withdraw(uint256 amount) external nonReentrant checkSelfStakedBalance(msg.sender, amount) {
_withdraw(msg.sender, amount);
}
/// @inheritdoc IRewardVault
function delegateWithdraw(address account, uint256 amount) external nonReentrant {
if (msg.sender == account) NotDelegate.selector.revertWith();
unchecked {
DelegateStake storage info = _delegateStake[account];
uint256 stakedByDelegate = info.stakedByDelegate[msg.sender];
if (stakedByDelegate < amount) InsufficientDelegateStake.selector.revertWith();
info.stakedByDelegate[msg.sender] = stakedByDelegate - amount;
// underflow is impossible because `info.delegateTotalStaked` >= `stakedByDelegate` >= `amount`
info.delegateTotalStaked -= amount;
}
_withdraw(account, amount);
emit DelegateWithdrawn(account, msg.sender, amount);
}
/// @inheritdoc IRewardVault
function getReward(
address account,
address recipient
)
external
nonReentrant
onlyOperatorOrUser(account)
returns (uint256)
{
return _getReward(account, recipient);
}
/// @inheritdoc IRewardVault
function exit(address recipient) external nonReentrant {
// self-staked amount
uint256 amount = _accountInfo[msg.sender].balance - _delegateStake[msg.sender].delegateTotalStaked;
_withdraw(msg.sender, amount);
_getReward(msg.sender, recipient);
}
/// @inheritdoc IRewardVault
function setOperator(address _operator) external {
_operators[msg.sender] = _operator;
emit OperatorSet(msg.sender, _operator);
}
/// @inheritdoc IRewardVault
function addIncentive(
address token,
uint256 amount,
uint256 incentiveRate
)
external
nonReentrant
onlyWhitelistedToken(token)
{
if (incentiveRate > MAX_INCENTIVE_RATE) IncentiveRateTooHigh.selector.revertWith();
Incentive storage incentive = incentives[token];
(uint256 minIncentiveRate, uint256 incentiveRateStored, uint256 amountRemainingBefore, address manager) =
(incentive.minIncentiveRate, incentive.incentiveRate, incentive.amountRemaining, incentive.manager);
// Only allow the incentive token manager to add incentive.
if (msg.sender != manager) NotIncentiveManager.selector.revertWith();
// The incentive amount should be equal to or greater than the `minIncentiveRate` to avoid spamming.
// If the `minIncentiveRate` is 100 USDC/BGT, the amount should be at least 100 USDC.
if (amount < minIncentiveRate) AmountLessThanMinIncentiveRate.selector.revertWith();
// The incentive rate should be greater than or equal to the `minIncentiveRate`.
if (incentiveRate < minIncentiveRate) InvalidIncentiveRate.selector.revertWith();
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
incentive.amountRemaining = amountRemainingBefore + amount;
// Allows updating the incentive rate if the remaining incentive amount is 0.
// Allow to decrease the incentive rate when accounted incentives are finished.
if (amountRemainingBefore == 0) {
incentive.incentiveRate = incentiveRate;
}
// Always allow to increase the incentive rate.
else if (incentiveRate >= incentiveRateStored) {
incentive.incentiveRate = incentiveRate;
}
// If the remaining incentive amount is not 0 and the new rate is less than the current rate, revert.
else {
InvalidIncentiveRate.selector.revertWith();
}
emit IncentiveAdded(token, msg.sender, amount, incentive.incentiveRate);
}
/// @inheritdoc IRewardVault
function accountIncentives(address token, uint256 amount) external nonReentrant onlyWhitelistedToken(token) {
Incentive storage incentive = incentives[token];
(uint256 minIncentiveRate, uint256 incentiveRateStored, uint256 amountRemainingBefore, address manager) =
(incentive.minIncentiveRate, incentive.incentiveRate, incentive.amountRemaining, incentive.manager);
// Only allow the incentive token manager to account for cumulated incentives.
if (msg.sender != manager) NotIncentiveManager.selector.revertWith();
if (amount < minIncentiveRate) AmountLessThanMinIncentiveRate.selector.revertWith();
uint256 incentiveBalance = IERC20(token).balanceOf(address(this));
if (amount > incentiveBalance - amountRemainingBefore) NotEnoughBalance.selector.revertWith();
incentive.amountRemaining += amount;
emit IncentiveAdded(token, msg.sender, amount, incentiveRateStored);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Check if the account has enough self-staked balance.
/// @param account The account to check the self-staked balance for.
/// @param amount The amount being withdrawn.
function _checkSelfStakedBalance(address account, uint256 amount) internal view {
unchecked {
uint256 selfStaked = _accountInfo[account].balance - _delegateStake[account].delegateTotalStaked;
if (selfStaked < amount) InsufficientSelfStake.selector.revertWith();
}
}
/// @dev The Distributor grants this contract the allowance to transfer the BGT in its balance.
function _safeTransferRewardToken(address to, uint256 amount) internal override {
rewardToken.safeTransferFrom(distributor, to, amount);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
function _checkRewardSolvency() internal view override {
uint256 allowance = rewardToken.allowance(distributor, address(this));
if (undistributedRewards / PRECISION > allowance) InsolventReward.selector.revertWith();
}
/// @notice process the incentives for a validator.
/// @notice If a token transfer consumes more than 500k gas units, the transfer alone will fail.
/// @param pubkey The pubkey of the validator to process the incentives for.
/// @param bgtEmitted The amount of BGT emitted by the validator.
function _processIncentives(bytes calldata pubkey, uint256 bgtEmitted) internal {
// Validator's operator corresponding to the pubkey receives the incentives.
// The pubkey -> operator relationship is maintained by the BeaconDeposit contract.
address _operator = beaconDepositContract.getOperator(pubkey);
IBeraChef beraChef = IDistributor(distributor).beraChef();
address bgtIncentiveDistributor = getBGTIncentiveDistributor();
uint256 whitelistedTokensCount = whitelistedTokens.length;
unchecked {
for (uint256 i; i < whitelistedTokensCount; ++i) {
address token = whitelistedTokens[i];
Incentive storage incentive = incentives[token];
uint256 amount = FixedPointMathLib.mulDiv(bgtEmitted, incentive.incentiveRate, PRECISION);
uint256 amountRemaining = incentive.amountRemaining;
amount = FixedPointMathLib.min(amount, amountRemaining);
uint256 validatorShare;
if (amount > 0) {
validatorShare = beraChef.getValidatorIncentiveTokenShare(pubkey, amount);
amount -= validatorShare;
}
if (validatorShare > 0) {
// Transfer the validator share of the incentive to its operator address.
// slither-disable-next-line arbitrary-send-erc20
bool success = token.trySafeTransfer(_operator, validatorShare);
if (success) {
// Update the remaining amount only if tokens were transferred.
amountRemaining -= validatorShare;
emit IncentivesProcessed(pubkey, token, bgtEmitted, validatorShare);
} else {
emit IncentivesProcessFailed(pubkey, token, bgtEmitted, validatorShare);
}
}
if (amount > 0) {
// Transfer the remaining amount of the incentive to the bgtIncentiveDistributor contract for
// distribution among BGT boosters.
// give the bgtIncentiveDistributor the allowance to transfer the incentive token.
bytes memory data = abi.encodeCall(IERC20.approve, (bgtIncentiveDistributor, amount));
(bool success,) = token.call{ gas: SAFE_GAS_LIMIT }(data);
if (success) {
// reuse the already defined data variable to avoid stack too deep error.
data = abi.encodeCall(IBGTIncentiveDistributor.receiveIncentive, (pubkey, token, amount));
(success,) = bgtIncentiveDistributor.call{ gas: SAFE_GAS_LIMIT }(data);
if (success) {
amountRemaining -= amount;
emit BGTBoosterIncentivesProcessed(pubkey, token, bgtEmitted, amount);
} else {
// If the transfer fails, set the allowance back to 0.
// If we don't reset the allowance, the approved tokens remain unused, and future calls to
// _processIncentives would revert for tokens like USDT that require allowance to be 0
// before setting a new value, blocking the entire incentive distribution process.
data = abi.encodeCall(IERC20.approve, (bgtIncentiveDistributor, 0));
(success,) = token.call{ gas: SAFE_GAS_LIMIT }(data);
emit BGTBoosterIncentivesProcessFailed(pubkey, token, bgtEmitted, amount);
}
}
// if the approve fails, log the failure in sending the incentive to the bgtIncentiveDistributor.
else {
emit BGTBoosterIncentivesProcessFailed(pubkey, token, bgtEmitted, amount);
}
}
incentive.amountRemaining = amountRemaining;
}
}
}
function _deleteWhitelistedTokenFromList(address token) internal {
uint256 activeTokens = whitelistedTokens.length;
// The length of `whitelistedTokens` cannot be 0 because the `onlyWhitelistedToken` check has already been
// performed.
unchecked {
for (uint256 i; i < activeTokens; ++i) {
if (token == whitelistedTokens[i]) {
whitelistedTokens[i] = whitelistedTokens[activeTokens - 1];
whitelistedTokens.pop();
return;
}
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
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.1.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 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 {
/**
* @dev An operation with an ERC-20 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.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
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.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
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.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
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 Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
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 silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Pausable
struct PausableStorage {
bool _paused;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
/**
* @dev The operation failed because the contract is paused.
*/
error EnforcedPause();
/**
* @dev The operation failed because the contract is not paused.
*/
error ExpectedPause();
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
* consider using {ReentrancyGuardTransient} instead.
*
* 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 ReentrancyGuardUpgradeable is Initializable {
// 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;
/// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard
struct ReentrancyGuardStorage {
uint256 _status;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
assembly {
$.slot := ReentrancyGuardStorageLocation
}
}
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
$._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 {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// 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 {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// 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) {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
return $._status == ENTERED;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
library FixedPointMathLib {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The operation failed, as the output exceeds the maximum value of uint256.
error ExpOverflow();
/// @dev The operation failed, as the output exceeds the maximum value of uint256.
error FactorialOverflow();
/// @dev The operation failed, due to an overflow.
error RPowOverflow();
/// @dev The mantissa is too big to fit.
error MantissaOverflow();
/// @dev The operation failed, due to an multiplication overflow.
error MulWadFailed();
/// @dev The operation failed, due to an multiplication overflow.
error SMulWadFailed();
/// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.
error DivWadFailed();
/// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.
error SDivWadFailed();
/// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.
error MulDivFailed();
/// @dev The division failed, as the denominator is zero.
error DivFailed();
/// @dev The full precision multiply-divide operation failed, either due
/// to the result being larger than 256 bits, or a division by a zero.
error FullMulDivFailed();
/// @dev The output is undefined, as the input is less-than-or-equal to zero.
error LnWadUndefined();
/// @dev The input outside the acceptable domain.
error OutOfDomain();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The scalar of ETH and most ERC20s.
uint256 internal constant WAD = 1e18;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* SIMPLIFIED FIXED POINT OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Equivalent to `(x * y) / WAD` rounded down.
function mulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Equivalent to `require(y == 0 || x <= type(uint256).max / y)`.
if gt(x, div(not(0), y)) {
if y {
mstore(0x00, 0xbac65e5b) // `MulWadFailed()`.
revert(0x1c, 0x04)
}
}
z := div(mul(x, y), WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded down.
function sMulWad(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(x, y)
// Equivalent to `require((x == 0 || z / x == y) && !(x == -1 && y == type(int256).min))`.
if iszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {
mstore(0x00, 0xedcd4dd4) // `SMulWadFailed()`.
revert(0x1c, 0x04)
}
z := sdiv(z, WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded down, but without overflow checks.
function rawMulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := div(mul(x, y), WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded down, but without overflow checks.
function rawSMulWad(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := sdiv(mul(x, y), WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded up.
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(x, y)
// Equivalent to `require(y == 0 || x <= type(uint256).max / y)`.
if iszero(eq(div(z, y), x)) {
if y {
mstore(0x00, 0xbac65e5b) // `MulWadFailed()`.
revert(0x1c, 0x04)
}
}
z := add(iszero(iszero(mod(z, WAD))), div(z, WAD))
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded up, but without overflow checks.
function rawMulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down.
function divWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Equivalent to `require(y != 0 && x <= type(uint256).max / WAD)`.
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d) // `DivWadFailed()`.
revert(0x1c, 0x04)
}
z := div(mul(x, WAD), y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down.
function sDivWad(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(x, WAD)
// Equivalent to `require(y != 0 && ((x * WAD) / WAD == x))`.
if iszero(mul(y, eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d) // `SDivWadFailed()`.
revert(0x1c, 0x04)
}
z := sdiv(z, y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down, but without overflow and divide by zero checks.
function rawDivWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := div(mul(x, WAD), y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down, but without overflow and divide by zero checks.
function rawSDivWad(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := sdiv(mul(x, WAD), y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded up.
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Equivalent to `require(y != 0 && x <= type(uint256).max / WAD)`.
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d) // `DivWadFailed()`.
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded up, but without overflow and divide by zero checks.
function rawDivWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
/// @dev Equivalent to `x` to the power of `y`.
/// because `x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)`.
/// Note: This function is an approximation.
function powWad(int256 x, int256 y) internal pure returns (int256) {
// Using `ln(x)` means `x` must be greater than 0.
return expWad((lnWad(x) * y) / int256(WAD));
}
/// @dev Returns `exp(x)`, denominated in `WAD`.
/// Credit to Remco Bloemen under MIT license: https://2π.com/22/exp-ln
/// Note: This function is an approximation. Monotonically increasing.
function expWad(int256 x) internal pure returns (int256 r) {
unchecked {
// When the result is less than 0.5 we return zero.
// This happens when `x <= (log(1e-18) * 1e18) ~ -4.15e19`.
if (x <= -41446531673892822313) return r;
/// @solidity memory-safe-assembly
assembly {
// When the result is greater than `(2**255 - 1) / 1e18` we can not represent it as
// an int. This happens when `x >= floor(log((2**255 - 1) / 1e18) * 1e18) ≈ 135`.
if iszero(slt(x, 135305999368893231589)) {
mstore(0x00, 0xa37bfec9) // `ExpOverflow()`.
revert(0x1c, 0x04)
}
}
// `x` is now in the range `(-42, 136) * 1e18`. Convert to `(-42, 136) * 2**96`
// for more intermediate precision and a binary basis. This base conversion
// is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
x = (x << 78) / 5 ** 18;
// Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers
// of two such that exp(x) = exp(x') * 2**k, where k is an integer.
// Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;
x = x - k * 54916777467707473351141471128;
// `k` is in the range `[-61, 195]`.
// Evaluate using a (6, 7)-term rational approximation.
// `p` is made monic, we'll multiply by a scale factor later.
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
// We leave `p` in `2**192` basis so we don't need to scale it back up for the division.
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
/// @solidity memory-safe-assembly
assembly {
// Div in assembly because solidity adds a zero check despite the unchecked.
// The q polynomial won't have zeros in the domain as all its roots are complex.
// No scaling is necessary because p is already `2**96` too large.
r := sdiv(p, q)
}
// r should be in the range `(0.09, 0.25) * 2**96`.
// We now need to multiply r by:
// - The scale factor `s ≈ 6.031367120`.
// - The `2**k` factor from the range reduction.
// - The `1e18 / 2**96` factor for base conversion.
// We do this all at once, with an intermediate result in `2**213`
// basis, so the final right shift is always by a positive amount.
r = int256(
(uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)
);
}
}
/// @dev Returns `ln(x)`, denominated in `WAD`.
/// Credit to Remco Bloemen under MIT license: https://2π.com/22/exp-ln
/// Note: This function is an approximation. Monotonically increasing.
function lnWad(int256 x) internal pure returns (int256 r) {
/// @solidity memory-safe-assembly
assembly {
// We want to convert `x` from `10**18` fixed point to `2**96` fixed point.
// We do this by multiplying by `2**96 / 10**18`. But since
// `ln(x * C) = ln(x) + ln(C)`, we can simply do nothing here
// and add `ln(2**96 / 10**18)` at the end.
// Compute `k = log2(x) - 96`, `r = 159 - k = 255 - log2(x) = 255 ^ log2(x)`.
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
// We place the check here for more optimal stack operations.
if iszero(sgt(x, 0)) {
mstore(0x00, 0x1615e638) // `LnWadUndefined()`.
revert(0x1c, 0x04)
}
// forgefmt: disable-next-item
r := xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))
// Reduce range of x to (1, 2) * 2**96
// ln(2^k * x) = k * ln(2) + ln(x)
x := shr(159, shl(r, x))
// Evaluate using a (8, 8)-term rational approximation.
// `p` is made monic, we will multiply by a scale factor later.
// forgefmt: disable-next-item
let p := sub( // This heavily nested expression is to avoid stack-too-deep for via-ir.
sar(96, mul(add(43456485725739037958740375743393,
sar(96, mul(add(24828157081833163892658089445524,
sar(96, mul(add(3273285459638523848632254066296,
x), x))), x))), x)), 11111509109440967052023855526967)
p := sub(sar(96, mul(p, x)), 45023709667254063763336534515857)
p := sub(sar(96, mul(p, x)), 14706773417378608786704636184526)
p := sub(mul(p, x), shl(96, 795164235651350426258249787498))
// We leave `p` in `2**192` basis so we don't need to scale it back up for the division.
// `q` is monic by convention.
let q := add(5573035233440673466300451813936, x)
q := add(71694874799317883764090561454958, sar(96, mul(x, q)))
q := add(283447036172924575727196451306956, sar(96, mul(x, q)))
q := add(401686690394027663651624208769553, sar(96, mul(x, q)))
q := add(204048457590392012362485061816622, sar(96, mul(x, q)))
q := add(31853899698501571402653359427138, sar(96, mul(x, q)))
q := add(909429971244387300277376558375, sar(96, mul(x, q)))
// `p / q` is in the range `(0, 0.125) * 2**96`.
// Finalization, we need to:
// - Multiply by the scale factor `s = 5.549…`.
// - Add `ln(2**96 / 10**18)`.
// - Add `k * ln(2)`.
// - Multiply by `10**18 / 2**96 = 5**18 >> 78`.
// The q polynomial is known not to have zeros in the domain.
// No scaling required because p is already `2**96` too large.
p := sdiv(p, q)
// Multiply by the scaling factor: `s * 5**18 * 2**96`, base is now `5**18 * 2**192`.
p := mul(1677202110996718588342820967067443963516166, p)
// Add `ln(2) * k * 5**18 * 2**192`.
// forgefmt: disable-next-item
p := add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)
// Add `ln(2**96 / 10**18) * 5**18 * 2**192`.
p := add(600920179829731861736702779321621459595472258049074101567377883020018308, p)
// Base conversion: mul `2**18 / 2**192`.
r := sar(174, p)
}
}
/// @dev Returns `W_0(x)`, denominated in `WAD`.
/// See: https://en.wikipedia.org/wiki/Lambert_W_function
/// a.k.a. Product log function. This is an approximation of the principal branch.
/// Note: This function is an approximation. Monotonically increasing.
function lambertW0Wad(int256 x) internal pure returns (int256 w) {
// forgefmt: disable-next-item
unchecked {
if ((w = x) <= -367879441171442322) revert OutOfDomain(); // `x` less than `-1/e`.
(int256 wad, int256 p) = (int256(WAD), x);
uint256 c; // Whether we need to avoid catastrophic cancellation.
uint256 i = 4; // Number of iterations.
if (w <= 0x1ffffffffffff) {
if (-0x4000000000000 <= w) {
i = 1; // Inputs near zero only take one step to converge.
} else if (w <= -0x3ffffffffffffff) {
i = 32; // Inputs near `-1/e` take very long to converge.
}
} else if (uint256(w >> 63) == uint256(0)) {
/// @solidity memory-safe-assembly
assembly {
// Inline log2 for more performance, since the range is small.
let v := shr(49, w)
let l := shl(3, lt(0xff, v))
l := add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000)), 49)
w := sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))
c := gt(l, 60)
i := add(2, add(gt(l, 53), c))
}
} else {
int256 ll = lnWad(w = lnWad(w));
/// @solidity memory-safe-assembly
assembly {
// `w = ln(x) - ln(ln(x)) + b * ln(ln(x)) / ln(x)`.
w := add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))
i := add(3, iszero(shr(68, x)))
c := iszero(shr(143, x))
}
if (c == uint256(0)) {
do { // If `x` is big, use Newton's so that intermediate values won't overflow.
int256 e = expWad(w);
/// @solidity memory-safe-assembly
assembly {
let t := mul(w, div(e, wad))
w := sub(w, sdiv(sub(t, x), div(add(e, t), wad)))
}
if (p <= w) break;
p = w;
} while (--i != uint256(0));
/// @solidity memory-safe-assembly
assembly {
w := sub(w, sgt(w, 2))
}
return w;
}
}
do { // Otherwise, use Halley's for faster convergence.
int256 e = expWad(w);
/// @solidity memory-safe-assembly
assembly {
let t := add(w, wad)
let s := sub(mul(w, e), mul(x, wad))
w := sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))
}
if (p <= w) break;
p = w;
} while (--i != c);
/// @solidity memory-safe-assembly
assembly {
w := sub(w, sgt(w, 2))
}
// For certain ranges of `x`, we'll use the quadratic-rate recursive formula of
// R. Iacono and J.P. Boyd for the last iteration, to avoid catastrophic cancellation.
if (c == uint256(0)) return w;
int256 t = w | 1;
/// @solidity memory-safe-assembly
assembly {
x := sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
/// @solidity memory-safe-assembly
assembly {
w := sdiv(x, add(wad, t))
}
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GENERAL NUMBER UTILITIES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Calculates `floor(x * y / d)` with full precision.
/// Throws if result overflows a uint256 or when `d` is zero.
/// Credit to Remco Bloemen under MIT license: https://2π.com/21/muldiv
function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
// 512-bit multiply `[p1 p0] = x * y`.
// Compute the product mod `2**256` and mod `2**256 - 1`
// then use the Chinese Remainder Theorem to reconstruct
// the 512 bit result. The result is stored in two 256
// variables such that `product = p1 * 2**256 + p0`.
// Temporarily use `result` as `p0` to save gas.
result := mul(x, y) // Lower 256 bits of `x * y`.
for {} 1 {} {
// If overflows.
if iszero(mul(or(iszero(x), eq(div(result, x), y)), d)) {
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result))) // Upper 256 bits of `x * y`.
/*------------------- 512 by 256 division --------------------*/
// Make division exact by subtracting the remainder from `[p1 p0]`.
let r := mulmod(x, y, d) // Compute remainder using mulmod.
let t := and(d, sub(0, d)) // The least significant bit of `d`. `t >= 1`.
// Make sure the result is less than `2**256`. Also prevents `d == 0`.
// Placing the check here seems to give more optimal stack operations.
if iszero(gt(d, p1)) {
mstore(0x00, 0xae47f702) // `FullMulDivFailed()`.
revert(0x1c, 0x04)
}
d := div(d, t) // Divide `d` by `t`, which is a power of two.
// Invert `d mod 2**256`
// Now that `d` is an odd number, it has an inverse
// modulo `2**256` such that `d * inv = 1 mod 2**256`.
// Compute the inverse by starting with a seed that is correct
// correct for four bits. That is, `d * inv = 1 mod 2**4`.
let inv := xor(2, mul(3, d))
// Now use Newton-Raphson iteration to improve the precision.
// Thanks to Hensel's lifting lemma, this also works in modular
// arithmetic, doubling the correct bits in each step.
inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**8
inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**16
inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**32
inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**64
inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**128
result :=
mul(
// Divide [p1 p0] by the factors of two.
// Shift in bits from `p1` into `p0`. For this we need
// to flip `t` such that it is `2**256 / t`.
or(
mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)),
div(sub(result, r), t)
),
mul(sub(2, mul(d, inv)), inv) // inverse mod 2**256
)
break
}
result := div(result, d)
break
}
}
}
/// @dev Calculates `floor(x * y / d)` with full precision.
/// Behavior is undefined if `d` is zero or the final result cannot fit in 256 bits.
/// Performs the full 512 bit calculation regardless.
function fullMulDivUnchecked(uint256 x, uint256 y, uint256 d)
internal
pure
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
result := mul(x, y)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result)))
let t := and(d, sub(0, d))
let r := mulmod(x, y, d)
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
result :=
mul(
or(mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)), div(sub(result, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
}
}
/// @dev Calculates `floor(x * y / d)` with full precision, rounded up.
/// Throws if result overflows a uint256 or when `d` is zero.
/// Credit to Uniswap-v3-core under MIT license:
/// https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/FullMath.sol
function fullMulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
result = fullMulDiv(x, y, d);
/// @solidity memory-safe-assembly
assembly {
if mulmod(x, y, d) {
result := add(result, 1)
if iszero(result) {
mstore(0x00, 0xae47f702) // `FullMulDivFailed()`.
revert(0x1c, 0x04)
}
}
}
}
/// @dev Returns `floor(x * y / d)`.
/// Reverts if `x * y` overflows, or `d` is zero.
function mulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(x, y)
// Equivalent to `require(d != 0 && (y == 0 || x <= type(uint256).max / y))`.
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27) // `MulDivFailed()`.
revert(0x1c, 0x04)
}
z := div(z, d)
}
}
/// @dev Returns `ceil(x * y / d)`.
/// Reverts if `x * y` overflows, or `d` is zero.
function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(x, y)
// Equivalent to `require(d != 0 && (y == 0 || x <= type(uint256).max / y))`.
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27) // `MulDivFailed()`.
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(z, d))), div(z, d))
}
}
/// @dev Returns `ceil(x / d)`.
/// Reverts if `d` is zero.
function divUp(uint256 x, uint256 d) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
if iszero(d) {
mstore(0x00, 0x65244e4e) // `DivFailed()`.
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(x, d))), div(x, d))
}
}
/// @dev Returns `max(0, x - y)`.
function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
/// @dev Returns `condition ? x : y`, without branching.
function ternary(bool condition, uint256 x, uint256 y) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := xor(x, mul(xor(x, y), iszero(condition)))
}
}
/// @dev Exponentiate `x` to `y` by squaring, denominated in base `b`.
/// Reverts if the computation overflows.
function rpow(uint256 x, uint256 y, uint256 b) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(b, iszero(y)) // `0 ** 0 = 1`. Otherwise, `0 ** n = 0`.
if x {
z := xor(b, mul(xor(b, x), and(y, 1))) // `z = isEven(y) ? scale : x`
let half := shr(1, b) // Divide `b` by 2.
// Divide `y` by 2 every iteration.
for { y := shr(1, y) } y { y := shr(1, y) } {
let xx := mul(x, x) // Store x squared.
let xxRound := add(xx, half) // Round to the nearest number.
// Revert if `xx + half` overflowed, or if `x ** 2` overflows.
if or(lt(xxRound, xx), shr(128, x)) {
mstore(0x00, 0x49f7642b) // `RPowOverflow()`.
revert(0x1c, 0x04)
}
x := div(xxRound, b) // Set `x` to scaled `xxRound`.
// If `y` is odd:
if and(y, 1) {
let zx := mul(z, x) // Compute `z * x`.
let zxRound := add(zx, half) // Round to the nearest number.
// If `z * x` overflowed or `zx + half` overflowed:
if or(xor(div(zx, x), z), lt(zxRound, zx)) {
// Revert if `x` is non-zero.
if x {
mstore(0x00, 0x49f7642b) // `RPowOverflow()`.
revert(0x1c, 0x04)
}
}
z := div(zxRound, b) // Return properly scaled `zxRound`.
}
}
}
}
}
/// @dev Returns the square root of `x`, rounded down.
function sqrt(uint256 x) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// `floor(sqrt(2**15)) = 181`. `sqrt(2**15) - 181 = 2.84`.
z := 181 // The "correct" value is 1, but this saves a multiplication later.
// This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
// start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.
// Let `y = x / 2**r`. We check `y >= 2**(k + 8)`
// but shift right by `k` bits to ensure that if `x >= 256`, then `y >= 256`.
let r := shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffffff, shr(r, x))))
z := shl(shr(1, r), z)
// Goal was to get `z*z*y` within a small factor of `x`. More iterations could
// get y in a tighter range. Currently, we will have y in `[256, 256*(2**16))`.
// We ensured `y >= 256` so that the relative difference between `y` and `y+1` is small.
// That's not possible if `x < 256` but we can just verify those cases exhaustively.
// Now, `z*z*y <= x < z*z*(y+1)`, and `y <= 2**(16+8)`, and either `y >= 256`, or `x < 256`.
// Correctness can be checked exhaustively for `x < 256`, so we assume `y >= 256`.
// Then `z*sqrt(y)` is within `sqrt(257)/sqrt(256)` of `sqrt(x)`, or about 20bps.
// For `s` in the range `[1/256, 256]`, the estimate `f(s) = (181/1024) * (s+1)`
// is in the range `(1/2.84 * sqrt(s), 2.84 * sqrt(s))`,
// with largest error when `s = 1` and when `s = 256` or `1/256`.
// Since `y` is in `[256, 256*(2**16))`, let `a = y/65536`, so that `a` is in `[1/256, 256)`.
// Then we can estimate `sqrt(y)` using
// `sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2**18`.
// There is no overflow risk here since `y < 2**136` after the first branch above.
z := shr(18, mul(z, add(shr(r, x), 65536))) // A `mul()` is saved from starting `z` at 181.
// Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
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)))
// If `x+1` is a perfect square, the Babylonian method cycles between
// `floor(sqrt(x))` and `ceil(sqrt(x))`. This statement ensures we return floor.
// See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
z := sub(z, lt(div(x, z), z))
}
}
/// @dev Returns the cube root of `x`, rounded down.
/// Credit to bout3fiddy and pcaversaccio under AGPLv3 license:
/// https://github.com/pcaversaccio/snekmate/blob/main/src/utils/Math.vy
/// Formally verified by xuwinnie:
/// https://github.com/vectorized/solady/blob/main/audits/xuwinnie-solady-cbrt-proof.pdf
function cbrt(uint256 x) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
// Makeshift lookup table to nudge the approximate log2 result.
z := div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))
// Newton-Raphson's.
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
// Round down.
z := sub(z, lt(div(x, mul(z, z)), z))
}
}
/// @dev Returns the square root of `x`, denominated in `WAD`, rounded down.
function sqrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 18) return sqrt(x * 10 ** 18);
z = (1 + sqrt(x)) * 10 ** 9;
z = (fullMulDivUnchecked(x, 10 ** 18, z) + z) >> 1;
}
/// @solidity memory-safe-assembly
assembly {
z := sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1))) // Round down.
}
}
/// @dev Returns the cube root of `x`, denominated in `WAD`, rounded down.
/// Formally verified by xuwinnie:
/// https://github.com/vectorized/solady/blob/main/audits/xuwinnie-solady-cbrt-proof.pdf
function cbrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 36) return cbrt(x * 10 ** 36);
z = (1 + cbrt(x)) * 10 ** 12;
z = (fullMulDivUnchecked(x, 10 ** 36, z * z) + z + z) / 3;
}
/// @solidity memory-safe-assembly
assembly {
let p := x
for {} 1 {} {
if iszero(shr(229, p)) {
if iszero(shr(199, p)) {
p := mul(p, 100000000000000000) // 10 ** 17.
break
}
p := mul(p, 100000000) // 10 ** 8.
break
}
if iszero(shr(249, p)) { p := mul(p, 100) }
break
}
let t := mulmod(mul(z, z), z, p)
z := sub(z, gt(lt(t, shr(1, p)), iszero(t))) // Round down.
}
}
/// @dev Returns the factorial of `x`.
function factorial(uint256 x) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
assembly {
result := 1
if iszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2) // `FactorialOverflow()`.
revert(0x1c, 0x04)
}
for {} x { x := sub(x, 1) } { result := mul(result, x) }
}
}
/// @dev Returns the log2 of `x`.
/// Equivalent to computing the index of the most significant bit (MSB) of `x`.
/// Returns 0 if `x` is zero.
function log2(uint256 x) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
// forgefmt: disable-next-item
r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000))
}
}
/// @dev Returns the log2 of `x`, rounded up.
/// Returns 0 if `x` is zero.
function log2Up(uint256 x) internal pure returns (uint256 r) {
r = log2(x);
/// @solidity memory-safe-assembly
assembly {
r := add(r, lt(shl(r, 1), x))
}
}
/// @dev Returns the log10 of `x`.
/// Returns 0 if `x` is zero.
function log10(uint256 x) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
if iszero(lt(x, 100000000000000000000000000000000000000)) {
x := div(x, 100000000000000000000000000000000000000)
r := 38
}
if iszero(lt(x, 100000000000000000000)) {
x := div(x, 100000000000000000000)
r := add(r, 20)
}
if iszero(lt(x, 10000000000)) {
x := div(x, 10000000000)
r := add(r, 10)
}
if iszero(lt(x, 100000)) {
x := div(x, 100000)
r := add(r, 5)
}
r := add(r, add(gt(x, 9), add(gt(x, 99), add(gt(x, 999), gt(x, 9999)))))
}
}
/// @dev Returns the log10 of `x`, rounded up.
/// Returns 0 if `x` is zero.
function log10Up(uint256 x) internal pure returns (uint256 r) {
r = log10(x);
/// @solidity memory-safe-assembly
assembly {
r := add(r, lt(exp(10, r), x))
}
}
/// @dev Returns the log256 of `x`.
/// Returns 0 if `x` is zero.
function log256(uint256 x) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(shr(3, r), lt(0xff, shr(r, x)))
}
}
/// @dev Returns the log256 of `x`, rounded up.
/// Returns 0 if `x` is zero.
function log256Up(uint256 x) internal pure returns (uint256 r) {
r = log256(x);
/// @solidity memory-safe-assembly
assembly {
r := add(r, lt(shl(shl(3, r), 1), x))
}
}
/// @dev Returns the scientific notation format `mantissa * 10 ** exponent` of `x`.
/// Useful for compressing prices (e.g. using 25 bit mantissa and 7 bit exponent).
function sci(uint256 x) internal pure returns (uint256 mantissa, uint256 exponent) {
/// @solidity memory-safe-assembly
assembly {
mantissa := x
if mantissa {
if iszero(mod(mantissa, 1000000000000000000000000000000000)) {
mantissa := div(mantissa, 1000000000000000000000000000000000)
exponent := 33
}
if iszero(mod(mantissa, 10000000000000000000)) {
mantissa := div(mantissa, 10000000000000000000)
exponent := add(exponent, 19)
}
if iszero(mod(mantissa, 1000000000000)) {
mantissa := div(mantissa, 1000000000000)
exponent := add(exponent, 12)
}
if iszero(mod(mantissa, 1000000)) {
mantissa := div(mantissa, 1000000)
exponent := add(exponent, 6)
}
if iszero(mod(mantissa, 10000)) {
mantissa := div(mantissa, 10000)
exponent := add(exponent, 4)
}
if iszero(mod(mantissa, 100)) {
mantissa := div(mantissa, 100)
exponent := add(exponent, 2)
}
if iszero(mod(mantissa, 10)) {
mantissa := div(mantissa, 10)
exponent := add(exponent, 1)
}
}
}
}
/// @dev Convenience function for packing `x` into a smaller number using `sci`.
/// The `mantissa` will be in bits [7..255] (the upper 249 bits).
/// The `exponent` will be in bits [0..6] (the lower 7 bits).
/// Use `SafeCastLib` to safely ensure that the `packed` number is small
/// enough to fit in the desired unsigned integer type:
/// ```
/// uint32 packed = SafeCastLib.toUint32(FixedPointMathLib.packSci(777 ether));
/// ```
function packSci(uint256 x) internal pure returns (uint256 packed) {
(x, packed) = sci(x); // Reuse for `mantissa` and `exponent`.
/// @solidity memory-safe-assembly
assembly {
if shr(249, x) {
mstore(0x00, 0xce30380c) // `MantissaOverflow()`.
revert(0x1c, 0x04)
}
packed := or(shl(7, x), packed)
}
}
/// @dev Convenience function for unpacking a packed number from `packSci`.
function unpackSci(uint256 packed) internal pure returns (uint256 unpacked) {
unchecked {
unpacked = (packed >> 7) * 10 ** (packed & 0x7f);
}
}
/// @dev Returns the average of `x` and `y`. Rounds towards zero.
function avg(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = (x & y) + ((x ^ y) >> 1);
}
}
/// @dev Returns the average of `x` and `y`. Rounds towards negative infinity.
function avg(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = (x >> 1) + (y >> 1) + (x & y & 1);
}
}
/// @dev Returns the absolute value of `x`.
function abs(int256 x) internal pure returns (uint256 z) {
unchecked {
z = (uint256(x) + uint256(x >> 255)) ^ uint256(x >> 255);
}
}
/// @dev Returns the absolute distance between `x` and `y`.
function dist(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := add(xor(sub(0, gt(x, y)), sub(y, x)), gt(x, y))
}
}
/// @dev Returns the absolute distance between `x` and `y`.
function dist(int256 x, int256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := add(xor(sub(0, sgt(x, y)), sub(y, x)), sgt(x, y))
}
}
/// @dev Returns the minimum of `x` and `y`.
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := xor(x, mul(xor(x, y), lt(y, x)))
}
}
/// @dev Returns the minimum of `x` and `y`.
function min(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := xor(x, mul(xor(x, y), slt(y, x)))
}
}
/// @dev Returns the maximum of `x` and `y`.
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := xor(x, mul(xor(x, y), gt(y, x)))
}
}
/// @dev Returns the maximum of `x` and `y`.
function max(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := xor(x, mul(xor(x, y), sgt(y, x)))
}
}
/// @dev Returns `x`, bounded to `minValue` and `maxValue`.
function clamp(uint256 x, uint256 minValue, uint256 maxValue)
internal
pure
returns (uint256 z)
{
/// @solidity memory-safe-assembly
assembly {
z := xor(x, mul(xor(x, minValue), gt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), lt(maxValue, z)))
}
}
/// @dev Returns `x`, bounded to `minValue` and `maxValue`.
function clamp(int256 x, int256 minValue, int256 maxValue) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := xor(x, mul(xor(x, minValue), sgt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), slt(maxValue, z)))
}
}
/// @dev Returns greatest common divisor of `x` and `y`.
function gcd(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
for { z := x } y {} {
let t := y
y := mod(z, y)
z := t
}
}
}
/// @dev Returns `a + (b - a) * (t - begin) / (end - begin)`,
/// with `t` clamped between `begin` and `end` (inclusive).
/// Agnostic to the order of (`a`, `b`) and (`end`, `begin`).
/// If `begins == end`, returns `t <= begin ? a : b`.
function lerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)
internal
pure
returns (uint256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);
return a - fullMulDiv(a - b, t - begin, end - begin);
}
}
/// @dev Returns `a + (b - a) * (t - begin) / (end - begin)`.
/// with `t` clamped between `begin` and `end` (inclusive).
/// Agnostic to the order of (`a`, `b`) and (`end`, `begin`).
/// If `begins == end`, returns `t <= begin ? a : b`.
function lerp(int256 a, int256 b, int256 t, int256 begin, int256 end)
internal
pure
returns (int256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
// forgefmt: disable-next-item
unchecked {
if (b >= a) return int256(uint256(a) + fullMulDiv(uint256(b - a),
uint256(t - begin), uint256(end - begin)));
return int256(uint256(a) - fullMulDiv(uint256(a - b),
uint256(t - begin), uint256(end - begin)));
}
}
/// @dev Returns if `x` is an even number. Some people may need this.
function isEven(uint256 x) internal pure returns (bool) {
return x & uint256(1) == uint256(0);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* RAW NUMBER OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns `x + y`, without checking for overflow.
function rawAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x + y;
}
}
/// @dev Returns `x + y`, without checking for overflow.
function rawAdd(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x + y;
}
}
/// @dev Returns `x - y`, without checking for underflow.
function rawSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x - y;
}
}
/// @dev Returns `x - y`, without checking for underflow.
function rawSub(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x - y;
}
}
/// @dev Returns `x * y`, without checking for overflow.
function rawMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x * y;
}
}
/// @dev Returns `x * y`, without checking for overflow.
function rawMul(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x * y;
}
}
/// @dev Returns `x / y`, returning 0 if `y` is zero.
function rawDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := div(x, y)
}
}
/// @dev Returns `x / y`, returning 0 if `y` is zero.
function rawSDiv(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := sdiv(x, y)
}
}
/// @dev Returns `x % y`, returning 0 if `y` is zero.
function rawMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mod(x, y)
}
}
/// @dev Returns `x % y`, returning 0 if `y` is zero.
function rawSMod(int256 x, int256 y) internal pure returns (int256 z) {
/// @solidity memory-safe-assembly
assembly {
z := smod(x, y)
}
}
/// @dev Returns `(x + y) % d`, return 0 if `d` if zero.
function rawAddMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := addmod(x, y, d)
}
}
/// @dev Returns `(x * y) % d`, return 0 if `d` if zero.
function rawMulMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mulmod(x, y, d)
}
}
}// SPDX-License-Identifier: BUSL-1.1
// solhint-disable-next-line compiler-version
pragma solidity 0.8.26;
import { SafeTransferLib } from "solady/src/utils/SafeTransferLib.sol";
library Utils {
using SafeTransferLib for address;
/// @notice The gas limit for a transfer, used to prevent malicious token griefing.
uint32 constant TRANSFER_GAS_LIMIT = 500_000;
/// @notice Error for overflow when increasing allowance
error IncreaseAllowanceOverflow();
/// @dev Reverts with the selector of a custom error in the scratch space.
function revertWith(bytes4 selector) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
revert(0, 0x04)
}
}
/// @dev Reverts for the reason encoding a silent revert, Error(string), or a custom error.
function revertFor(bytes memory reason) internal pure {
assembly ("memory-safe") {
revert(add(reason, 0x20), mload(reason))
}
}
function revertWith(bytes4 selector, address addr) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
mstore(0x04, addr)
revert(0, 0x24) // 4 (selector) + 32 (addr)
}
}
function revertWith(bytes4 selector, uint256 amount) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
mstore(0x04, amount)
revert(0, 0x24) // 4 (selector) + 32 (amount)
}
}
function revertWith(bytes4 selector, uint256 amount1, uint256 amount2) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
mstore(0x04, amount1)
mstore(0x24, amount2)
revert(0, 0x44) // 4 (selector) + 32 (amount1) + 32 (amount2)
}
}
function revertWith(bytes4 selector, address addr1, address addr2) internal pure {
assembly ("memory-safe") {
mstore(0, selector)
mstore(0x04, addr1)
mstore(0x24, addr2)
revert(0, 0x44) // 4 (selector) + 32 (addr1) + 32 (addr2)
}
}
/// @dev Increase the calling contract's allowance toward `spender` by `amount`.
/// @dev Does not check if token exists.
function safeIncreaseAllowance(address token, address spender, uint256 amount) internal {
unchecked {
uint256 oldAllowance = allowance(token, address(this), spender);
uint256 newAllowance = oldAllowance + amount;
if (newAllowance < oldAllowance) revertWith(IncreaseAllowanceOverflow.selector);
token.safeApprove(spender, newAllowance);
}
}
/// @dev Returns the amount of ERC20 `token` that `owner` has allowed `spender` to use.
/// Returns zero if the `token` does not exist.
function allowance(address token, address owner, address spender) internal view returns (uint256 amount) {
assembly ("memory-safe") {
mstore(0, 0xdd62ed3e00000000000000000000000000000000000000000000000000000000) // Store function selector of
// `allowance(address,address)`.
mstore(0x04, owner) // Store the `owner` argument.
mstore(0x24, spender) // Store the `spender` argument.
amount :=
mul( // The arguments of `mul` are evaluated from right to left.
mload(0),
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0, 0x44, 0, 0x20)
)
)
mstore(0x24, 0) // clear the upper bits of free memory pointer.
}
}
/// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
/// Doesn't revert upon failure.
function trySafeTransfer(address token, address to, uint256 amount) internal returns (bool success) {
assembly ("memory-safe") {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)` function selector.
// Perform the transfer, returning success status.
success :=
and(
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(TRANSFER_GAS_LIMIT, token, 0, 0x10, 0x44, 0x00, 0x20)
)
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
function changeDecimals(uint256 amount, uint8 from, uint8 to) internal pure returns (uint256) {
if (from == to) {
return amount;
}
if (from > to) {
return amount / (10 ** (from - to));
} else {
return amount * (10 ** (to - from));
}
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IPOLErrors } from "./IPOLErrors.sol";
/// @title IBeaconDeposit
/// @author Berachain Team.
interface IBeaconDeposit is IPOLErrors {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @dev Emitted when a deposit is made, which could mean a new validator or a top up of an existing one.
* @param pubkey the public key of the validator.
* @param credentials is the withdrawal credentials of the validator.
* @param amount the amount of stake being deposited, in Gwei.
* @param signature the signature of the deposit message.
* @param index the index of the deposit.
*/
event Deposit(bytes pubkey, bytes credentials, uint64 amount, bytes signature, uint64 index);
/**
* @notice Emitted when the operator change of a validator is queued.
* @param pubkey The pubkey of the validator.
* @param queuedOperator The new queued operator address.
* @param currentOperator The current operator address.
* @param queuedTimestamp The timestamp when the change was queued.
*/
event OperatorChangeQueued(
bytes indexed pubkey, address queuedOperator, address currentOperator, uint256 queuedTimestamp
);
/**
* @notice Emitted when the operator change of a validator is cancelled.
* @param pubkey The pubkey of the validator.
*/
event OperatorChangeCancelled(bytes indexed pubkey);
/**
* @notice Emitted when the operator of a validator is updated.
* @param pubkey The pubkey of the validator.
* @param newOperator The new operator address.
* @param previousOperator The previous operator address.
*/
event OperatorUpdated(bytes indexed pubkey, address newOperator, address previousOperator);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEWS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Get the operator address for a given pubkey.
* @dev Returns zero address if the pubkey is not registered.
* @param pubkey The pubkey of the validator.
* @return The operator address for the given pubkey.
*/
function getOperator(bytes calldata pubkey) external view returns (address);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Submit a deposit message to the Beaconchain.
* @notice This will be used to create a new validator or to top up an existing one, increasing stake.
* @param pubkey is the consensus public key of the validator.
* @param credentials is the withdrawal credentials of the validator.
* @param signature is the signature used only on the first deposit.
* @param operator is the address of the operator used for `POL` mechanics.
* @dev emits the Deposit event upon successful deposit.
* @dev Reverts if the operator is already set and caller passed non-zero operator.
*/
function deposit(
bytes calldata pubkey,
bytes calldata credentials,
bytes calldata signature,
address operator
)
external
payable;
/**
* @notice Request to change the operator of a validator.
* @dev Only the current operator can request a change.
* @param pubkey The pubkey of the validator.
* @param newOperator The new operator address.
*/
function requestOperatorChange(bytes calldata pubkey, address newOperator) external;
/**
* @notice Cancel the operator change of a validator.
* @dev Only the current operator can cancel the change.
* @param pubkey The pubkey of the validator.
*/
function cancelOperatorChange(bytes calldata pubkey) external;
/**
* @notice Accept the operator change of a validator.
* @dev Only the new operator can accept the change.
* @dev Reverts if the queue delay has not passed.
* @param pubkey The pubkey of the validator.
*/
function acceptOperatorChange(bytes calldata pubkey) external;
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IPOLErrors } from "./IPOLErrors.sol";
import { IStakingRewards } from "../../base/IStakingRewards.sol";
interface IRewardVault is IPOLErrors, IStakingRewards {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Emitted when a delegate has staked on behalf of an account.
/// @param account The account whose delegate has staked.
/// @param delegate The delegate that has staked.
/// @param amount The amount of staked tokens.
event DelegateStaked(address indexed account, address indexed delegate, uint256 amount);
/// @notice Emitted when a delegate has withdrawn on behalf of an account.
/// @param account The account whose delegate has withdrawn.
/// @param delegate The delegate that has withdrawn.
/// @param amount The amount of withdrawn tokens.
event DelegateWithdrawn(address indexed account, address indexed delegate, uint256 amount);
/// @notice Emitted when a token has been recovered.
/// @param token The token that has been recovered.
/// @param amount The amount of token recovered.
event Recovered(address token, uint256 amount);
/// @notice Emitted when the msg.sender has set an operator to handle its rewards.
/// @param account The account that has set the operator.
/// @param operator The operator that has been set.
event OperatorSet(address account, address operator);
/// @notice Emitted when the distributor is set.
/// @param distributor The address of the distributor.
event DistributorSet(address indexed distributor);
/// @notice Emitted when the manager of an incentive token is changed.
/// @param token The address of the incentive token.
/// @param newManager The new manager of the incentive token.
/// @param oldManager The old manager of the incentive token.
event IncentiveManagerChanged(address indexed token, address newManager, address oldManager);
/// @notice Emitted when an incentive token is whitelisted.
/// @param token The address of the token that has been whitelisted.
/// @param minIncentiveRate The minimum amount of the token to incentivize per BGT emission.
/// @param manager The address of the manager that can addIncentive for this incentive token.
event IncentiveTokenWhitelisted(address indexed token, uint256 minIncentiveRate, address manager);
/// @notice Emitted when an incentive token is removed.
/// @param token The address of the token that has been removed.
event IncentiveTokenRemoved(address indexed token);
/// @notice Emitted when maxIncentiveTokensCount is updated.
/// @param maxIncentiveTokensCount The max count of incentive tokens.
event MaxIncentiveTokensCountUpdated(uint8 maxIncentiveTokensCount);
/// @notice Emitted when validator share of incentives are processed to the operator address of a validator.
event IncentivesProcessed(bytes indexed pubkey, address indexed token, uint256 bgtEmitted, uint256 amount);
/// @notice Emitted when validator share of incentives fail to be processed to the operator address of a validator.
event IncentivesProcessFailed(bytes indexed pubkey, address indexed token, uint256 bgtEmitted, uint256 amount);
/// @notice Emitted when incentives are added to the vault.
/// @param token The incentive token.
/// @param sender The address that added the incentive.
/// @param amount The amount of the incentive.
/// @param incentiveRate The amount of the token to incentivize per BGT emission.
event IncentiveAdded(address indexed token, address sender, uint256 amount, uint256 incentiveRate);
/// @notice Emitted when the BGT booster share of the incentive is processed.
/// @param pubkey The pubkey of the validator.
/// @param token The address of the incentive token.
/// @param bgtEmitted The amount of BGT emitted by the validator.
/// @param amount The amount of the incentive.
event BGTBoosterIncentivesProcessed(
bytes indexed pubkey, address indexed token, uint256 bgtEmitted, uint256 amount
);
/// @notice Emitted when the BGT booster share of the incentive fails to be processed.
/// @param pubkey The pubkey of the validator.
/// @param token The address of the incentive token.
/// @param bgtEmitted The amount of BGT emitted by the validator.
/// @param amount The amount of the incentive.
event BGTBoosterIncentivesProcessFailed(
bytes indexed pubkey, address indexed token, uint256 bgtEmitted, uint256 amount
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Get the address that is allowed to distribute rewards.
/// @return The address that is allowed to distribute rewards.
function distributor() external view returns (address);
/// @notice Get the operator for an account.
/// @param account The account to get the operator for.
/// @return The operator for the account.
function operator(address account) external view returns (address);
/// @notice Get the count of active incentive tokens.
/// @return The count of active incentive tokens.
function getWhitelistedTokensCount() external view returns (uint256);
/// @notice Get the list of whitelisted tokens.
/// @return The list of whitelisted tokens.
function getWhitelistedTokens() external view returns (address[] memory);
/// @notice Get the total amount staked by delegates.
/// @return The total amount staked by delegates.
function getTotalDelegateStaked(address account) external view returns (uint256);
/// @notice Get the amount staked by a delegate on behalf of an account.
/// @return The amount staked by a delegate.
function getDelegateStake(address account, address delegate) external view returns (uint256);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ADMIN */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Initialize the vault, this is only callable once and by the factory since its the deployer.
* @param _berachef The address of the berachef.
* @param _bgt The address of the BGT token.
* @param _distributor The address of the distributor.
* @param _stakingToken The address of the staking token.
*/
function initialize(address _berachef, address _bgt, address _distributor, address _stakingToken) external;
/// @notice Allows the factory owner to set the contract that is allowed to distribute rewards.
/// @param _rewardDistribution The address that is allowed to distribute rewards.
function setDistributor(address _rewardDistribution) external;
/// @notice Allows the distributor to notify the reward amount.
/// @param pubkey The pubkey of the validator.
/// @param reward The amount of reward to notify.
function notifyRewardAmount(bytes calldata pubkey, uint256 reward) external;
/// @notice Allows the factory owner to recover any ERC20 token from the vault.
/// @param tokenAddress The address of the token to recover.
/// @param tokenAmount The amount of token to recover.
function recoverERC20(address tokenAddress, uint256 tokenAmount) external;
/// @notice Allows the factory owner to update the duration of the rewards.
/// @param _rewardsDuration The new duration of the rewards.
function setRewardsDuration(uint256 _rewardsDuration) external;
/// @notice Allows the factory owner to whitelist a token to incentivize with.
/// @param token The address of the token to whitelist.
/// @param minIncentiveRate The minimum amount of the token to incentivize per BGT emission.
/// @param manager The address of the manager that can addIncentive for this token.
function whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager) external;
/// @notice Allows the factory vault manager to remove a whitelisted incentive token.
/// @param token The address of the token to remove.
function removeIncentiveToken(address token) external;
/// @notice Allows the factory owner to update the maxIncentiveTokensCount.
/// @param _maxIncentiveTokensCount The new maxIncentiveTokens count.
function setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount) external;
/// @notice Allows the factory vault pauser to pause the vault.
function pause() external;
/// @notice Allows the factory vault manager to unpause the vault.
function unpause() external;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* MUTATIVE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Exit the vault with the staked tokens and claim the reward.
/// @dev Only the account holder can call this function, not the operator.
/// @dev Clears out the user self-staked balance and rewards.
/// @param recipient The address to send the 'BGT' reward to.
function exit(address recipient) external;
/// @notice Claim the reward.
/// @dev The operator only handles BGT, not STAKING_TOKEN.
/// @dev Callable by the operator or the account holder.
/// @param account The account to get the reward for.
/// @param recipient The address to send the reward to.
/// @return The amount of the reward claimed.
function getReward(address account, address recipient) external returns (uint256);
/// @notice Stake tokens in the vault.
/// @param amount The amount of tokens to stake.
function stake(uint256 amount) external;
/// @notice Stake tokens on behalf of another account.
/// @param account The account to stake for.
/// @param amount The amount of tokens to stake.
function delegateStake(address account, uint256 amount) external;
/// @notice Withdraw the staked tokens from the vault.
/// @param amount The amount of tokens to withdraw.
function withdraw(uint256 amount) external;
/// @notice Withdraw tokens staked on behalf of another account by the delegate (msg.sender).
/// @param account The account to withdraw for.
/// @param amount The amount of tokens to withdraw.
function delegateWithdraw(address account, uint256 amount) external;
/// @notice Allows msg.sender to set another address to claim and manage their rewards.
/// @param _operator The address that will be allowed to claim and manage rewards.
function setOperator(address _operator) external;
/// @notice Update the manager of an incentive token.
/// @dev Permissioned function, only allow factory owner to update the manager.
/// @param token The address of the incentive token.
/// @param newManager The new manager of the incentive token.
function updateIncentiveManager(address token, address newManager) external;
/// @notice Add an incentive token to the vault.
/// @notice The incentive token's transfer should not exceed a gas usage of 500k units.
/// In case the transfer exceeds 500k gas units, your incentive will fail to be transferred to the validator and
/// its delegates.
/// @param token The address of the token to add as an incentive.
/// @param amount The amount of the token to add as an incentive.
/// @param incentiveRate The amount of the token to incentivize per BGT emission.
/// @dev Permissioned function, only callable by incentive token manager.
function addIncentive(address token, uint256 amount, uint256 incentiveRate) external;
/// @notice Process incentives added via IERC20.transfer, adding them to the incentive accounting.
/// @notice Allows permissionless incentive addition, without dossing the manager possibility to
/// let the incentive accounting go to 0 in order to be able to decrease the incentive rate.
/// @param token The address of the token to process.
/// @param amount The amount of token to account as incentive.
/// @dev Permissioned function, only callable by incentive token manager.
function accountIncentives(address token, uint256 amount) external;
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { IRewardVaultFactory } from "../pol/interfaces/IRewardVaultFactory.sol";
import { Utils } from "../libraries/Utils.sol";
/// @title FactoryOwnable
/// @author Berachain Team
/// @notice Contract module which provides a modifier for restricting access to the factory owner.
abstract contract FactoryOwnable is Initializable {
using Utils for bytes4;
/// @notice Throws if sender is not the owner of factory contract.
/// @param account The address of the sender.
error OwnableUnauthorizedAccount(address account);
/// @custom:storage-location erc7201:berachain.storage.factoryOwnable
struct FactoryOwnableStorage {
address _factory;
}
// keccak256(abi.encode(uint256(keccak256("berachain.storage.factoryOwnable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant FactoryOwnableStorageLocation =
0x4e32a932fdd4658a66f9586d8955a0d0a795a01bd8251335b4fae29d972acc00;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZER */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Must be called by the initializer of the inheriting contract.
/// @param factoryAddr The address of the ownable factory contract.
function __FactoryOwnable_init(address factoryAddr) internal onlyInitializing {
_setFactory(factoryAddr);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* MODIFIERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Throws if called by any account other than the factory owner.
modifier onlyFactoryOwner() {
_checkFactoryOwner();
_;
}
/// @dev Throws if called by any account other than the factory vault manager.
modifier onlyFactoryVaultManager() {
_checkFactoryVaultManager();
_;
}
/// @dev Throws if called by any account other than the factory vault pauser.
modifier onlyFactoryVaultPauser() {
_checkFactoryVaultPauser();
_;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Returns the address of the factory contract.
function factory() public view virtual returns (address) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return $._factory;
}
/// @notice Returns if the user is a owner of the factory contract.
function isFactoryOwner(address user) public view virtual returns (bool) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return AccessControlUpgradeable($._factory).hasRole(_getAdminRole(), user);
}
/// @notice Returns if the account is a vault manager of the factory contract.
function isFactoryVaultManager(address user) public view virtual returns (bool) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return AccessControlUpgradeable($._factory).hasRole(_getVaultManagerRole(), user);
}
/// @notice Returns if the account is a vault pauser of the factory contract.
function isFactoryVaultPauser(address user) public view virtual returns (bool) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return AccessControlUpgradeable($._factory).hasRole(_getVaultPauserRole(), user);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNALS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns the DEFAULT_ADMIN_ROLE of the factory contract.
function _getAdminRole() internal view returns (bytes32) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return AccessControlUpgradeable($._factory).DEFAULT_ADMIN_ROLE();
}
/// @dev Returns the VAULT_MANAGER_ROLE of the factory contract.
function _getVaultManagerRole() internal view returns (bytes32) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return IRewardVaultFactory($._factory).VAULT_MANAGER_ROLE();
}
/// @dev Returns the VAULT_PAUSER_ROLE of the factory contract.
function _getVaultPauserRole() internal view returns (bytes32) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return IRewardVaultFactory($._factory).VAULT_PAUSER_ROLE();
}
/// @dev Returns the storage struct of the factory ownable contract.
function _getFactoryOwnableStorage() internal pure returns (FactoryOwnableStorage storage $) {
assembly {
$.slot := FactoryOwnableStorageLocation
}
}
/// @dev Returns the address of the BGTIncentiveDistributor contract.
function getBGTIncentiveDistributor() internal view returns (address) {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
return IRewardVaultFactory($._factory).bgtIncentiveDistributor();
}
/// @dev Sets the address of the factory contract.
function _setFactory(address factoryAddr) internal {
FactoryOwnableStorage storage $ = _getFactoryOwnableStorage();
$._factory = factoryAddr;
}
/// @dev Checks if the sender is a admin of the factory contract.
function _checkFactoryOwner() internal view {
if (!isFactoryOwner(msg.sender)) OwnableUnauthorizedAccount.selector.revertWith(msg.sender);
}
/// @dev Check if the sender is a vault manager of the factory contract.
function _checkFactoryVaultManager() internal view {
if (!isFactoryVaultManager(msg.sender)) OwnableUnauthorizedAccount.selector.revertWith(msg.sender);
}
/// @dev Check if the sender is a vault pauser of the factory contract.
function _checkFactoryVaultPauser() internal view {
if (!isFactoryVaultPauser(msg.sender)) OwnableUnauthorizedAccount.selector.revertWith(msg.sender);
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
import { Utils } from "../libraries/Utils.sol";
import { IStakingRewards } from "./IStakingRewards.sol";
/// @title StakingRewards
/// @author Berachain Team
/// @notice This is a minimal implementation of staking rewards logic to be inherited.
/// @dev This contract is modified and abstracted from the stable and tested:
/// https://github.com/Synthetixio/synthetix/blob/develop/contracts/StakingRewards.sol
abstract contract StakingRewards is Initializable, IStakingRewards {
using Utils for bytes4;
using SafeERC20 for IERC20;
/// @notice Struct to hold account data.
/// @param balance The balance of the staked tokens.
/// @param unclaimedReward The amount of unclaimed rewards.
/// @param rewardsPerTokenPaid The amount of rewards per token paid, scaled by PRECISION.
struct Info {
uint256 balance;
uint256 unclaimedReward;
uint256 rewardsPerTokenPaid;
}
uint256 internal constant PRECISION = 1e18;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STORAGE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice ERC20 token which users stake to earn rewards.
IERC20 public stakeToken;
/// @notice ERC20 token in which rewards are denominated and distributed.
IERC20 public rewardToken;
/// @notice The reward rate for the current reward period scaled by PRECISION.
uint256 public rewardRate;
/// @notice The amount of undistributed rewards scaled by PRECISION.
uint256 public undistributedRewards;
/// @notice The last updated reward per token scaled by PRECISION.
uint256 public rewardPerTokenStored;
/// @notice The total supply of the staked tokens.
uint256 public totalSupply;
/// @notice The end of the current reward period, where we need to start a new one.
uint256 public periodFinish;
/// @notice The time over which the rewards will be distributed. Current default is 7 days.
uint256 public rewardsDuration;
/// @notice The last time the rewards were updated.
uint256 public lastUpdateTime;
/// @notice The mapping of accounts to their data.
mapping(address account => Info) internal _accountInfo;
/// @dev This gap is used to prevent storage collisions.
uint256[50] private __gap;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZER */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Must be called by the initializer of the inheriting contract.
/// @param _stakingToken The address of the token that users will stake.
/// @param _rewardToken The address of the token that will be distributed as rewards.
/// @param _rewardsDuration The duration of the rewards cycle.
function __StakingRewards_init(
address _stakingToken,
address _rewardToken,
uint256 _rewardsDuration
)
internal
onlyInitializing
{
stakeToken = IERC20(_stakingToken);
rewardToken = IERC20(_rewardToken);
rewardsDuration = _rewardsDuration;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* MODIFIERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
modifier updateReward(address account) {
_updateReward(account);
_;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STATE MUTATING FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Notifies the staking contract of a new reward transfer.
/// @param reward The quantity of reward tokens being notified.
/// @dev Only authorized notifiers should call this method to avoid griefing or false notifications.
function _notifyRewardAmount(uint256 reward) internal virtual updateReward(address(0)) {
reward = reward * PRECISION;
if (totalSupply != 0 && block.timestamp < periodFinish) {
reward += _computeLeftOverReward();
}
undistributedRewards += reward;
_checkRewardSolvency();
if (totalSupply != 0) {
_setRewardRate();
lastUpdateTime = block.timestamp;
}
emit RewardAdded(reward);
}
/// @notice Check if the rewards are solvent.
/// @dev Inherited contracts may override this function to implement custom solvency checks.
function _checkRewardSolvency() internal view virtual {
if (undistributedRewards / PRECISION > rewardToken.balanceOf(address(this))) {
InsolventReward.selector.revertWith();
}
}
/// @notice Claims the reward for a specified account and transfers it to the specified recipient.
/// @param account The account to claim the reward for.
/// @param recipient The account to receive the reward.
/// @return The amount of the reward claimed.
function _getReward(address account, address recipient) internal virtual updateReward(account) returns (uint256) {
Info storage info = _accountInfo[account];
uint256 reward = info.unclaimedReward; // get the rewards owed to the account
if (reward != 0) {
info.unclaimedReward = 0;
_safeTransferRewardToken(recipient, reward);
emit RewardPaid(account, recipient, reward);
}
return reward;
}
/// @notice Safely transfers the reward tokens to the specified recipient.
/// @dev Inherited contracts may override this function to implement custom transfer logic.
/// @param to The recipient address.
/// @param amount The amount of reward tokens to transfer.
function _safeTransferRewardToken(address to, uint256 amount) internal virtual {
rewardToken.safeTransfer(to, amount);
}
/// @notice Stakes tokens in the vault for a specified account.
/// @param account The account to stake the tokens for.
/// @param amount The amount of tokens to stake.
function _stake(address account, uint256 amount) internal virtual {
if (amount == 0) StakeAmountIsZero.selector.revertWith();
// set the reward rate after the first stake if there are undistributed rewards
if (totalSupply == 0 && undistributedRewards > 0) {
_setRewardRate();
}
// update the rewards for the account after `rewardRate` is updated
_updateReward(account);
unchecked {
uint256 totalSupplyBefore = totalSupply; // cache storage read
uint256 totalSupplyAfter = totalSupplyBefore + amount;
// `<=` and `<` are equivalent here but the former is cheaper
if (totalSupplyAfter <= totalSupplyBefore) TotalSupplyOverflow.selector.revertWith();
totalSupply = totalSupplyAfter;
// `totalSupply` would have overflowed first because `totalSupplyBefore` >= `_accountInfo[account].balance`
_accountInfo[account].balance += amount;
}
_safeTransferFromStakeToken(msg.sender, amount);
emit Staked(account, amount);
}
/// @notice Safely transfers staking tokens from the sender to the contract.
/// @dev Inherited contracts may override this function to implement custom transfer logic.
/// @param from The address to transfer the tokens from.
/// @param amount The amount of tokens to transfer.
function _safeTransferFromStakeToken(address from, uint256 amount) internal virtual {
stakeToken.safeTransferFrom(from, address(this), amount);
}
/// @notice Withdraws staked tokens from the vault for a specified account.
/// @param account The account to withdraw the tokens for.
/// @param amount The amount of tokens to withdraw.
function _withdraw(address account, uint256 amount) internal virtual {
if (amount == 0) WithdrawAmountIsZero.selector.revertWith();
// update the rewards for the account before the balance is updated
_updateReward(account);
unchecked {
Info storage info = _accountInfo[account];
uint256 balanceBefore = info.balance; // cache storage read
if (balanceBefore < amount) InsufficientStake.selector.revertWith();
info.balance = balanceBefore - amount;
// underflow not possible because `totalSupply` >= `balanceBefore` >= `amount`
totalSupply -= amount;
}
if (totalSupply == 0 && block.timestamp < periodFinish) {
undistributedRewards += _computeLeftOverReward();
}
_safeTransferStakeToken(msg.sender, amount);
emit Withdrawn(account, amount);
}
/// @notice Safely transfers staking tokens to the specified recipient.
/// @param to The recipient address.
/// @param amount The amount of tokens to transfer.
function _safeTransferStakeToken(address to, uint256 amount) internal virtual {
stakeToken.safeTransfer(to, amount);
}
function _setRewardRate() internal virtual {
uint256 _rewardsDuration = rewardsDuration; // cache storage read
uint256 _rewardRate = undistributedRewards / _rewardsDuration;
rewardRate = _rewardRate;
periodFinish = block.timestamp + _rewardsDuration;
undistributedRewards -= _rewardRate * _rewardsDuration;
}
function _updateReward(address account) internal virtual {
uint256 _rewardPerToken = rewardPerToken(); // cache result
rewardPerTokenStored = _rewardPerToken;
// record the last time the rewards were updated
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
Info storage info = _accountInfo[account];
(info.unclaimedReward, info.rewardsPerTokenPaid) = (earned(account), _rewardPerToken);
}
}
/// @dev Allows to change `rewardsDuration` during the reward cycle, not affecting `rewardRate` which
/// will be updated upon next `_notifyRewardAmount()` call.
function _setRewardsDuration(uint256 _rewardsDuration) internal virtual {
if (_rewardsDuration == 0) RewardsDurationIsZero.selector.revertWith();
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(_rewardsDuration);
}
/// @notice Returns the left over amount scaled by PRECISION.
function _computeLeftOverReward() internal view returns (uint256 leftOver) {
uint256 remainingTime;
unchecked {
remainingTime = periodFinish - block.timestamp;
}
leftOver = rewardRate * remainingTime;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function balanceOf(address account) public view virtual returns (uint256) {
return _accountInfo[account].balance;
}
function rewards(address account) public view virtual returns (uint256) {
return _accountInfo[account].unclaimedReward;
}
function userRewardPerTokenPaid(address account) public view virtual returns (uint256) {
return _accountInfo[account].rewardsPerTokenPaid;
}
function lastTimeRewardApplicable() public view virtual returns (uint256) {
return FixedPointMathLib.min(block.timestamp, periodFinish);
}
/// @dev Gives current reward per token, result is scaled by PRECISION.
function rewardPerToken() public view virtual returns (uint256) {
uint256 _totalSupply = totalSupply; // cache storage read
if (_totalSupply == 0) return rewardPerTokenStored;
uint256 timeDelta;
unchecked {
timeDelta = lastTimeRewardApplicable() - lastUpdateTime;
}
// computes reward per token by rounding it down to avoid reverting '_getReward' with insufficient rewards
uint256 _newRewardPerToken = FixedPointMathLib.fullMulDiv(rewardRate, timeDelta, _totalSupply);
return rewardPerTokenStored + _newRewardPerToken;
}
function earned(address account) public view virtual returns (uint256) {
Info storage info = _accountInfo[account];
(uint256 balance, uint256 unclaimedReward, uint256 rewardsPerTokenPaid) =
(info.balance, info.unclaimedReward, info.rewardsPerTokenPaid);
uint256 rewardPerTokenDelta;
unchecked {
rewardPerTokenDelta = rewardPerToken() - rewardsPerTokenPaid;
}
return unclaimedReward + FixedPointMathLib.fullMulDiv(balance, rewardPerTokenDelta, PRECISION);
}
function getRewardForDuration() public view virtual returns (uint256) {
return FixedPointMathLib.fullMulDiv(rewardRate, rewardsDuration, PRECISION);
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IPOLErrors } from "./IPOLErrors.sol";
/// @notice Interface of the BeraChef module
interface IBeraChef is IPOLErrors {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRUCTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Represents a RewardAllocation entry
struct RewardAllocation {
// The block this reward allocation goes into effect.
uint64 startBlock;
// The weights of the reward allocation.
Weight[] weights;
}
/// @notice Represents a Weight entry
struct Weight {
// The address of the receiver that this weight is for.
address receiver;
// The fraction of rewards going to this receiver.
// the percentage denominator is: ONE_HUNDRED_PERCENT = 10000
// the actual fraction is: percentageNumerator / ONE_HUNDRED_PERCENT
// e.g. percentageNumerator for 50% is 5000, because 5000 / 10000 = 0.5
uint96 percentageNumerator;
}
/// @notice The struct of validator queued commission rate changes on incentive tokens.
/// @param blockNumberLast The last block number commission rate was queued
/// @param commissionRate The queued commission rate to be used by the validator
struct QueuedCommissionRateChange {
uint32 blockNumberLast;
uint96 commissionRate;
}
/// @notice Commission rate of a validator on incentive tokens
/// @param activationBlock The block number in which the commission rate was activated
/// @param commissionRate The commission rate to be used by the validator
struct CommissionRate {
uint32 activationBlock;
uint96 commissionRate;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Emitted when the maximum number of weights per reward allocation has been set.
/// @param maxNumWeightsPerRewardAllocation The maximum number of weights per reward allocation.
event MaxNumWeightsPerRewardAllocationSet(uint8 maxNumWeightsPerRewardAllocation);
/// @notice Emitted when the maximum weight per vault in a reward allocation has been set.
/// @param maxWeightPerVault The maximum weight per vault (in basis points).
event MaxWeightPerVaultSet(uint96 maxWeightPerVault);
/// @notice Emitted when the delay in blocks before a new reward allocation can go into effect has been set.
/// @param rewardAllocationBlockDelay The delay in blocks before a new reward allocation can go into effect.
event RewardAllocationBlockDelaySet(uint64 rewardAllocationBlockDelay);
/// @notice Emitted when the vault's whitelisted status have been updated.
/// @param receiver The address to remove or add as whitelisted vault.
/// @param isWhitelisted The whitelist status; true if the receiver is being whitelisted, false otherwise.
/// @param metadata The metadata of the vault.
event VaultWhitelistedStatusUpdated(address indexed receiver, bool indexed isWhitelisted, string metadata);
/**
* @notice Emitted when the metadata of a whitelisted vault has been updated.
* @param receiver The address of the whitelisted vault.
* @param metadata The metadata of the vault.
*/
event WhitelistedVaultMetadataUpdated(address indexed receiver, string metadata);
/**
* @notice Emitted when a new reward allocation has been queued.
* @param valPubkey The validator's pubkey.
* @param startBlock The block that the reward allocation goes into effect.
* @param weights The weights of the reward allocation.
*/
event QueueRewardAllocation(bytes indexed valPubkey, uint64 startBlock, Weight[] weights);
/**
* @notice Emitted when a new reward allocation has been activated.
* @param valPubkey The validator's pubkey.
* @param startBlock The block that the reward allocation goes into effect.
* @param weights The weights of the reward allocation.
*/
event ActivateRewardAllocation(bytes indexed valPubkey, uint64 startBlock, Weight[] weights);
/**
* @notice Emitted when the governance module has set a new default reward allocation.
* @param rewardAllocation The default reward allocation.
*/
event SetDefaultRewardAllocation(RewardAllocation rewardAllocation);
/**
* @notice Emitted when the commission change delay has been set.
* @param commissionChangeDelay The delay in blocks to activate a queued commission change.
*/
event CommissionChangeDelaySet(uint64 commissionChangeDelay);
/**
* @notice Emitted when a validator's commission rate on incentive tokens has been queued.
* @param valPubkey The validator's pubkey.
* @param queuedCommissionRate The queued commission rate of the validator on the incentive tokens.
*/
event QueuedValCommission(bytes indexed valPubkey, uint96 queuedCommissionRate);
/**
* @notice Emitted when the commission rate of a validator on incentive tokens has been set.
* @param valPubkey The validator's pubkey.
* @param oldCommissionRate The old commission rate of the validator on the incentive tokens.
* @param newCommissionRate The new commission rate of the validator on the incentive tokens.
*/
event ValCommissionSet(bytes indexed valPubkey, uint96 oldCommissionRate, uint96 newCommissionRate);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Returns the active reward allocation for validator with given pubkey
* @param valPubkey The validator's pubkey.
* @return rewardAllocation The active reward allocation.
*/
function getActiveRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory);
/**
* @notice Returns the queued reward allocation for a validator with given pubkey
* @param valPubkey The validator's pubkey.
* @return rewardAllocation The queued reward allocation.
*/
function getQueuedRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory);
/**
* @notice Returns the active reward allocation set by the validator with given pubkey.
* @dev This will return active reward allocation set by validators even if its not valid.
* @param valPubkey The validator's pubkey.
* @return rewardAllocation The reward allocation.
*/
function getSetActiveRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory);
/**
* @notice Returns the default reward allocation for validators that do not have a reward allocation.
* @return rewardAllocation The default reward allocation.
*/
function getDefaultRewardAllocation() external view returns (RewardAllocation memory);
/**
* @notice Returns the status of whether a queued reward allocation is ready to be activated.
* @param valPubkey The validator's pubkey.
* @param blockNumber The block number to be queried.
* @return isReady True if the queued reward allocation is ready to be activated, false otherwise.
*/
function isQueuedRewardAllocationReady(
bytes calldata valPubkey,
uint256 blockNumber
)
external
view
returns (bool);
/**
* @notice Returns the status of whether the BeraChef contract is ready to be used.
* @dev This function should be used by all contracts that depend on a system call.
* @dev This will return false if the governance module has not set a default reward allocation yet.
* @return isReady True if the BeraChef is ready to be used, false otherwise.
*/
function isReady() external view returns (bool);
/**
* @notice Returns the queued commission struct of a validator on an incentive tokens.
* @param valPubkey The validator's pubkey.
* @return queuedCommissionRate The queued commission struct of the validator on the incentive tokens.
*/
function getValQueuedCommissionOnIncentiveTokens(bytes calldata valPubkey)
external
view
returns (QueuedCommissionRateChange memory);
/**
* @notice Returns the commission rate of a validator on an incentive tokens.
* @dev Default commission rate is 5% if the commission was never set.
* @param valPubkey The validator's pubkey.
* @return commissionRate The commission rate of the validator on the incentive tokens.
*/
function getValCommissionOnIncentiveTokens(bytes calldata valPubkey) external view returns (uint96);
/**
* @notice Returns the validator's share of the incentive tokens based on the validator's commission rate.
* @param valPubkey The validator's pubkey.
* @param incentiveTokenAmount The amount of the incentive tokens.
* @return validatorShare The validator's share of the incentive tokens.
*/
function getValidatorIncentiveTokenShare(
bytes calldata valPubkey,
uint256 incentiveTokenAmount
)
external
view
returns (uint256);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ADMIN FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Sets the maximum number of weights per reward allocation.
function setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation) external;
/// @notice Sets the maximum weight a vault can assume in a reward allocation.
function setMaxWeightPerVault(uint96 _maxWeightPerVault) external;
/// @notice Sets the delay in blocks before a new reward allocation can be queued.
function setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay) external;
/**
* @notice Updates the vault's whitelisted status
* @notice The caller of this function must be the governance module account.
* @param receiver The address to remove or add as whitelisted vault.
* @param isWhitelisted The whitelist status; true if the receiver is being whitelisted, false otherwise.
* @param metadata The metadata of the vault.
*/
function setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata) external;
/**
* @notice Updates the metadata of a whitelisted vault, reverts if vault is not whitelisted.
* @notice The caller of this function must be the governance module account.
* @param receiver The address of the whitelisted vault.
* @param metadata The metadata of the vault, to associate info with the vault in the events log.
*/
function updateWhitelistedVaultMetadata(address receiver, string memory metadata) external;
/**
* @notice Sets the default reward allocation for validators that do not have a reward allocation.
* @dev The caller of this function must be the governance module account.
* @param rewardAllocation The default reward allocation.
*/
function setDefaultRewardAllocation(RewardAllocation calldata rewardAllocation) external;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* SETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Add a new reward allocation to the queue for validator with given pubkey. Does not allow overwriting of
* existing queued reward allocation.
* @dev The weights of the reward allocation must add up to 100% or 1e4.
* Only whitelisted pools may be used as well.
* @param valPubkey The validator's pubkey.
* @param startBlock The block that the reward allocation goes into effect.
* @param weights The weights of the reward allocation.
*/
function queueNewRewardAllocation(
bytes calldata valPubkey,
uint64 startBlock,
Weight[] calldata weights
)
external;
/**
* @notice Activates the queued reward allocation for a validator if its ready for the current block.
* @dev Should be called by the distribution contract.
* @param valPubkey The validator's pubkey.
*/
function activateReadyQueuedRewardAllocation(bytes calldata valPubkey) external;
/**
* @notice Sets the commission change delay.
* @dev Only owner can call this function.
* @param _commissionChangeDelay The delay in blocks to activate a queued commission change.
*/
function setCommissionChangeDelay(uint64 _commissionChangeDelay) external;
/**
* @notice Queues a commission rate change for a validator on incentive tokens.
* @dev The caller of this function must be the validator operator address.
* @dev Revert if already a commission rate change is queued.
* @param valPubkey The validator's pubkey.
* @param commissionRate The commission rate of the validator on the incentive tokens.
*/
function queueValCommission(bytes calldata valPubkey, uint96 commissionRate) external;
/**
* @notice Activates the queued commission rate of a validator on incentive tokens.
* @param valPubkey The validator's pubkey.
*/
function activateQueuedValCommission(bytes calldata valPubkey) external;
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IPOLErrors } from "./IPOLErrors.sol";
import { IBeraChef } from "./IBeraChef.sol";
/// @notice Interface of the Distributor contract.
interface IDistributor is IPOLErrors {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event Distributed(bytes indexed valPubkey, uint64 indexed nextTimestamp, address indexed receiver, uint256 amount);
/**
* @notice Distribute the rewards to the reward allocation receivers.
* @dev Permissionless function to distribute rewards by providing the necessary Merkle proofs. Reverts if the
* proofs are invalid.
* @param nextTimestamp The timestamp of the next beacon block to distribute for. The EIP-4788 Beacon Roots
* contract is queried by this key, returning the parent beacon block root from the next timestamp.
* @param proposerIndex The proposer index of the beacon block. This should be the validator index corresponding
* to the pubkey in the validator registry in the beacon state.
* @param pubkey The validator pubkey of the proposer.
* @param proposerIndexProof The Merkle proof of the proposer index in the beacon block.
* @param pubkeyProof The Merkle proof of the validator pubkey of the proposer in the beacon block.
*/
function distributeFor(
uint64 nextTimestamp,
uint64 proposerIndex,
bytes calldata pubkey,
bytes32[] calldata proposerIndexProof,
bytes32[] calldata pubkeyProof
)
external;
/// @notice Returns the address of the BeraChef contract.
function beraChef() external view returns (IBeraChef);
}// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import { IPOLErrors } from "./IPOLErrors.sol";
interface IBGTIncentiveDistributor is IPOLErrors {
/**
* @param identifier Identifier of the distribution
* @param token The address of the token to distribute
* @param pubkey The pubkey of the validator
* @param merkleRoot The merkle root of the distribution
* @param proof The proof of the distribution
*/
struct Distribution {
bytes32 identifier;
bytes pubkey;
address token;
bytes32 merkleRoot;
bytes32 proof;
}
/**
* @param token Address of the token to distribute
* @param merkleRoot Merkle root of the distribution
* @param proof The proof of the distribution
* @param activeAt Timestamp at which the reward claim becomes active
* @param pubkey The pubkey of the validator
*/
struct Reward {
address token;
bytes32 merkleRoot;
bytes32 proof;
uint256 activeAt;
bytes pubkey;
}
/**
* @param identifier Identifier of the distribution
* @param account The address of the account to claim the reward
* @param amount The amount of tokens to claim
* @param merkleProof The merkle proof of the distribution
*/
struct Claim {
bytes32 identifier;
address account;
uint256 amount;
bytes32[] merkleProof;
}
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Event emitted when the reward claim delay is set
* @param delay The delay in seconds
*/
event RewardClaimDelaySet(uint64 delay);
/**
* @notice Event emitted when a reward is claimed
* @param identifier The identifier of the reward
* @param token The address of the reward token
* @param account The address of the account that claimed the reward
* @param pubkey The pubkey of the validator corresponding to `identifier`
* @param amount The amount of tokens claimed
*/
event RewardClaimed(
bytes32 indexed identifier, address indexed token, address indexed account, bytes pubkey, uint256 amount
);
/**
* @notice Event emitted when a reward metadata is updated
* @param identifier The identifier of the reward
* @param token The address of the reward token
* @param merkleRoot The merkle root of the reward
* @param proof The proof of the reward
* @param activeAt The timestamp at which the reward claim becomes active
*/
event RewardMetadataUpdated(
bytes32 indexed identifier,
bytes indexed pubkey,
address indexed token,
bytes32 merkleRoot,
bytes32 proof,
uint256 activeAt
);
/**
* @notice Event emitted when an incentive is received by the contract
* @param pubkey The pubkey of the validator
* @param token The address of the incentive token
* @param amount The amount of tokens received
*/
event IncentiveReceived(bytes indexed pubkey, address indexed token, uint256 amount);
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/* FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Get the amount of incentive tokens held by the contract for a validator
* @param pubkey The pubkey of the validator
* @param token The address of the incentive token
* @return The amount of tokens held by the contract for the validator
*/
function incentiveTokensPerValidator(bytes calldata pubkey, address token) external view returns (uint256);
/**
* @notice Set the reward claim delay
* @dev Only address with DEFAULT_ADMIN_ROLE can call this function
* @param _delay The delay in seconds
*/
function setRewardClaimDelay(uint64 _delay) external;
/**
* @notice Receive incentive tokens from POL reward vaults
* @dev Token approval must be given by the caller to this function before calling it.
* @param pubkey The pubkey of the validator
* @param token The address of the incentive token
* @param _amount The amount of tokens received
*/
function receiveIncentive(bytes calldata pubkey, address token, uint256 _amount) external;
/**
* @notice Claim rewards based on the specified metadata
* @param _claims Claim[] List of claim metadata
*/
function claim(Claim[] calldata _claims) external;
/**
* @notice Set the contract's pause state.
* @dev Only address with PAUSER_ROLE can call this function
* @param state Pause state
*/
function setPauseState(bool state) external;
/**
* @notice Update the rewards metadata
* @dev Only address with MANAGER_ROLE can call this function
* @dev During the updated of a distribution, reverts if the token address is not the same as the one set for the
* given identifier to avoid accidental wrong updates.
* @param _distributions Distribution[] List of reward metadata
*/
function updateRewardsMetadata(Distribution[] calldata _distributions) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Address.sol)
pragma solidity ^0.8.20;
import {Errors} from "./Errors.sol";
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @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 Errors.InsufficientBalance(address(this).balance, amount);
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert Errors.FailedCall();
}
}
/**
* @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
* {Errors.FailedCall} 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 Errors.InsufficientBalance(address(this).balance, value);
}
(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 {Errors.FailedCall}) 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 {Errors.FailedCall} 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 {Errors.FailedCall}.
*/
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
assembly ("memory-safe") {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert Errors.FailedCall();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @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 ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
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) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.
library SafeTransferLib {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The ETH transfer has failed.
error ETHTransferFailed();
/// @dev The ERC20 `transferFrom` has failed.
error TransferFromFailed();
/// @dev The ERC20 `transfer` has failed.
error TransferFailed();
/// @dev The ERC20 `approve` has failed.
error ApproveFailed();
/// @dev The Permit2 operation has failed.
error Permit2Failed();
/// @dev The Permit2 amount must be less than `2**160 - 1`.
error Permit2AmountOverflow();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.
uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;
/// @dev Suggested gas stipend for contract receiving ETH to perform a few
/// storage reads and writes, but low enough to prevent griefing.
uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
/// @dev The unique EIP-712 domain domain separator for the DAI token contract.
bytes32 internal constant DAI_DOMAIN_SEPARATOR =
0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;
/// @dev The address for the WETH9 contract on Ethereum mainnet.
address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
/// @dev The canonical Permit2 address.
/// [Github](https://github.com/Uniswap/permit2)
/// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)
address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ETH OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
// If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.
//
// The regular variants:
// - Forwards all remaining gas to the target.
// - Reverts if the target reverts.
// - Reverts if the current contract has insufficient balance.
//
// The force variants:
// - Forwards with an optional gas stipend
// (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).
// - If the target reverts, or if the gas stipend is exhausted,
// creates a temporary contract to force send the ETH via `SELFDESTRUCT`.
// Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.
// - Reverts if the current contract has insufficient balance.
//
// The try variants:
// - Forwards with a mandatory gas stipend.
// - Instead of reverting, returns whether the transfer succeeded.
/// @dev Sends `amount` (in wei) ETH to `to`.
function safeTransferETH(address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
}
}
/// @dev Sends all the ETH in the current contract to `to`.
function safeTransferAllETH(address to) internal {
/// @solidity memory-safe-assembly
assembly {
// Transfer all the ETH and check if it succeeded or not.
if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
}
}
/// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
/// @solidity memory-safe-assembly
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.
function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
/// @solidity memory-safe-assembly
assembly {
if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.
function forceSafeTransferETH(address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.
function forceSafeTransferAllETH(address to) internal {
/// @solidity memory-safe-assembly
assembly {
// forgefmt: disable-next-item
if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
internal
returns (bool success)
{
/// @solidity memory-safe-assembly
assembly {
success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
}
}
/// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.
function trySafeTransferAllETH(address to, uint256 gasStipend)
internal
returns (bool success)
{
/// @solidity memory-safe-assembly
assembly {
success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ERC20 OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
/// Reverts upon failure.
///
/// The `from` account must have at least `amount` approved for
/// the current contract to manage.
function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40) // Cache the free memory pointer.
mstore(0x60, amount) // Store the `amount` argument.
mstore(0x40, to) // Store the `to` argument.
mstore(0x2c, shl(96, from)) // Store the `from` argument.
mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
revert(0x1c, 0x04)
}
}
mstore(0x60, 0) // Restore the zero slot to zero.
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
///
/// The `from` account must have at least `amount` approved for the current contract to manage.
function trySafeTransferFrom(address token, address from, address to, uint256 amount)
internal
returns (bool success)
{
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40) // Cache the free memory pointer.
mstore(0x60, amount) // Store the `amount` argument.
mstore(0x40, to) // Store the `to` argument.
mstore(0x2c, shl(96, from)) // Store the `from` argument.
mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
success := lt(or(iszero(extcodesize(token)), returndatasize()), success)
}
mstore(0x60, 0) // Restore the zero slot to zero.
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends all of ERC20 `token` from `from` to `to`.
/// Reverts upon failure.
///
/// The `from` account must have their entire balance approved for the current contract to manage.
function safeTransferAllFrom(address token, address from, address to)
internal
returns (uint256 amount)
{
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40) // Cache the free memory pointer.
mstore(0x40, to) // Store the `to` argument.
mstore(0x2c, shl(96, from)) // Store the `from` argument.
mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
// Read the balance, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
revert(0x1c, 0x04)
}
mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.
amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.
// Perform the transfer, reverting upon failure.
let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
revert(0x1c, 0x04)
}
}
mstore(0x60, 0) // Restore the zero slot to zero.
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
/// Reverts upon failure.
function safeTransfer(address token, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
// Perform the transfer, reverting upon failure.
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
revert(0x1c, 0x04)
}
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sends all of ERC20 `token` from the current contract to `to`.
/// Reverts upon failure.
function safeTransferAll(address token, address to) internal returns (uint256 amount) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
mstore(0x20, address()) // Store the address of the current contract.
// Read the balance, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
revert(0x1c, 0x04)
}
mstore(0x14, to) // Store the `to` argument.
amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.
mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
// Perform the transfer, reverting upon failure.
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
revert(0x1c, 0x04)
}
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
/// Reverts upon failure.
function safeApprove(address token, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
revert(0x1c, 0x04)
}
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
/// If the initial attempt to approve fails, attempts to reset the approved amount to zero,
/// then retries the approval again (some tokens, e.g. USDT, requires this).
/// Reverts upon failure.
function safeApproveWithRetry(address token, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
// Perform the approval, retrying upon failure.
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x34, 0) // Store 0 for the `amount`.
mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.
mstore(0x34, amount) // Store back the original `amount`.
// Retry the approval, reverting upon failure.
success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
// Check the `extcodesize` again just in case the token selfdestructs lol.
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
revert(0x1c, 0x04)
}
}
}
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Returns the amount of ERC20 `token` owned by `account`.
/// Returns zero if the `token` does not exist.
function balanceOf(address token, address account) internal view returns (uint256 amount) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, account) // Store the `account` argument.
mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
amount :=
mul( // The arguments of `mul` are evaluated from right to left.
mload(0x20),
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
)
)
}
}
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
/// If the initial attempt fails, try to use Permit2 to transfer the token.
/// Reverts upon failure.
///
/// The `from` account must have at least `amount` approved for the current contract to manage.
function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {
if (!trySafeTransferFrom(token, from, to, amount)) {
permit2TransferFrom(token, from, to, amount);
}
}
/// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.
/// Reverts upon failure.
function permit2TransferFrom(address token, address from, address to, uint256 amount)
internal
{
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40)
mstore(add(m, 0x74), shr(96, shl(96, token)))
mstore(add(m, 0x54), amount)
mstore(add(m, 0x34), to)
mstore(add(m, 0x20), shl(96, from))
// `transferFrom(address,address,uint160,address)`.
mstore(m, 0x36c78516000000000000000000000000)
let p := PERMIT2
let exists := eq(chainid(), 1)
if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }
if iszero(
and(
call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),
lt(iszero(extcodesize(token)), exists) // Token has code and Permit2 exists.
)
) {
mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.
revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)
}
}
}
/// @dev Permit a user to spend a given amount of
/// another user's tokens via native EIP-2612 permit if possible, falling
/// back to Permit2 if native permit fails or is not implemented on the token.
function permit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
bool success;
/// @solidity memory-safe-assembly
assembly {
for {} shl(96, xor(token, WETH9)) {} {
mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.
// Gas stipend to limit gas burn for tokens that don't refund gas when
// an non-existing function is called. 5K should be enough for a SLOAD.
staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)
)
) { break }
// After here, we can be sure that token is a contract.
let m := mload(0x40)
mstore(add(m, 0x34), spender)
mstore(add(m, 0x20), shl(96, owner))
mstore(add(m, 0x74), deadline)
if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {
mstore(0x14, owner)
mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.
mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))
mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.
// `nonces` is already at `add(m, 0x54)`.
// `1` is already stored at `add(m, 0x94)`.
mstore(add(m, 0xb4), and(0xff, v))
mstore(add(m, 0xd4), r)
mstore(add(m, 0xf4), s)
success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)
break
}
mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.
mstore(add(m, 0x54), amount)
mstore(add(m, 0x94), and(0xff, v))
mstore(add(m, 0xb4), r)
mstore(add(m, 0xd4), s)
success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)
break
}
}
if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);
}
/// @dev Simple permit on the Permit2 contract.
function simplePermit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40)
mstore(m, 0x927da105) // `allowance(address,address,address)`.
{
let addressMask := shr(96, not(0))
mstore(add(m, 0x20), and(addressMask, owner))
mstore(add(m, 0x40), and(addressMask, token))
mstore(add(m, 0x60), and(addressMask, spender))
mstore(add(m, 0xc0), and(addressMask, spender))
}
let p := mul(PERMIT2, iszero(shr(160, amount)))
if iszero(
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.
staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)
)
) {
mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.
revert(add(0x18, shl(2, iszero(p))), 0x04)
}
mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).
// `owner` is already `add(m, 0x20)`.
// `token` is already at `add(m, 0x40)`.
mstore(add(m, 0x60), amount)
mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.
// `nonce` is already at `add(m, 0xa0)`.
// `spender` is already at `add(m, 0xc0)`.
mstore(add(m, 0xe0), deadline)
mstore(add(m, 0x100), 0x100) // `signature` offset.
mstore(add(m, 0x120), 0x41) // `signature` length.
mstore(add(m, 0x140), r)
mstore(add(m, 0x160), s)
mstore(add(m, 0x180), shl(248, v))
if iszero( // Revert if token does not have code, or if the call fails.
mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))) {
mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.
revert(0x1c, 0x04)
}
}
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IStakingRewardsErrors } from "../../base/IStakingRewardsErrors.sol";
/// @notice Interface of POL errors
interface IPOLErrors is IStakingRewardsErrors {
// Signature: 0xf2d81d95
error NotApprovedSender();
// Signature: 0x1db3b859
error NotDelegate();
// Signature: 0x53f0a596
error NotBGT();
// Signature: 0x1b0eb4ec
error NotBlockRewardController();
// Signature: 0x385296d5
error NotDistributor();
// Signature: 0x73fcd3fe
error NotFeeCollector();
// Signature: 0x36407850
error NotWhitelistedVault();
// Signature:0x7c214f04
error NotOperator();
// Signature: 0xad3a8b9e
error NotEnoughBalance();
// Signature: 0xadd377f6
error InvalidActivateBoostDelay();
// Signature: 0x2f14f4f9
error InvalidDropBoostDelay();
// Signature: 0x14969061
error NotEnoughBoostedBalance();
// Signature: 0xe8966d7a
error NotEnoughTime();
// Signature: 0xec2caa0d
error InvalidStartBlock();
// Signature: 0x3be31f8c
error RewardAllocationAlreadyQueued();
// Signature: 0x13134d24
error InvalidRewardAllocationWeights();
// Signature: 0xf6fae721
error TooManyWeights();
// Signature: 0x3e38573f
error InvalidateDefaultRewardAllocation();
// Signature: 0xd92e233d
error ZeroAddress();
// Signature: 0x462a2bb2
error RewardAllocationBlockDelayTooLarge();
// Signature: 0x08519afa
error NotFactoryVault();
// Signature: 0x978dc040
error ZeroPercentageWeight();
// Signature: 0x585b9263
error InvalidWeight();
// Signature: 0xcb1ee123
error InvalidMaxWeightPerVault();
// Signature: 0xab396d11
error InvalidCommissionValue();
// Signature: 0x0c32c4fa
error CommissionChangeAlreadyQueued();
// Signature: 0xe9269446
error CommissionNotQueuedOrDelayNotPassed();
// Signature: 0xc1abde53
error InvalidCommissionChangeDelay();
/* BLOCK REWARD CONTROLLLER */
// Signature: 0x2e2dab43
error InvalidBaseRate();
// Signature: 0x22be2284
error InvalidRewardRate();
// Signature: 0x15482337
error InvalidMinBoostedRewardRate();
// Signature: 0xb7b2319a
error InvalidBoostMultiplier();
// Signature: 0x347f95b2
error InvalidRewardConvexity();
/* STAKING */
// Signature: 0x09ee12d5
error NotAContract();
// Signature: 0xe4ea100b
error CannotRecoverRewardToken();
// Signature: 0x1b813803
error CannotRecoverStakingToken();
// Signature: 0x2899103f
error CannotRecoverIncentiveToken();
// Signature: 0x38432c89
error IncentiveRateTooHigh();
// Signature: 0x5ee4de0e
error NotIncentiveManager();
// Signature: 0xf84835a0
error TokenNotWhitelisted();
// Signature: 0x8d1473a6
error InsufficientDelegateStake();
// Signature: 0x08e88f46
error InsufficientSelfStake();
// Signature: 0xfbf97e07
error TokenAlreadyWhitelistedOrLimitReached();
// Signature: 0xad57d95d
error AmountLessThanMinIncentiveRate();
// Signature: 0xfbf1123c
error InvalidMaxIncentiveTokensCount();
// Signature: 0x546c7600
error PayoutAmountIsZero();
// Signature: 0x89c622a2
error DonateAmountLessThanPayoutAmount();
// Signature: 0xa4cc22ed
error MaxNumWeightsPerRewardAllocationIsZero();
// Signature: 0x0b5c3aff
error MinIncentiveRateIsZero();
// Signature: 0x8e7572da
error InvariantCheckFailed();
// Signature: 0x451fa036
error InvalidIncentiveRate();
/* BEACON ROOTS */
// Signature: 0x1390f2a1
error IndexOutOfRange();
// Signature: 0x09bde339
error InvalidProof();
// Signature: 0x0a431b2a
error TimestampAlreadyProcessed();
/* BEACON DEPOSIT */
/// @dev Error thrown when the deposit amount is too small, to prevent dust deposits.
// Signature: 0x0e1eddda
error InsufficientDeposit();
/// @dev Error thrown when the deposit amount is not a multiple of Gwei.
// Signature: 0x40567b38
error DepositNotMultipleOfGwei();
/// @dev Error thrown when the deposit amount is too high, since it is a uint64.
// Signature: 0x2aa66734
error DepositValueTooHigh();
/// @dev Error thrown when the public key length is not 48 bytes.
// Signature: 0x9f106472
error InvalidPubKeyLength();
/// @dev Error thrown when the withdrawal credentials length is not 32 bytes.
// Signature: 0xb39bca16
error InvalidCredentialsLength();
/// @dev Error thrown when the signature length is not 96 bytes.
// Signature: 0x4be6321b
error InvalidSignatureLength();
/// @dev Error thrown when the input operator is zero address on the first deposit.
// Signature: 0x51969a7a
error ZeroOperatorOnFirstDeposit();
/// @dev Error thrown when the operator is already set and caller passed non-zero operator.
// Signature: 0xc4142b41
error OperatorAlreadySet();
/// @dev Error thrown when the caller is not the current operator.
// Signature: 0x819a0d0b
error NotNewOperator();
/* BGT INCENTIVE DISTRIBUTOR */
// Signature: 0x1ec5aa51
error InvalidArray();
// Signature: 0x68b5c198
error InvalidDistribution();
// Signature: 0x9dd854d3
error InvalidMerkleRoot();
// Signature: 0x0995309b
error RewardInactive();
// Signature: 0x5958c647
error InvalidRewardClaimDelay();
// Signature: 0x75f9d00c
error InsufficientIncentiveTokens();
// Signature: 0xc1ab6dc1
error InvalidToken();
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IStakingRewardsErrors } from "./IStakingRewardsErrors.sol";
/// @notice Interface of staking rewards
interface IStakingRewards is IStakingRewardsErrors {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Emitted when a reward has been added to the vault.
/// @param reward The amount of reward added, scaled by PRECISION.
event RewardAdded(uint256 reward);
/// @notice Emitted when the staking balance of an account has increased.
/// @param account The account that has staked.
/// @param amount The amount of staked tokens.
event Staked(address indexed account, uint256 amount);
/// @notice Emitted when the staking balance of an account has decreased.
/// @param account The account that has withdrawn.
/// @param amount The amount of withdrawn tokens.
event Withdrawn(address indexed account, uint256 amount);
/// @notice Emitted when a reward has been claimed.
/// @param account The account whose reward has been claimed.
/// @param to The address that the reward was sent to. (user or operator).
/// @param reward The amount of reward claimed.
event RewardPaid(address indexed account, address to, uint256 reward);
/// @notice Emitted when the reward duration has been updated.
/// @param newDuration The new duration of the reward.
event RewardsDurationUpdated(uint256 newDuration);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* GETTERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Get the balance of the staked tokens for an account.
/// @param account The account to get the balance for.
/// @return The balance of the staked tokens.
function balanceOf(address account) external view returns (uint256);
/// @notice Get the reward balance for a specific account.
/// @param account The account to retrieve the reward balance for.
/// @return The current reward balance of the specified account.
function rewards(address account) external view returns (uint256);
/// @notice Get the user reward per token paid.
/// @param account The account to retrieve the reward for.
/// @return The current reward balance of the specified account.
function userRewardPerTokenPaid(address account) external view returns (uint256);
/// @notice Retrieves the amount of reward earned by a specific account.
/// @param account The account to calculate the reward for.
/// @return The amount of reward earned by the account.
function earned(address account) external view returns (uint256);
/// @notice Retrieves the total reward vested over the specified duration.
/// @return The total reward vested over the duration.
function getRewardForDuration() external view returns (uint256);
/// @notice Returns the timestamp of the last reward distribution. This is either the current timestamp (if rewards
/// are still being actively distributed) or the timestamp when the reward duration ended (if all rewards have
/// already been distributed).
/// @return The timestamp of the last reward distribution.
function lastTimeRewardApplicable() external view returns (uint256);
/// @notice Retrieves the current value of the global reward per token accumulator. This value is the sum of the
/// last checkpoint value and the accumulated value since the last checkpoint. It should increase monotonically
/// over time as more rewards are distributed.
/// @return The current value of the global reward per token accumulator scaled by 1e18.
function rewardPerToken() external view returns (uint256);
/// @notice Get the total supply of the staked tokens in the vault.
/// @return The total supply of the staked tokens in the vault.
function totalSupply() external view returns (uint256);
/// @notice Get the end of the current reward period.
/// @return The end of the current reward period.
function periodFinish() external view returns (uint256);
/// @notice Get the reward rate for the current reward period.
/// @return The reward rate.
function rewardRate() external view returns (uint256);
/// @notice Get the time over which the rewards will be distributed.
/// @return The duration of the rewards cycle.
function rewardsDuration() external view returns (uint256);
/// @notice Get the last time the rewards were updated.
/// @return The last time the rewards were updated.
function lastUpdateTime() external view returns (uint256);
/// @notice Get the amount of undistributed rewards.
/// @return The amount of undistributed rewards.
function undistributedRewards() external view returns (uint256);
/// @notice Get the last updated reward per token scaled.
/// @return The last updated reward per token.
function rewardPerTokenStored() external view returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)
pragma solidity ^0.8.20;
import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {ERC165Upgradeable} from "../utils/introspection/ERC165Upgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```solidity
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```solidity
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
* to enforce additional security measures for this role.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {
struct RoleData {
mapping(address account => bool) hasRole;
bytes32 adminRole;
}
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/// @custom:storage-location erc7201:openzeppelin.storage.AccessControl
struct AccessControlStorage {
mapping(bytes32 role => RoleData) _roles;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.AccessControl")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;
function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {
assembly {
$.slot := AccessControlStorageLocation
}
}
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with an {AccessControlUnauthorizedAccount} error including the required role.
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].hasRole[account];
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
* is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
* is missing `role`.
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert AccessControlUnauthorizedAccount(account, role);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address callerConfirmation) public virtual {
if (callerConfirmation != _msgSender()) {
revert AccessControlBadConfirmation();
}
_revokeRole(role, callerConfirmation);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
AccessControlStorage storage $ = _getAccessControlStorage();
bytes32 previousAdminRole = getRoleAdmin(role);
$._roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (!hasRole(role, account)) {
$._roles[role].hasRole[account] = true;
emit RoleGranted(role, account, _msgSender());
return true;
} else {
return false;
}
}
/**
* @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (hasRole(role, account)) {
$._roles[role].hasRole[account] = false;
emit RoleRevoked(role, account, _msgSender());
return true;
} else {
return false;
}
}
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
import { IPOLErrors } from "../interfaces/IPOLErrors.sol";
interface IRewardVaultFactory is IPOLErrors {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Emitted when a new vault is created.
* @param stakingToken The address of the staking token.
* @param vault The address of the vault.
*/
event VaultCreated(address indexed stakingToken, address indexed vault);
/**
* @notice Emitted when the BGTIncentiveDistributor contract is set.
* @param newBGTIncentiveDistributor The address of the new BGTIncentiveDistributor contract.
* @param oldBGTIncentiveDistributor The address of the old BGTIncentiveDistributor contract.
*/
event BGTIncentiveDistributorSet(
address indexed newBGTIncentiveDistributor, address indexed oldBGTIncentiveDistributor
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ADMIN */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Sets the BGTIncentiveDistributor contract.
* @dev Only callable by the admin.
* @param _bgtIncentiveDistributor The address of the new BGTIncentiveDistributor contract.
*/
function setBGTIncentiveDistributor(address _bgtIncentiveDistributor) external;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VAULT CREATION */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Creates a new reward vault vault for the given staking token.
* @dev Reverts if the staking token is not a contract.
* @param stakingToken The address of the staking token.
* @return The address of the new vault.
*/
function createRewardVault(address stakingToken) external returns (address);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* READS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/**
* @notice Gets the VAULT_MANAGER_ROLE.
* @return The VAULT_MANAGER_ROLE.
*/
function VAULT_MANAGER_ROLE() external view returns (bytes32);
/**
* @notice Gets the VAULT_PAUSER_ROLE.
* @return The VAULT_PAUSER_ROLE.
*/
function VAULT_PAUSER_ROLE() external view returns (bytes32);
/**
* @notice Gets the vault for the given staking token.
* @param stakingToken The address of the staking token.
* @return The address of the vault.
*/
function getVault(address stakingToken) external view returns (address);
/**
* @notice Gets the number of vaults that have been created.
* @return The number of vaults.
*/
function allVaultsLength() external view returns (uint256);
/**
* @notice Gets the address of the BGTIncentiveDistributor contract.
* @return The address of the BGTIncentiveDistributor contract.
*/
function bgtIncentiveDistributor() external view returns (address);
/**
* @notice Predicts the address of the reward vault for the given staking token.
* @param stakingToken The address of the staking token.
* @return The address of the reward vault.
*/
function predictRewardVaultAddress(address stakingToken) external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../utils/introspection/IERC165.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of common custom errors used in multiple contracts
*
* IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
* It is recommended to avoid relying on the error API for critical functionality.
*
* _Available since v5.1._
*/
library Errors {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error InsufficientBalance(uint256 balance, uint256 needed);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedCall();
/**
* @dev The deployment failed.
*/
error FailedDeployment();
/**
* @dev A necessary precompile is missing.
*/
error MissingPrecompile(address);
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.26;
/// @notice Interface of staking rewards errors
interface IStakingRewardsErrors {
// Signature: 0xf4ba521f
error InsolventReward();
// Signature: 0xf1bc94d2
error InsufficientStake();
// Signature: 0x49835af0
error RewardCycleNotEnded();
// Signature: 0x5ce91fd0
error StakeAmountIsZero();
// Signature: 0xe5cfe957
error TotalSupplyOverflow();
// Signature: 0xa393d14b
error WithdrawAmountIsZero();
// Signature: 0x359f174d
error RewardsDurationIsZero();
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (access/IAccessControl.sol)
pragma solidity ^0.8.20;
/**
* @dev External interface of AccessControl declared to support ERC-165 detection.
*/
interface IAccessControl {
/**
* @dev The `account` is missing a role.
*/
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
/**
* @dev The caller of a function is not the expected one.
*
* NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
*/
error AccessControlBadConfirmation();
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
* Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*/
function renounceRole(bytes32 role, address callerConfirmation) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*/
abstract contract ERC165Upgradeable is Initializable, IERC165 {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}{
"remappings": [
"@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
"@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/",
"@openzeppelin-gov/=node_modules/@openzeppelin/contracts-upgradeable/governance/",
"@openzeppelin-gov-ext/=node_modules/@openzeppelin/contracts-upgradeable/governance/extensions/",
"@prb/math/=node_modules/@prb/math/",
"@pythnetwork/=node_modules/@pythnetwork/pyth-sdk-solidity/",
"forge-std/=lib/forge-std/src/",
"solady/src/=lib/solady/src/",
"solady/test/=lib/solady/test/",
"transient-goodies/=lib/transient-goodies/src/",
"@mock/=test/mock/",
"ds-test/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/lib/ds-test/src/",
"openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
"solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/"
],
"optimizer": {
"enabled": true,
"runs": 666
},
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "none",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"evmVersion": "cancun",
"viaIR": true,
"libraries": {}
}Contract ABI
API[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AmountLessThanMinIncentiveRate","type":"error"},{"inputs":[],"name":"CannotRecoverIncentiveToken","type":"error"},{"inputs":[],"name":"CannotRecoverRewardToken","type":"error"},{"inputs":[],"name":"CannotRecoverStakingToken","type":"error"},{"inputs":[],"name":"CommissionChangeAlreadyQueued","type":"error"},{"inputs":[],"name":"CommissionNotQueuedOrDelayNotPassed","type":"error"},{"inputs":[],"name":"DepositNotMultipleOfGwei","type":"error"},{"inputs":[],"name":"DepositValueTooHigh","type":"error"},{"inputs":[],"name":"DonateAmountLessThanPayoutAmount","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"IncentiveRateTooHigh","type":"error"},{"inputs":[],"name":"IndexOutOfRange","type":"error"},{"inputs":[],"name":"InsolventReward","type":"error"},{"inputs":[],"name":"InsufficientDelegateStake","type":"error"},{"inputs":[],"name":"InsufficientDeposit","type":"error"},{"inputs":[],"name":"InsufficientIncentiveTokens","type":"error"},{"inputs":[],"name":"InsufficientSelfStake","type":"error"},{"inputs":[],"name":"InsufficientStake","type":"error"},{"inputs":[],"name":"InvalidActivateBoostDelay","type":"error"},{"inputs":[],"name":"InvalidArray","type":"error"},{"inputs":[],"name":"InvalidBaseRate","type":"error"},{"inputs":[],"name":"InvalidBoostMultiplier","type":"error"},{"inputs":[],"name":"InvalidCommissionChangeDelay","type":"error"},{"inputs":[],"name":"InvalidCommissionValue","type":"error"},{"inputs":[],"name":"InvalidCredentialsLength","type":"error"},{"inputs":[],"name":"InvalidDistribution","type":"error"},{"inputs":[],"name":"InvalidDropBoostDelay","type":"error"},{"inputs":[],"name":"InvalidIncentiveRate","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidMaxIncentiveTokensCount","type":"error"},{"inputs":[],"name":"InvalidMaxWeightPerVault","type":"error"},{"inputs":[],"name":"InvalidMerkleRoot","type":"error"},{"inputs":[],"name":"InvalidMinBoostedRewardRate","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"InvalidPubKeyLength","type":"error"},{"inputs":[],"name":"InvalidRewardAllocationWeights","type":"error"},{"inputs":[],"name":"InvalidRewardClaimDelay","type":"error"},{"inputs":[],"name":"InvalidRewardConvexity","type":"error"},{"inputs":[],"name":"InvalidRewardRate","type":"error"},{"inputs":[],"name":"InvalidSignatureLength","type":"error"},{"inputs":[],"name":"InvalidStartBlock","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[],"name":"InvalidWeight","type":"error"},{"inputs":[],"name":"InvalidateDefaultRewardAllocation","type":"error"},{"inputs":[],"name":"InvariantCheckFailed","type":"error"},{"inputs":[],"name":"MaxNumWeightsPerRewardAllocationIsZero","type":"error"},{"inputs":[],"name":"MinIncentiveRateIsZero","type":"error"},{"inputs":[],"name":"NotAContract","type":"error"},{"inputs":[],"name":"NotApprovedSender","type":"error"},{"inputs":[],"name":"NotBGT","type":"error"},{"inputs":[],"name":"NotBlockRewardController","type":"error"},{"inputs":[],"name":"NotDelegate","type":"error"},{"inputs":[],"name":"NotDistributor","type":"error"},{"inputs":[],"name":"NotEnoughBalance","type":"error"},{"inputs":[],"name":"NotEnoughBoostedBalance","type":"error"},{"inputs":[],"name":"NotEnoughTime","type":"error"},{"inputs":[],"name":"NotFactoryVault","type":"error"},{"inputs":[],"name":"NotFeeCollector","type":"error"},{"inputs":[],"name":"NotIncentiveManager","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"NotNewOperator","type":"error"},{"inputs":[],"name":"NotOperator","type":"error"},{"inputs":[],"name":"NotWhitelistedVault","type":"error"},{"inputs":[],"name":"OperatorAlreadySet","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"PayoutAmountIsZero","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"RewardAllocationAlreadyQueued","type":"error"},{"inputs":[],"name":"RewardAllocationBlockDelayTooLarge","type":"error"},{"inputs":[],"name":"RewardCycleNotEnded","type":"error"},{"inputs":[],"name":"RewardInactive","type":"error"},{"inputs":[],"name":"RewardsDurationIsZero","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"StakeAmountIsZero","type":"error"},{"inputs":[],"name":"TimestampAlreadyProcessed","type":"error"},{"inputs":[],"name":"TokenAlreadyWhitelistedOrLimitReached","type":"error"},{"inputs":[],"name":"TokenNotWhitelisted","type":"error"},{"inputs":[],"name":"TooManyWeights","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"WithdrawAmountIsZero","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroOperatorOnFirstDeposit","type":"error"},{"inputs":[],"name":"ZeroPercentageWeight","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"bgtEmitted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BGTBoosterIncentivesProcessFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"bgtEmitted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BGTBoosterIncentivesProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DelegateStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DelegateWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"distributor","type":"address"}],"name":"DistributorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"incentiveRate","type":"uint256"}],"name":"IncentiveAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"newManager","type":"address"},{"indexed":false,"internalType":"address","name":"oldManager","type":"address"}],"name":"IncentiveManagerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"IncentiveTokenRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"minIncentiveRate","type":"uint256"},{"indexed":false,"internalType":"address","name":"manager","type":"address"}],"name":"IncentiveTokenWhitelisted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"bgtEmitted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IncentivesProcessFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"bgtEmitted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IncentivesProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"maxIncentiveTokensCount","type":"uint8"}],"name":"MaxIncentiveTokensCountUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"OperatorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"RewardsDurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"accountIncentives","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"incentiveRate","type":"uint256"}],"name":"addIncentive","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":"beaconDepositContract","outputs":[{"internalType":"contract IBeaconDeposit","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"delegateStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"delegateWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"delegate","type":"address"}],"name":"getDelegateStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"recipient","type":"address"}],"name":"getReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getTotalDelegateStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWhitelistedTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWhitelistedTokensCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"incentives","outputs":[{"internalType":"uint256","name":"minIncentiveRate","type":"uint256"},{"internalType":"uint256","name":"incentiveRate","type":"uint256"},{"internalType":"uint256","name":"amountRemaining","type":"uint256"},{"internalType":"address","name":"manager","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beaconDepositContract","type":"address"},{"internalType":"address","name":"_bgt","type":"address"},{"internalType":"address","name":"_distributor","type":"address"},{"internalType":"address","name":"_stakingToken","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"isFactoryOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"isFactoryVaultManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"isFactoryVaultPauser","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxIncentiveTokensCount","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"pubkey","type":"bytes"},{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"removeIncentiveToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardDistribution","type":"address"}],"name":"setDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_maxIncentiveTokensCount","type":"uint8"}],"name":"setMaxIncentiveTokensCount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardsDuration","type":"uint256"}],"name":"setRewardsDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakeToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"undistributedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"newManager","type":"address"}],"name":"updateIncentiveManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"minIncentiveRate","type":"uint256"},{"internalType":"address","name":"manager","type":"address"}],"name":"whitelistIncentiveToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"whitelistedTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]Loading...
Loading
Loading...
Loading
Multichain Portfolio | 34 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.