Source Code
Overview
ETH Balance
0 ETH
ETH Value
$0.00View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Cross-Chain Transactions
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
DistributionCreator
Compiler Version
v0.8.25+commit.b61c2a91
Optimization Enabled:
Yes with 100 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.17;
import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { SignatureChecker } from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import { UUPSHelper } from "./utils/UUPSHelper.sol";
import { IAccessControlManager } from "./interfaces/IAccessControlManager.sol";
import { Errors } from "./utils/Errors.sol";
import { CampaignParameters } from "./struct/CampaignParameters.sol";
import { DistributionParameters } from "./struct/DistributionParameters.sol";
import { RewardTokenAmounts } from "./struct/RewardTokenAmounts.sol";
import { Distributor } from "./Distributor.sol";
/// @title DistributionCreator
/// @author Angle Labs, Inc.
/// @notice Manages the distribution of rewards through the Merkl system
/// @dev This contract is mostly a helper for APIs built on top of Merkl
/// @dev This contract distinguishes two types of different rewards:
/// - distributions: type of campaign for concentrated liquidity pools created before Feb 15 2024,
/// now deprecated
/// - campaigns: the more global name to describe any reward program on top of Merkl
//solhint-disable
contract DistributionCreator is UUPSHelper, ReentrancyGuardUpgradeable {
using SafeERC20 for IERC20;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CONSTANTS / VARIABLES
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
uint32 public constant HOUR = 3600;
/// @notice Base for fee computation
uint256 public constant BASE_9 = 1e9;
uint256 public immutable CHAIN_ID = block.chainid;
/// @notice `AccessControlManager` contract handling access control
IAccessControlManager public accessControlManager;
/// @notice Contract distributing rewards to users
address public distributor;
/// @notice Address to which fees are forwarded
address public feeRecipient;
/// @notice Value (in base 10**9) of the fees taken when creating a campaign
uint256 public defaultFees;
/// @notice Message that needs to be acknowledged by users creating a campaign
string public message;
/// @notice Hash of the message that needs to be signed
bytes32 public messageHash;
/// @notice List of all rewards distributed in the contract on campaigns created before mid Feb 2024
/// for concentrated liquidity pools
DistributionParameters[] public distributionList;
/// @notice Maps an address to its fee rebate
mapping(address => uint256) public feeRebate;
/// @notice Maps a token to whether it is whitelisted or not. No fees are to be paid for incentives given
/// on pools with whitelisted tokens
mapping(address => uint256) public isWhitelistedToken;
/// @notice Deprecated, kept for storage compatibility
mapping(address => uint256) public _nonces;
/// @notice Maps an address to the last valid hash signed
mapping(address => bytes32) public userSignatures;
/// @notice Maps a user to whether it is whitelisted for not signing
mapping(address => uint256) public userSignatureWhitelist;
/// @notice Maps a token to the minimum amount that must be sent per epoch for a distribution to be valid
/// @dev If `rewardTokenMinAmounts[token] == 0`, then `token` cannot be used as a reward
mapping(address => uint256) public rewardTokenMinAmounts;
/// @notice List of all reward tokens that have at some point been accepted
address[] public rewardTokens;
/// @notice List of all rewards ever distributed or to be distributed in the contract
/// @dev An attacker could try to populate this list. It shouldn't be an issue as only view functions
/// iterate on it
CampaignParameters[] public campaignList;
/// @notice Maps a campaignId to the ID of the campaign in the campaign list + 1
mapping(bytes32 => uint256) internal _campaignLookup;
/// @notice Maps a campaign type to the fees for this specific campaign
mapping(uint32 => uint256) public campaignSpecificFees;
/// @notice Maps a campaignId to a potential override written
mapping(bytes32 => CampaignParameters) public campaignOverrides;
/// @notice Maps a campaignId to the block numbers at which it's been updated
mapping(bytes32 => uint256[]) public campaignOverridesTimestamp;
/// @notice Maps one address to another one to reallocate rewards for a given campaign
mapping(bytes32 => mapping(address => address)) public campaignReallocation;
/// @notice List all reallocated address for a given campaign
mapping(bytes32 => address[]) public campaignListReallocation;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
event DistributorUpdated(address indexed _distributor);
event FeeRebateUpdated(address indexed user, uint256 userFeeRebate);
event FeeRecipientUpdated(address indexed _feeRecipient);
event FeesSet(uint256 _fees);
event CampaignOverride(bytes32 _campaignId, CampaignParameters campaign);
event CampaignReallocation(bytes32 _campaignId, address[] indexed from, address indexed to);
event CampaignSpecificFeesSet(uint32 campaignType, uint256 _fees);
event MessageUpdated(bytes32 _messageHash);
event NewCampaign(CampaignParameters campaign);
event NewDistribution(DistributionParameters distribution, address indexed sender);
event RewardTokenMinimumAmountUpdated(address indexed token, uint256 amount);
event TokenWhitelistToggled(address indexed token, uint256 toggleStatus);
event UserSigned(bytes32 messageHash, address indexed user);
event UserSigningWhitelistToggled(address indexed user, uint256 toggleStatus);
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MODIFIERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Checks whether the `msg.sender` has the governor role or the guardian role
modifier onlyGovernorOrGuardian() {
if (!accessControlManager.isGovernorOrGuardian(msg.sender)) revert Errors.NotGovernorOrGuardian();
_;
}
/// @notice Checks whether the `msg.sender` has the governor role or the guardian role
modifier onlyGovernor() {
if (!accessControlManager.isGovernor(msg.sender)) revert Errors.NotGovernor();
_;
}
/// @notice Checks whether an address has signed the message or not
modifier hasSigned() {
if (
userSignatureWhitelist[msg.sender] == 0 &&
userSignatures[msg.sender] != messageHash &&
userSignatureWhitelist[tx.origin] == 0 &&
userSignatures[tx.origin] != messageHash
) revert Errors.NotSigned();
_;
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
function initialize(
IAccessControlManager _accessControlManager,
address _distributor,
uint256 _fees
) external initializer {
if (address(_accessControlManager) == address(0) || _distributor == address(0)) revert Errors.ZeroAddress();
if (_fees >= BASE_9) revert Errors.InvalidParam();
distributor = _distributor;
accessControlManager = _accessControlManager;
defaultFees = _fees;
}
constructor() initializer {}
/// @inheritdoc UUPSHelper
function _authorizeUpgrade(address) internal view override onlyGovernorUpgrader(accessControlManager) {}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
USER FACING FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Creates a `campaign` to incentivize a given pool for a specific period of time
/// @return The campaignId of the new campaign
/// @dev If the campaign is badly specified, it will not be handled by the campaign script and rewards may be lost
/// @dev Reward tokens sent as part of campaigns must have been whitelisted before and amounts
/// sent should be bigger than a minimum amount specific to each token
/// @dev This function reverts if the sender has not accepted the terms and conditions
function createCampaign(CampaignParameters memory newCampaign) external nonReentrant hasSigned returns (bytes32) {
return _createCampaign(newCampaign);
}
/// @notice Same as the function above but for multiple campaigns at once
/// @return List of all the campaign amounts actually deposited for each `campaign` in the `campaigns` list
function createCampaigns(
CampaignParameters[] memory campaigns
) external nonReentrant hasSigned returns (bytes32[] memory) {
uint256 campaignsLength = campaigns.length;
bytes32[] memory campaignIds = new bytes32[](campaignsLength);
for (uint256 i; i < campaignsLength; ) {
campaignIds[i] = _createCampaign(campaigns[i]);
unchecked {
++i;
}
}
return campaignIds;
}
/// @notice Allows a user to accept the conditions without signing the message
/// @dev Users may either call `acceptConditions` here or `sign` the message
function acceptConditions() external {
userSignatureWhitelist[msg.sender] = 1;
}
/// @notice Checks whether the `msg.sender`'s `signature` is compatible with the message
/// to sign and stores the signature
/// @dev If you signed the message once, and the message has not been modified, then you do not
/// need to sign again
function sign(bytes calldata signature) external {
_sign(signature);
}
/// @notice Combines signing the message and creating a campaign
function signAndCreateCampaign(
CampaignParameters memory newCampaign,
bytes calldata signature
) external returns (bytes32) {
_sign(signature);
return _createCampaign(newCampaign);
}
/// @notice Creates a `distribution` to incentivize a given pool for a specific period of time
function createDistribution(
DistributionParameters memory newDistribution
) external nonReentrant hasSigned returns (uint256 distributionAmount) {
return _createDistribution(newDistribution);
}
/// @notice Same as the function above but for multiple distributions at once
function createDistributions(
DistributionParameters[] memory distributions
) external nonReentrant hasSigned returns (uint256[] memory) {
uint256 distributionsLength = distributions.length;
uint256[] memory distributionAmounts = new uint256[](distributionsLength);
for (uint256 i; i < distributionsLength; ) {
distributionAmounts[i] = _createDistribution(distributions[i]);
unchecked {
++i;
}
}
return distributionAmounts;
}
/// @notice Overrides a campaign with new parameters
/// @dev Some overrides maybe incorrect, but their correctness cannot be checked onchain. It is up to the Merkl
/// engine to check the validity of the override. If the override is invalid, then the first campaign details
/// will still apply.
/// @dev Some fields in the new campaign parameters will be disregarded anyway (like the amount)
function overrideCampaign(bytes32 _campaignId, CampaignParameters memory newCampaign) external {
CampaignParameters memory _campaign = campaign(_campaignId);
if (
_campaign.creator != msg.sender ||
newCampaign.rewardToken != _campaign.rewardToken ||
newCampaign.amount != _campaign.amount ||
(newCampaign.startTimestamp != _campaign.startTimestamp && block.timestamp > _campaign.startTimestamp) || // Allow to update startTimestamp before campaign start
// End timestamp should be in the future
newCampaign.duration + _campaign.startTimestamp <= block.timestamp
) revert Errors.InvalidOverride();
// Take a new fee to not trick the system by creating a campaign with the smallest fee
// and then overriding it with a campaign with a bigger fee
_computeFees(newCampaign.campaignType, newCampaign.amount, newCampaign.rewardToken);
newCampaign.campaignId = _campaignId;
newCampaign.creator = msg.sender;
campaignOverrides[_campaignId] = newCampaign;
campaignOverridesTimestamp[_campaignId].push(block.timestamp);
emit CampaignOverride(_campaignId, newCampaign);
}
/// @notice Reallocates rewards of a given campaign from one address to another
/// @dev To prevent manipulations by campaign creators, this function can only be called by the
/// initial campaign creator if the `from` address has never claimed any reward on the chain
/// @dev Compute engine should also make sure when reallocating rewards that `from` claimed amount
/// is still 0 - otherwise double allocation can happen
/// @dev It is meant to be used for the case of addresses accruing rewards but unable to claim them
function reallocateCampaignRewards(bytes32 _campaignId, address[] memory froms, address to) external {
CampaignParameters memory _campaign = campaign(_campaignId);
if (_campaign.creator != msg.sender || block.timestamp < _campaign.startTimestamp + _campaign.duration)
revert Errors.InvalidOverride();
uint256 fromsLength = froms.length;
address[] memory successfullFrom = new address[](fromsLength);
uint256 count = 0;
for (uint256 i; i < fromsLength; i++) {
(uint208 amount, uint48 timestamp, ) = Distributor(distributor).claimed(froms[i], _campaign.rewardToken);
if (amount == 0 && timestamp == 0) {
successfullFrom[count] = froms[i];
campaignReallocation[_campaignId][froms[i]] = to;
campaignListReallocation[_campaignId].push(froms[i]);
count++;
}
}
assembly {
mstore(successfullFrom, count)
}
if (count == 0) revert Errors.InvalidOverride();
emit CampaignReallocation(_campaignId, successfullFrom, to);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GETTERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Returns the distribution at a given index converted into a campaign
function distribution(uint256 index) external view returns (CampaignParameters memory) {
return _convertDistribution(distributionList[index]);
}
/// @notice Returns the index of a campaign in the campaign list
function campaignLookup(bytes32 _campaignId) public view returns (uint256) {
uint256 index = _campaignLookup[_campaignId];
if (index == 0) revert Errors.CampaignDoesNotExist();
return index - 1;
}
/// @notice Returns the campaign parameters of a given campaignId
/// @dev If a campaign has been overriden, this function still shows the original state of the campaign
function campaign(bytes32 _campaignId) public view returns (CampaignParameters memory) {
return campaignList[campaignLookup(_campaignId)];
}
/// @notice Returns the campaign ID for a given campaign
/// @dev The campaign ID is computed as the hash of the following parameters:
/// - `campaign.chainId`
/// - `campaign.creator`
/// - `campaign.rewardToken`
/// - `campaign.campaignType`
/// - `campaign.startTimestamp`
/// - `campaign.duration`
/// - `campaign.campaignData`
/// This prevents the creation by the same account of two campaigns with the same parameters
/// which is not a huge issue
function campaignId(CampaignParameters memory campaignData) public view returns (bytes32) {
return
bytes32(
keccak256(
abi.encodePacked(
CHAIN_ID,
campaignData.creator,
campaignData.rewardToken,
campaignData.campaignType,
campaignData.startTimestamp,
campaignData.duration,
campaignData.campaignData
)
)
);
}
/// @notice Returns the list of all the reward tokens supported as well as their minimum amounts
/// @dev Not to be queried on-chain and hence not optimized for gas consumption
function getValidRewardTokens() external view returns (RewardTokenAmounts[] memory) {
(RewardTokenAmounts[] memory validRewardTokens, ) = _getValidRewardTokens(0, type(uint32).max);
return validRewardTokens;
}
/// @dev Not to be queried on-chain and hence not optimized for gas consumption
function getValidRewardTokens(
uint32 skip,
uint32 first
) external view returns (RewardTokenAmounts[] memory, uint256) {
return _getValidRewardTokens(skip, first);
}
/// @notice Gets all the campaigns which were live at some point between `start` and `end` timestamp
/// @param skip Disregard distibutions with a global index lower than `skip`
/// @param first Limit the length of the returned array to `first`
/// @return searchCampaigns Eligible campaigns
/// @return lastIndexCampaign Index of the last campaign assessed in the list of all campaigns
/// @dev For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexCampaign`
/// @dev Not to be queried on-chain and hence not optimized for gas consumption
function getCampaignsBetween(
uint32 start,
uint32 end,
uint32 skip,
uint32 first
) external view returns (CampaignParameters[] memory, uint256 lastIndexCampaign) {
return _getCampaignsBetween(start, end, skip, first);
}
function getCampaignOverridesTimestamp(bytes32 _campaignId) external view returns (uint256[] memory) {
return campaignOverridesTimestamp[_campaignId];
}
function getCampaignListReallocation(bytes32 _campaignId) external view returns (address[] memory) {
return campaignListReallocation[_campaignId];
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GOVERNANCE FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Sets a new `distributor` to which rewards should be distributed
function setNewDistributor(address _distributor) external onlyGovernor {
if (_distributor == address(0)) revert Errors.InvalidParam();
distributor = _distributor;
emit DistributorUpdated(_distributor);
}
/// @notice Sets the defaultFees on deposit
function setFees(uint256 _defaultFees) external onlyGovernor {
if (_defaultFees >= BASE_9) revert Errors.InvalidParam();
defaultFees = _defaultFees;
emit FeesSet(_defaultFees);
}
/// @notice Recovers fees accrued on the contract for a list of `tokens`
function recoverFees(IERC20[] calldata tokens, address to) external onlyGovernor {
uint256 tokensLength = tokens.length;
for (uint256 i; i < tokensLength; ) {
tokens[i].safeTransfer(to, tokens[i].balanceOf(address(this)));
unchecked {
++i;
}
}
}
/// @notice Sets a new address to receive fees
function setFeeRecipient(address _feeRecipient) external onlyGovernor {
feeRecipient = _feeRecipient;
emit FeeRecipientUpdated(_feeRecipient);
}
/// @notice Sets the message that needs to be signed by users before posting rewards
function setMessage(string memory _message) external onlyGovernor {
message = _message;
bytes32 _messageHash = ECDSA.toEthSignedMessageHash(bytes(_message));
messageHash = _messageHash;
emit MessageUpdated(_messageHash);
}
/// @notice Sets the fees specific for a campaign
/// @dev To waive the fees for a campaign, set its fees to 1
function setCampaignFees(uint32 campaignType, uint256 _fees) external onlyGovernorOrGuardian {
if (_fees >= BASE_9) revert Errors.InvalidParam();
campaignSpecificFees[campaignType] = _fees;
emit CampaignSpecificFeesSet(campaignType, _fees);
}
/// @notice Toggles the fee whitelist for `token`
function toggleTokenWhitelist(address token) external onlyGovernorOrGuardian {
uint256 toggleStatus = 1 - isWhitelistedToken[token];
isWhitelistedToken[token] = toggleStatus;
emit TokenWhitelistToggled(token, toggleStatus);
}
/// @notice Sets fee rebates for a given user
function setUserFeeRebate(address user, uint256 userFeeRebate) external onlyGovernorOrGuardian {
feeRebate[user] = userFeeRebate;
emit FeeRebateUpdated(user, userFeeRebate);
}
/// @notice Sets the minimum amounts per distribution epoch for different reward tokens
function setRewardTokenMinAmounts(
address[] calldata tokens,
uint256[] calldata amounts
) external onlyGovernorOrGuardian {
uint256 tokensLength = tokens.length;
if (tokensLength != amounts.length) revert Errors.InvalidLengths();
for (uint256 i; i < tokensLength; ++i) {
uint256 amount = amounts[i];
// Basic logic check to make sure there are no duplicates in the `rewardTokens` table. If a token is
// removed then re-added, it will appear as a duplicate in the list
if (amount != 0 && rewardTokenMinAmounts[tokens[i]] == 0) rewardTokens.push(tokens[i]);
rewardTokenMinAmounts[tokens[i]] = amount;
emit RewardTokenMinimumAmountUpdated(tokens[i], amount);
}
}
/// @notice Toggles the whitelist status for `user` when it comes to signing messages before depositing rewards.
function toggleSigningWhitelist(address user) external onlyGovernorOrGuardian {
uint256 whitelistStatus = 1 - userSignatureWhitelist[user];
userSignatureWhitelist[user] = whitelistStatus;
emit UserSigningWhitelistToggled(user, whitelistStatus);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
INTERNAL
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Internal version of `createCampaign`
function _createCampaign(CampaignParameters memory newCampaign) internal returns (bytes32) {
uint256 rewardTokenMinAmount = rewardTokenMinAmounts[newCampaign.rewardToken];
// if the campaign doesn't last at least one hour
if (newCampaign.duration < HOUR) revert Errors.CampaignDurationBelowHour();
// if the reward token is not whitelisted as an incentive token
if (rewardTokenMinAmount == 0) revert Errors.CampaignRewardTokenNotWhitelisted();
// if the amount distributed is too small with respect to what is allowed
if ((newCampaign.amount * HOUR) / newCampaign.duration < rewardTokenMinAmount)
revert Errors.CampaignRewardTooLow();
if (newCampaign.creator == address(0)) newCampaign.creator = msg.sender;
// Computing fees: these are waived for whitelisted addresses and if there is a whitelisted token in a pool
uint256 campaignAmountMinusFees = _computeFees(
newCampaign.campaignType,
newCampaign.amount,
newCampaign.rewardToken
);
IERC20(newCampaign.rewardToken).safeTransferFrom(msg.sender, distributor, campaignAmountMinusFees);
newCampaign.amount = campaignAmountMinusFees;
newCampaign.campaignId = campaignId(newCampaign);
if (_campaignLookup[newCampaign.campaignId] != 0) revert Errors.CampaignAlreadyExists();
_campaignLookup[newCampaign.campaignId] = campaignList.length + 1;
campaignList.push(newCampaign);
emit NewCampaign(newCampaign);
return newCampaign.campaignId;
}
/// @notice Creates a distribution from a deprecated distribution type
function _createDistribution(DistributionParameters memory newDistribution) internal returns (uint256) {
_createCampaign(_convertDistribution(newDistribution));
// Not gas efficient but deprecated
return campaignList[campaignList.length - 1].amount;
}
/// @notice Converts the deprecated distribution type into a campaign
function _convertDistribution(
DistributionParameters memory distributionToConvert
) internal view returns (CampaignParameters memory) {
uint256 wrapperLength = distributionToConvert.wrapperTypes.length;
address[] memory whitelist = new address[](wrapperLength);
address[] memory blacklist = new address[](wrapperLength);
uint256 whitelistLength;
uint256 blacklistLength;
for (uint256 k = 0; k < wrapperLength; k++) {
if (distributionToConvert.wrapperTypes[k] == 0) {
whitelist[whitelistLength] = (distributionToConvert.positionWrappers[k]);
whitelistLength += 1;
}
if (distributionToConvert.wrapperTypes[k] == 3) {
blacklist[blacklistLength] = (distributionToConvert.positionWrappers[k]);
blacklistLength += 1;
}
}
assembly {
mstore(whitelist, whitelistLength)
mstore(blacklist, blacklistLength)
}
return
CampaignParameters({
campaignId: distributionToConvert.rewardId,
creator: msg.sender,
rewardToken: distributionToConvert.rewardToken,
amount: distributionToConvert.amount,
campaignType: 2,
startTimestamp: distributionToConvert.epochStart,
duration: distributionToConvert.numEpoch * HOUR,
campaignData: abi.encode(
distributionToConvert.uniV3Pool,
distributionToConvert.propFees, // eg. 6000
distributionToConvert.propToken0, // eg. 3000
distributionToConvert.propToken1, // eg. 1000
distributionToConvert.isOutOfRangeIncentivized, // eg. 0
distributionToConvert.boostingAddress, // eg. NULL_ADDRESS
distributionToConvert.boostedReward, // eg. 0
whitelist, // eg. []
blacklist, // eg. []
"0x"
)
});
}
/// @notice Computes the fees to be taken on a campaign and transfers them to the fee recipient
function _computeFees(
uint32 campaignType,
uint256 distributionAmount,
address rewardToken
) internal returns (uint256 distributionAmountMinusFees) {
uint256 baseFeesValue = campaignSpecificFees[campaignType];
if (baseFeesValue == 1) baseFeesValue = 0;
else if (baseFeesValue == 0) baseFeesValue = defaultFees;
uint256 _fees = (baseFeesValue * (BASE_9 - feeRebate[msg.sender])) / BASE_9;
distributionAmountMinusFees = distributionAmount;
if (_fees != 0) {
distributionAmountMinusFees = (distributionAmount * (BASE_9 - _fees)) / BASE_9;
address _feeRecipient = feeRecipient;
_feeRecipient = _feeRecipient == address(0) ? address(this) : _feeRecipient;
IERC20(rewardToken).safeTransferFrom(
msg.sender,
_feeRecipient,
distributionAmount - distributionAmountMinusFees
);
}
}
/// @notice Internal version of the `sign` function
function _sign(bytes calldata signature) internal {
bytes32 _messageHash = messageHash;
if (!SignatureChecker.isValidSignatureNow(msg.sender, _messageHash, signature))
revert Errors.InvalidSignature();
userSignatures[msg.sender] = _messageHash;
emit UserSigned(_messageHash, msg.sender);
}
/// @notice Rounds an `epoch` timestamp to the start of the corresponding period
function _getRoundedEpoch(uint32 epoch) internal pure returns (uint32) {
return (epoch / HOUR) * HOUR;
}
/// @notice Internal version of `getCampaignsBetween`
function _getCampaignsBetween(
uint32 start,
uint32 end,
uint32 skip,
uint32 first
) internal view returns (CampaignParameters[] memory, uint256) {
uint256 length;
uint256 campaignListLength = campaignList.length;
uint256 returnSize = first > campaignListLength ? campaignListLength : first;
CampaignParameters[] memory activeRewards = new CampaignParameters[](returnSize);
uint32 i = skip;
while (i < campaignListLength) {
CampaignParameters memory campaignToProcess = campaignList[i];
if (
campaignToProcess.startTimestamp + campaignToProcess.duration > start &&
campaignToProcess.startTimestamp < end
) {
activeRewards[length] = campaignToProcess;
length += 1;
}
unchecked {
++i;
}
if (length == returnSize) break;
}
assembly {
mstore(activeRewards, length)
}
return (activeRewards, i);
}
/// @notice Builds the list of valid reward tokens
function _getValidRewardTokens(
uint32 skip,
uint32 first
) internal view returns (RewardTokenAmounts[] memory, uint256) {
uint256 length;
uint256 rewardTokenListLength = rewardTokens.length;
uint256 returnSize = first > rewardTokenListLength ? rewardTokenListLength : first;
RewardTokenAmounts[] memory validRewardTokens = new RewardTokenAmounts[](returnSize);
uint32 i = skip;
while (i < rewardTokenListLength) {
address token = rewardTokens[i];
uint256 minAmount = rewardTokenMinAmounts[token];
if (minAmount > 0) {
validRewardTokens[length] = RewardTokenAmounts(token, minAmount);
length += 1;
}
unchecked {
++i;
}
if (length == returnSize) break;
}
assembly {
mstore(validRewardTokens, length)
}
return (validRewardTokens, i);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[31] private __gap;
}// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.17;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import { UUPSHelper } from "./utils/UUPSHelper.sol";
import { IAccessControlManager } from "./interfaces/IAccessControlManager.sol";
import { Errors } from "./utils/Errors.sol";
struct MerkleTree {
// Root of a Merkle tree which leaves are `(address user, address token, uint amount)`
// representing an amount of tokens accumulated by `user`.
// The Merkle tree is assumed to have only increasing amounts: that is to say if a user can claim 1,
// then after the amount associated in the Merkle tree for this token should be x > 1
bytes32 merkleRoot;
// Ipfs hash of the tree data
bytes32 ipfsHash;
}
struct Claim {
uint208 amount;
uint48 timestamp;
bytes32 merkleRoot;
}
interface IClaimRecipient {
/// @notice Hook to call within contracts receiving token rewards on behalf of users
function onClaim(address user, address token, uint256 amount, bytes memory data) external returns (bytes32);
}
/// @title Distributor
/// @notice Allows to claim rewards distributed to them through Merkl
/// @author Angle Labs. Inc
contract Distributor is UUPSHelper {
using SafeERC20 for IERC20;
/// @notice Default epoch duration
uint32 internal constant _EPOCH_DURATION = 3600;
/// @notice Success message received when calling a `ClaimRecipient` contract
bytes32 public constant CALLBACK_SUCCESS = keccak256("IClaimRecipient.onClaim");
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
VARIABLES
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Tree of claimable tokens through this contract
MerkleTree public tree;
/// @notice Tree that was in place in the contract before the last `tree` update
MerkleTree public lastTree;
/// @notice Token to deposit to freeze the roots update
IERC20 public disputeToken;
/// @notice `AccessControlManager` contract handling access control
IAccessControlManager public accessControlManager;
/// @notice Address which created the last dispute
/// @dev Used to store if there is an ongoing dispute
address public disputer;
/// @notice When the current tree becomes valid
uint48 public endOfDisputePeriod;
/// @notice Time after which a change in a tree becomes effective, in EPOCH_DURATION
uint48 public disputePeriod;
/// @notice Amount to deposit to freeze the roots update
uint256 public disputeAmount;
/// @notice Mapping user -> token -> amount to track claimed amounts
mapping(address => mapping(address => Claim)) public claimed;
/// @notice Trusted EOAs to update the Merkle root
mapping(address => uint256) public canUpdateMerkleRoot;
/// @notice Deprecated mapping
mapping(address => uint256) public onlyOperatorCanClaim;
/// @notice User -> Operator -> authorisation to claim on behalf of the user
mapping(address => mapping(address => uint256)) public operators;
/// @notice Whether the contract has been made non upgradeable or not
uint128 public upgradeabilityDeactivated;
/// @notice Reentrancy status
uint96 private _status;
/// @notice Epoch duration for dispute periods (in seconds)
uint32 internal _epochDuration;
/// @notice user -> token -> recipient address for when user claims `token`
/// @dev If the mapping is empty, by default rewards will accrue on the user address
mapping(address => mapping(address => address)) public claimRecipient;
uint256[36] private __gap;
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
event Claimed(address indexed user, address indexed token, uint256 amount);
event ClaimRecipientUpdated(address indexed user, address indexed token, address indexed recipient);
event DisputeAmountUpdated(uint256 _disputeAmount);
event Disputed(string reason);
event DisputePeriodUpdated(uint48 _disputePeriod);
event DisputeResolved(bool valid);
event DisputeTokenUpdated(address indexed _disputeToken);
event EpochDurationUpdated(uint32 newEpochDuration);
event OperatorClaimingToggled(address indexed user, bool isEnabled);
event OperatorToggled(address indexed user, address indexed operator, bool isWhitelisted);
event Recovered(address indexed token, address indexed to, uint256 amount);
event Revoked(); // With this event an indexer could maintain a table (timestamp, merkleRootUpdate)
event TreeUpdated(bytes32 merkleRoot, bytes32 ipfsHash, uint48 endOfDisputePeriod);
event TrustedToggled(address indexed eoa, bool trust);
event UpgradeabilityRevoked();
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MODIFIERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Checks whether the `msg.sender` has the governor role
modifier onlyGovernor() {
if (!accessControlManager.isGovernor(msg.sender)) revert Errors.NotGovernor();
_;
}
/// @notice Checks whether the `msg.sender` is the `user` address or is a trusted address
modifier onlyTrustedOrUser(address user) {
if (
user != msg.sender &&
canUpdateMerkleRoot[msg.sender] != 1 &&
!accessControlManager.isGovernorOrGuardian(msg.sender)
) revert Errors.NotTrusted();
_;
}
/// @notice Checks whether the contract is upgradeable or whether the caller is allowed to upgrade the contract
modifier onlyUpgradeableInstance() {
if (upgradeabilityDeactivated == 1) revert Errors.NotUpgradeable();
else if (!accessControlManager.isGovernor(msg.sender)) revert Errors.NotGovernor();
_;
}
/// @notice Checks whether a call is reentrant or not
modifier nonReentrant() {
if (_status == 2) revert Errors.ReentrantCall();
// Any calls to nonReentrant after this point will fail
_status = 2;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = 1;
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
constructor() initializer {}
function initialize(IAccessControlManager _accessControlManager) external initializer {
if (address(_accessControlManager) == address(0)) revert Errors.ZeroAddress();
accessControlManager = _accessControlManager;
}
/// @inheritdoc UUPSHelper
function _authorizeUpgrade(address) internal view override onlyUpgradeableInstance {}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MAIN FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Claims rewards for a given set of users
/// @dev Unless another address has been approved for claiming, only an address can claim for itself
/// @param users Addresses for which claiming is taking place
/// @param tokens ERC20 token claimed
/// @param amounts Amount of tokens that will be sent to the corresponding users
/// @param proofs Array of hashes bridging from a leaf `(hash of user | token | amount)` to the Merkle root
function claim(
address[] calldata users,
address[] calldata tokens,
uint256[] calldata amounts,
bytes32[][] calldata proofs
) external {
address[] memory recipients = new address[](users.length);
bytes[] memory datas = new bytes[](users.length);
_claim(users, tokens, amounts, proofs, recipients, datas);
}
/// @notice Same as the function above except that for each token claimed, the caller may set different
/// recipients for rewards and pass arbitrary data to the reward recipient on claim
/// @dev Only a `msg.sender` calling for itself can set a different recipient for the token rewards
/// within the context of a call to claim
/// @dev Non-zero recipient addresses given by the `msg.sender` can override any previously set reward address
function claimWithRecipient(
address[] calldata users,
address[] calldata tokens,
uint256[] calldata amounts,
bytes32[][] calldata proofs,
address[] calldata recipients,
bytes[] memory datas
) external {
_claim(users, tokens, amounts, proofs, recipients, datas);
}
/// @notice Returns the Merkle root that is currently live for the contract
function getMerkleRoot() public view returns (bytes32) {
if (block.timestamp >= endOfDisputePeriod && disputer == address(0)) return tree.merkleRoot;
else return lastTree.merkleRoot;
}
function getEpochDuration() public view returns (uint32 epochDuration) {
epochDuration = _epochDuration;
if (epochDuration == 0) epochDuration = _EPOCH_DURATION;
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
USER ADMIN FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Toggles whitelisting for a given user and a given operator
/// @dev When an operator is whitelisted for a user, the operator can claim rewards on behalf of the user
function toggleOperator(address user, address operator) external onlyTrustedOrUser(user) {
uint256 oldValue = operators[user][operator];
operators[user][operator] = 1 - oldValue;
emit OperatorToggled(user, operator, oldValue == 0);
}
/// @notice Sets a recipient for a user claiming rewards for a token
/// @dev This is an optional functionality and if the `recipient` is set to the zero address, then
/// the user will still accrue all rewards to its address
/// @dev Users may still specify a different recipient when they claim token rewards with the
/// `claimWithRecipient` function
function setClaimRecipient(address recipient, address token) external {
claimRecipient[msg.sender][token] = recipient;
emit ClaimRecipientUpdated(msg.sender, recipient, token);
}
/// @notice Freezes the Merkle tree update until the dispute is resolved
/// @dev Requires a deposit of `disputeToken` that'll be slashed if the dispute is not accepted
/// @dev It is only possible to create a dispute within `disputePeriod` after each tree update
function disputeTree(string memory reason) external {
if (disputer != address(0)) revert Errors.UnresolvedDispute();
if (block.timestamp >= endOfDisputePeriod) revert Errors.InvalidDispute();
IERC20(disputeToken).safeTransferFrom(msg.sender, address(this), disputeAmount);
disputer = msg.sender;
emit Disputed(reason);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GOVERNANCE FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Updates the Merkle tree
function updateTree(MerkleTree calldata _tree) external {
if (
disputer != address(0) ||
// A trusted address cannot update a tree right after a precedent tree update otherwise it can de facto
// validate a tree which has not passed the dispute period
((canUpdateMerkleRoot[msg.sender] != 1 || block.timestamp < endOfDisputePeriod) &&
!accessControlManager.isGovernor(msg.sender))
) revert Errors.NotTrusted();
MerkleTree memory _lastTree = tree;
tree = _tree;
lastTree = _lastTree;
uint48 _endOfPeriod = _endOfDisputePeriod(uint48(block.timestamp));
endOfDisputePeriod = _endOfPeriod;
emit TreeUpdated(_tree.merkleRoot, _tree.ipfsHash, _endOfPeriod);
}
/// @notice Adds or removes addresses which are trusted to update the Merkle root
function toggleTrusted(address trustAddress) external onlyGovernor {
uint256 trustedStatus = 1 - canUpdateMerkleRoot[trustAddress];
canUpdateMerkleRoot[trustAddress] = trustedStatus;
emit TrustedToggled(trustAddress, trustedStatus == 1);
}
/// @notice Prevents future contract upgrades
function revokeUpgradeability() external onlyGovernor {
upgradeabilityDeactivated = 1;
emit UpgradeabilityRevoked();
}
/// @notice Updates the epoch duration period
function setEpochDuration(uint32 epochDuration) external onlyGovernor {
_epochDuration = epochDuration;
emit EpochDurationUpdated(epochDuration);
}
/// @notice Resolve the ongoing dispute, if any
/// @param valid Whether the dispute was valid
function resolveDispute(bool valid) external onlyGovernor {
if (disputer == address(0)) revert Errors.NoDispute();
if (valid) {
IERC20(disputeToken).safeTransfer(disputer, disputeAmount);
// If a dispute is valid, the contract falls back to the last tree that was updated
_revokeTree();
} else {
IERC20(disputeToken).safeTransfer(msg.sender, disputeAmount);
endOfDisputePeriod = _endOfDisputePeriod(uint48(block.timestamp));
}
disputer = address(0);
emit DisputeResolved(valid);
}
/// @notice Allows the governor of this contract to fallback to the last version of the tree
/// immediately
function revokeTree() external onlyGovernor {
if (disputer != address(0)) revert Errors.UnresolvedDispute();
_revokeTree();
}
/// @notice Recovers any ERC20 token left on the contract
function recoverERC20(address tokenAddress, address to, uint256 amountToRecover) external onlyGovernor {
IERC20(tokenAddress).safeTransfer(to, amountToRecover);
emit Recovered(tokenAddress, to, amountToRecover);
}
/// @notice Sets the dispute period after which a tree update becomes effective
function setDisputePeriod(uint48 _disputePeriod) external onlyGovernor {
disputePeriod = uint48(_disputePeriod);
emit DisputePeriodUpdated(_disputePeriod);
}
/// @notice Sets the token used as a caution during disputes
function setDisputeToken(IERC20 _disputeToken) external onlyGovernor {
if (disputer != address(0)) revert Errors.UnresolvedDispute();
disputeToken = _disputeToken;
emit DisputeTokenUpdated(address(_disputeToken));
}
/// @notice Sets the amount of `disputeToken` used as a caution during disputes
function setDisputeAmount(uint256 _disputeAmount) external onlyGovernor {
if (disputer != address(0)) revert Errors.UnresolvedDispute();
disputeAmount = _disputeAmount;
emit DisputeAmountUpdated(_disputeAmount);
}
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
INTERNAL HELPERS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/// @notice Internal version of `claimWithRecipient`
function _claim(
address[] calldata users,
address[] calldata tokens,
uint256[] calldata amounts,
bytes32[][] calldata proofs,
address[] memory recipients,
bytes[] memory datas
) internal nonReentrant {
uint256 usersLength = users.length;
if (
usersLength == 0 ||
usersLength != tokens.length ||
usersLength != amounts.length ||
usersLength != proofs.length ||
usersLength != recipients.length ||
usersLength != datas.length
) revert Errors.InvalidLengths();
for (uint256 i; i < usersLength; ) {
address user = users[i];
address token = tokens[i];
uint256 amount = amounts[i];
bytes memory data = datas[i];
// Only approved operator can claim for `user`
if (msg.sender != user && tx.origin != user && operators[user][msg.sender] == 0)
revert Errors.NotWhitelisted();
// Verifying proof
bytes32 leaf = keccak256(abi.encode(user, token, amount));
if (!_verifyProof(leaf, proofs[i])) revert Errors.InvalidProof();
// Closing reentrancy gate here
uint256 toSend = amount - claimed[user][token].amount;
claimed[user][token] = Claim(SafeCast.toUint208(amount), uint48(block.timestamp), getMerkleRoot());
emit Claimed(user, token, toSend);
address recipient = recipients[i];
// Only `msg.sender` can set a different recipient for itself within the context of a call to claim
// The recipient set in the context of the call to `claim` can override the default recipient set by the user
if (msg.sender != user || recipient == address(0)) {
address userSetRecipient = claimRecipient[user][token];
if (userSetRecipient == address(0)) recipient = user;
else recipient = userSetRecipient;
}
if (toSend != 0) {
IERC20(token).safeTransfer(recipient, toSend);
if (data.length != 0) {
try IClaimRecipient(recipient).onClaim(user, token, amount, data) returns (
bytes32 callbackSuccess
) {
if (callbackSuccess != CALLBACK_SUCCESS) revert Errors.InvalidReturnMessage();
} catch {}
}
}
unchecked {
++i;
}
}
}
/// @notice Fallback to the last version of the tree
function _revokeTree() internal {
MerkleTree memory _tree = lastTree;
endOfDisputePeriod = 0;
tree = _tree;
uint32 epochDuration = getEpochDuration();
emit Revoked();
emit TreeUpdated(
_tree.merkleRoot,
_tree.ipfsHash,
(uint48(block.timestamp) / epochDuration) * (epochDuration) // Last hour
);
}
/// @notice Returns the end of the dispute period
/// @dev treeUpdate is rounded up to next hour and then `disputePeriod` hours are added
function _endOfDisputePeriod(uint48 treeUpdate) internal view returns (uint48) {
uint32 epochDuration = getEpochDuration();
return ((treeUpdate - 1) / epochDuration + 1 + disputePeriod) * (epochDuration);
}
/// @notice Checks the validity of a proof
/// @param leaf Hashed leaf data, the starting point of the proof
/// @param proof Array of hashes forming a hash chain from leaf to root
/// @return true If proof is correct, else false
function _verifyProof(bytes32 leaf, bytes32[] memory proof) internal view returns (bool) {
bytes32 currentHash = leaf;
uint256 proofLength = proof.length;
for (uint256 i; i < proofLength; ) {
if (currentHash < proof[i]) {
currentHash = keccak256(abi.encode(currentHash, proof[i]));
} else {
currentHash = keccak256(abi.encode(proof[i], currentHash));
}
unchecked {
++i;
}
}
bytes32 root = getMerkleRoot();
if (root == bytes32(0)) revert Errors.InvalidUninitializedRoot();
return currentHash == root;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
/// @title IAccessControlManager
/// @author Angle Labs, Inc.
/// @notice Interface for the `AccessControlManager` contracts of Merkl contracts
interface IAccessControlManager {
/// @notice Checks whether an address is governor
/// @param admin Address to check
/// @return Whether the address has the `GOVERNOR_ROLE` or not
function isGovernor(address admin) external view returns (bool);
/// @notice Checks whether an address is a governor or a guardian of a module
/// @param admin Address to check
/// @return Whether the address has the `GUARDIAN_ROLE` or not
/// @dev Governance should make sure when adding a governor to also give this governor the guardian
/// role by calling the `addGovernor` function
function isGovernorOrGuardian(address admin) external view returns (bool);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;
struct CampaignParameters {
// POPULATED ONCE CREATED
// ID of the campaign. This can be left as a null bytes32 when creating campaigns
// on Merkl.
bytes32 campaignId;
// CHOSEN BY CAMPAIGN CREATOR
// Address of the campaign creator, if marked as address(0), it will be overriden with the
// address of the `msg.sender` creating the campaign
address creator;
// Address of the token used as a reward
address rewardToken;
// Amount of `rewardToken` to distribute across all the epochs
// Amount distributed per epoch is `amount/numEpoch`
uint256 amount;
// Type of campaign
uint32 campaignType;
// Timestamp at which the campaign should start
uint32 startTimestamp;
// Duration of the campaign in seconds. Has to be a multiple of EPOCH = 3600
uint32 duration;
// Extra data to pass to specify the campaign
bytes campaignData;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;
struct DistributionParameters {
// ID of the reward (populated once created). This can be left as a null bytes32 when creating distributions
// on Merkl.
bytes32 rewardId;
// Address of the UniswapV3 pool that needs to be incentivized
address uniV3Pool;
// Address of the reward token for the incentives
address rewardToken;
// Amount of `rewardToken` to distribute across all the epochs
// Amount distributed per epoch is `amount/numEpoch`
uint256 amount;
// List of all position wrappers to consider or not for this contract. Some wrappers like Gamma or Arrakis
// are automatically detected and so there is no need to specify them here. Check out the docs to find out
// which need to be specified and which are not automatically detected.
address[] positionWrappers;
// Type (blacklist==3, whitelist==0, ...) encoded as a `uint32` for each wrapper in the list above. Mapping between
// wrapper types and their corresponding `uint32` value can be found in Angle Docs
uint32[] wrapperTypes;
// In the incentivization formula, how much of the fees should go to holders of token0
// in base 10**4
uint32 propToken0;
// Proportion for holding token1 (in base 10**4)
uint32 propToken1;
// Proportion for providing a useful liquidity (in base 10**4) that generates fees
uint32 propFees;
// Timestamp at which the incentivization should start. This is in the same units as `block.timestamp`.
uint32 epochStart;
// Amount of epochs for which incentivization should last. Epochs are expressed in hours here, so for a
// campaign of 1 week `numEpoch` should for instance be 168.
uint32 numEpoch;
// Whether out of range liquidity should still be incentivized or not
// This should be equal to 1 if out of range liquidity should still be incentivized
// and 0 otherwise.
uint32 isOutOfRangeIncentivized;
// How much more addresses with a maximum boost can get with respect to addresses
// which do not have a boost (in base 4). In the case of Curve where addresses get 2.5x more
// this would be 25000.
uint32 boostedReward;
// Address of the token which dictates who gets boosted rewards or not. This is optional
// and if the zero address is given no boost will be taken into account. In the case of Curve, this address
// would for instance be the veBoostProxy address, or in other cases the veToken address.
address boostingAddress;
// Additional data passed when distributing rewards. This parameter may be used in case
// the reward distribution script needs to look into other parameters beyond the ones above.
// In most cases, when creating a campaign on Merkl, you can leave this as an empty bytes.
bytes additionalData;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;
struct RewardTokenAmounts {
address token;
uint256 minimumAmountPerEpoch;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
library Errors {
error CampaignDoesNotExist();
error CampaignAlreadyExists();
error CampaignDurationBelowHour();
error CampaignRewardTokenNotWhitelisted();
error CampaignRewardTooLow();
error CampaignShouldStartInFuture();
error InvalidDispute();
error InvalidLengths();
error InvalidOverride();
error InvalidParam();
error InvalidParams();
error InvalidProof();
error InvalidUninitializedRoot();
error InvalidReturnMessage();
error InvalidReward();
error InvalidSignature();
error KeyAlreadyUsed();
error NoDispute();
error NoOverrideForCampaign();
error NotAllowed();
error NotEnoughPayment();
error NotGovernor();
error NotGovernorOrGuardian();
error NotSigned();
error NotTrusted();
error NotUpgradeable();
error NotWhitelisted();
error UnresolvedDispute();
error ZeroAddress();
error DisputeFundsTransferFailed();
error EthNotAccepted();
error ReentrantCall();
error WithdrawalFailed();
error InvalidClaim();
error RefererNotSet();
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import { IAccessControlManager } from "../interfaces/IAccessControlManager.sol";
import { Errors } from "./Errors.sol";
/// @title UUPSHelper
/// @notice Helper contract for UUPSUpgradeable contracts where the upgradeability is controlled by a specific address
/// @author Angle Labs., Inc
/// @dev The 0 address check in the modifier allows the use of these modifiers during initialization
abstract contract UUPSHelper is UUPSUpgradeable {
modifier onlyGuardianUpgrader(IAccessControlManager _accessControlManager) {
if (address(_accessControlManager) != address(0) && !_accessControlManager.isGovernorOrGuardian(msg.sender))
revert Errors.NotGovernorOrGuardian();
_;
}
modifier onlyGovernorUpgrader(IAccessControlManager _accessControlManager) {
if (address(_accessControlManager) != address(0) && !_accessControlManager.isGovernor(msg.sender))
revert Errors.NotGovernor();
_;
}
constructor() initializer {}
/// @inheritdoc UUPSUpgradeable
function _authorizeUpgrade(address newImplementation) internal virtual override {}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
*
* _Available since v4.8.3._
*/
interface IERC1967Upgradeable {
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Emitted when the beacon is changed.
*/
event BeaconUpgraded(address indexed beacon);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822ProxiableUpgradeable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)
pragma solidity ^0.8.2;
import "../beacon/IBeaconUpgradeable.sol";
import "../../interfaces/IERC1967Upgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import "../utils/Initializable.sol";
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*
* _Available since v4.1._
*/
abstract contract ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
function __ERC1967Upgrade_init() internal onlyInitializing {
}
function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
}
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation address.
*/
function _getImplementation() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Perform implementation upgrade
*
* Emits an {Upgraded} event.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Perform implementation upgrade with additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
AddressUpgradeable.functionDelegateCall(newImplementation, data);
}
}
/**
* @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Returns the current admin.
*/
function _getAdmin() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {AdminChanged} event.
*/
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
*/
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Returns the current beacon.
*/
function _getBeacon() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
/**
* @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
* not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
*
* Emits a {BeaconUpgraded} event.
*/
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.0;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeaconUpgradeable {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {BeaconProxy} will check that this address is a contract.
*/
function implementation() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @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 Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 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 functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_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 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_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() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @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 {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)
pragma solidity ^0.8.0;
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import "./Initializable.sol";
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*
* _Available since v4.1._
*/
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
/**
* @dev Check that the execution is being performed through a delegatecall call and that the execution context is
* a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
* function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
* fail.
*/
modifier onlyProxy() {
require(address(this) != __self, "Function must be called through delegatecall");
require(_getImplementation() == __self, "Function must be called through active proxy");
_;
}
/**
* @dev Check that the execution is not being performed through a delegate call. This allows a function to be
* callable on the implementing contract but not through proxies.
*/
modifier notDelegated() {
require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
_;
}
/**
* @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
* implementation. It is used to validate the implementation's compatibility when performing an upgrade.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
*/
function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
return _IMPLEMENTATION_SLOT;
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function upgradeTo(address newImplementation) public virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
* encoded in `data`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
/**
* @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
* {upgradeTo} and {upgradeToAndCall}.
*
* Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
*
* ```solidity
* function _authorizeUpgrade(address) internal override onlyOwner {}
* ```
*/
function _authorizeUpgrade(address newImplementation) internal virtual;
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
import "../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 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;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @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, it is bubbled up by this
* function (like regular Solidity function calls).
*
* 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.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @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`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
* _Available since v4.9 for `string`, `bytes`._
*/
library StorageSlotUpgradeable {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
/**
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC1271 standard signature validation method for
* contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
*
* _Available since v4.1._
*/
interface IERC1271 {
/**
* @dev Should return whether the signature provided is valid for the provided data
* @param hash Hash of the data to be signed
* @param signature Signature byte array associated with _data
*/
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` 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 amount) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*
* CAUTION: See Security Considerations above.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev 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.encodeWithSelector(token.transfer.selector, 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.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
* Revert on invalid signature.
*/
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @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, it is bubbled up by this
* function (like regular Solidity function calls).
*
* 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.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @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`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
import "../Strings.sol";
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV // Deprecated in v4.8
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ? {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
/**
* @dev Returns an Ethereum Signed Data with intended validator, created from a
* `validator` and `data` according to the version 0 of EIP-191.
*
* See {recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/SignatureChecker.sol)
pragma solidity ^0.8.0;
import "./ECDSA.sol";
import "../../interfaces/IERC1271.sol";
/**
* @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
* signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
* Argent and Gnosis Safe.
*
* _Available since v4.1._
*/
library SignatureChecker {
/**
* @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
* signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
*
* NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
* change through time. It could return true at block N and false at block N+1 (or the opposite).
*/
function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
(address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
return
(error == ECDSA.RecoverError.NoError && recovered == signer) ||
isValidERC1271SignatureNow(signer, hash, signature);
}
/**
* @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
* against the signer smart contract using ERC1271.
*
* NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
* change through time. It could return true at block N and false at block N+1 (or the opposite).
*/
function isValidERC1271SignatureNow(
address signer,
bytes32 hash,
bytes memory signature
) internal view returns (bool) {
(bool success, bytes memory result) = signer.staticcall(
abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
);
return (success &&
result.length >= 32 &&
abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// ? `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// ? `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCast {
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*
* _Available since v4.7._
*/
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*
* _Available since v4.7._
*/
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*
* _Available since v4.7._
*/
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*
* _Available since v4.2._
*/
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*
* _Available since v4.7._
*/
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*
* _Available since v4.7._
*/
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*
* _Available since v4.7._
*/
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*
* _Available since v4.7._
*/
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*
* _Available since v4.7._
*/
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*
* _Available since v4.7._
*/
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*
* _Available since v4.7._
*/
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*
* _Available since v4.7._
*/
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*
* _Available since v4.7._
*/
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*
* _Available since v4.7._
*/
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*
* _Available since v4.7._
*/
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v2.5._
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*
* _Available since v4.7._
*/
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*
* _Available since v4.7._
*/
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*
* _Available since v4.7._
*/
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*
* _Available since v4.2._
*/
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*
* _Available since v4.7._
*/
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*
* _Available since v4.7._
*/
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*
* _Available since v4.7._
*/
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v2.5._
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*
* _Available since v4.7._
*/
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*
* _Available since v4.7._
*/
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*
* _Available since v4.7._
*/
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v2.5._
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*
* _Available since v4.7._
*/
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v2.5._
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*
* _Available since v2.5._
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*
* _Available since v3.0._
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*
* _Available since v4.7._
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*
* _Available since v4.7._
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*
* _Available since v4.7._
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*
* _Available since v4.7._
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*
* _Available since v4.7._
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*
* _Available since v4.7._
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*
* _Available since v4.7._
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*
* _Available since v4.7._
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*
* _Available since v4.7._
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*
* _Available since v4.7._
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*
* _Available since v4.7._
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*
* _Available since v4.7._
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*
* _Available since v4.7._
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*
* _Available since v4.7._
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*
* _Available since v4.7._
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*
* _Available since v4.7._
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*
* _Available since v4.7._
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*
* _Available since v4.7._
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*
* _Available since v4.7._
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*
* _Available since v4.7._
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*
* _Available since v4.7._
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*
* _Available since v4.7._
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*
* _Available since v4.7._
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*
* _Available since v4.7._
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*
* _Available since v4.7._
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*
* _Available since v4.7._
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*
* _Available since v3.0._
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}{
"evmVersion": "cancun",
"libraries": {},
"metadata": {
"appendCBOR": true,
"bytecodeHash": "ipfs",
"useLiteralContent": false
},
"optimizer": {
"enabled": true,
"runs": 100
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"remappings": [
"@openzeppelin/=node_modules/@openzeppelin/",
"forge-std/=node_modules/forge-std/src/",
"oz/=node_modules/@openzeppelin/contracts/",
"@utils/=node_modules/utils/src/",
"hardhat/=node_modules/hardhat/",
"lz/=node_modules/utils/lib/solidity-examples/contracts/",
"stringutils/=node_modules/utils/lib/solidity-stringutils/src/",
"utils/=node_modules/utils/"
],
"viaIR": false
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CampaignAlreadyExists","type":"error"},{"inputs":[],"name":"CampaignDoesNotExist","type":"error"},{"inputs":[],"name":"CampaignDurationBelowHour","type":"error"},{"inputs":[],"name":"CampaignRewardTokenNotWhitelisted","type":"error"},{"inputs":[],"name":"CampaignRewardTooLow","type":"error"},{"inputs":[],"name":"InvalidLengths","type":"error"},{"inputs":[],"name":"InvalidOverride","type":"error"},{"inputs":[],"name":"InvalidParam","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"NotGovernor","type":"error"},{"inputs":[],"name":"NotGovernorOrGuardian","type":"error"},{"inputs":[],"name":"NotSigned","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_campaignId","type":"bytes32"},{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"indexed":false,"internalType":"struct CampaignParameters","name":"campaign","type":"tuple"}],"name":"CampaignOverride","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_campaignId","type":"bytes32"},{"indexed":true,"internalType":"address[]","name":"from","type":"address[]"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"CampaignReallocation","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"campaignType","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"CampaignSpecificFeesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_distributor","type":"address"}],"name":"DistributorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"userFeeRebate","type":"uint256"}],"name":"FeeRebateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_feeRecipient","type":"address"}],"name":"FeeRecipientUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"FeesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_messageHash","type":"bytes32"}],"name":"MessageUpdated","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"indexed":false,"internalType":"struct CampaignParameters","name":"campaign","type":"tuple"}],"name":"NewCampaign","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"bytes32","name":"rewardId","type":"bytes32"},{"internalType":"address","name":"uniV3Pool","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address[]","name":"positionWrappers","type":"address[]"},{"internalType":"uint32[]","name":"wrapperTypes","type":"uint32[]"},{"internalType":"uint32","name":"propToken0","type":"uint32"},{"internalType":"uint32","name":"propToken1","type":"uint32"},{"internalType":"uint32","name":"propFees","type":"uint32"},{"internalType":"uint32","name":"epochStart","type":"uint32"},{"internalType":"uint32","name":"numEpoch","type":"uint32"},{"internalType":"uint32","name":"isOutOfRangeIncentivized","type":"uint32"},{"internalType":"uint32","name":"boostedReward","type":"uint32"},{"internalType":"address","name":"boostingAddress","type":"address"},{"internalType":"bytes","name":"additionalData","type":"bytes"}],"indexed":false,"internalType":"struct DistributionParameters","name":"distribution","type":"tuple"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"NewDistribution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardTokenMinimumAmountUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"toggleStatus","type":"uint256"}],"name":"TokenWhitelistToggled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"UserSigned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"toggleStatus","type":"uint256"}],"name":"UserSigningWhitelistToggled","type":"event"},{"inputs":[],"name":"BASE_9","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CHAIN_ID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HOUR","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptConditions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"accessControlManager","outputs":[{"internalType":"contract IAccessControlManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_campaignId","type":"bytes32"}],"name":"campaign","outputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters","name":"campaignData","type":"tuple"}],"name":"campaignId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"campaignList","outputs":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"campaignListReallocation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_campaignId","type":"bytes32"}],"name":"campaignLookup","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"campaignOverrides","outputs":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"campaignOverridesTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"address","name":"","type":"address"}],"name":"campaignReallocation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"","type":"uint32"}],"name":"campaignSpecificFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters","name":"newCampaign","type":"tuple"}],"name":"createCampaign","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters[]","name":"campaigns","type":"tuple[]"}],"name":"createCampaigns","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"rewardId","type":"bytes32"},{"internalType":"address","name":"uniV3Pool","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address[]","name":"positionWrappers","type":"address[]"},{"internalType":"uint32[]","name":"wrapperTypes","type":"uint32[]"},{"internalType":"uint32","name":"propToken0","type":"uint32"},{"internalType":"uint32","name":"propToken1","type":"uint32"},{"internalType":"uint32","name":"propFees","type":"uint32"},{"internalType":"uint32","name":"epochStart","type":"uint32"},{"internalType":"uint32","name":"numEpoch","type":"uint32"},{"internalType":"uint32","name":"isOutOfRangeIncentivized","type":"uint32"},{"internalType":"uint32","name":"boostedReward","type":"uint32"},{"internalType":"address","name":"boostingAddress","type":"address"},{"internalType":"bytes","name":"additionalData","type":"bytes"}],"internalType":"struct DistributionParameters","name":"newDistribution","type":"tuple"}],"name":"createDistribution","outputs":[{"internalType":"uint256","name":"distributionAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"rewardId","type":"bytes32"},{"internalType":"address","name":"uniV3Pool","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address[]","name":"positionWrappers","type":"address[]"},{"internalType":"uint32[]","name":"wrapperTypes","type":"uint32[]"},{"internalType":"uint32","name":"propToken0","type":"uint32"},{"internalType":"uint32","name":"propToken1","type":"uint32"},{"internalType":"uint32","name":"propFees","type":"uint32"},{"internalType":"uint32","name":"epochStart","type":"uint32"},{"internalType":"uint32","name":"numEpoch","type":"uint32"},{"internalType":"uint32","name":"isOutOfRangeIncentivized","type":"uint32"},{"internalType":"uint32","name":"boostedReward","type":"uint32"},{"internalType":"address","name":"boostingAddress","type":"address"},{"internalType":"bytes","name":"additionalData","type":"bytes"}],"internalType":"struct DistributionParameters[]","name":"distributions","type":"tuple[]"}],"name":"createDistributions","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"defaultFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"distribution","outputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"distributionList","outputs":[{"internalType":"bytes32","name":"rewardId","type":"bytes32"},{"internalType":"address","name":"uniV3Pool","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"propToken0","type":"uint32"},{"internalType":"uint32","name":"propToken1","type":"uint32"},{"internalType":"uint32","name":"propFees","type":"uint32"},{"internalType":"uint32","name":"epochStart","type":"uint32"},{"internalType":"uint32","name":"numEpoch","type":"uint32"},{"internalType":"uint32","name":"isOutOfRangeIncentivized","type":"uint32"},{"internalType":"uint32","name":"boostedReward","type":"uint32"},{"internalType":"address","name":"boostingAddress","type":"address"},{"internalType":"bytes","name":"additionalData","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"feeRebate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_campaignId","type":"bytes32"}],"name":"getCampaignListReallocation","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_campaignId","type":"bytes32"}],"name":"getCampaignOverridesTimestamp","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"start","type":"uint32"},{"internalType":"uint32","name":"end","type":"uint32"},{"internalType":"uint32","name":"skip","type":"uint32"},{"internalType":"uint32","name":"first","type":"uint32"}],"name":"getCampaignsBetween","outputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters[]","name":"","type":"tuple[]"},{"internalType":"uint256","name":"lastIndexCampaign","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getValidRewardTokens","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"minimumAmountPerEpoch","type":"uint256"}],"internalType":"struct RewardTokenAmounts[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"skip","type":"uint32"},{"internalType":"uint32","name":"first","type":"uint32"}],"name":"getValidRewardTokens","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"minimumAmountPerEpoch","type":"uint256"}],"internalType":"struct RewardTokenAmounts[]","name":"","type":"tuple[]"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IAccessControlManager","name":"_accessControlManager","type":"address"},{"internalType":"address","name":"_distributor","type":"address"},{"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isWhitelistedToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"message","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"messageHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_campaignId","type":"bytes32"},{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters","name":"newCampaign","type":"tuple"}],"name":"overrideCampaign","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_campaignId","type":"bytes32"},{"internalType":"address[]","name":"froms","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"reallocateCampaignRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"recoverFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardTokenMinAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint256","name":"_fees","type":"uint256"}],"name":"setCampaignFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeRecipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_defaultFees","type":"uint256"}],"name":"setFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_message","type":"string"}],"name":"setMessage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_distributor","type":"address"}],"name":"setNewDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"setRewardTokenMinAmounts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"userFeeRebate","type":"uint256"}],"name":"setUserFeeRebate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"sign","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"campaignId","type":"bytes32"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"address","name":"rewardToken","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint32","name":"campaignType","type":"uint32"},{"internalType":"uint32","name":"startTimestamp","type":"uint32"},{"internalType":"uint32","name":"duration","type":"uint32"},{"internalType":"bytes","name":"campaignData","type":"bytes"}],"internalType":"struct CampaignParameters","name":"newCampaign","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"signAndCreateCampaign","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"toggleSigningWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"toggleTokenWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userSignatureWhitelist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userSignatures","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
0x7Db28175B63f154587BbB1Cae62D39Ea80A23383
Multichain Portfolio | 34 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
Loading...
Loading
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.