编译器
0.8.18+commit.87f61d96
文件 1 的 48：AccessControl.sol
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(account),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
文件 2 的 48：AccessControlEnumerable.sol
pragma solidity ^0.8.0;
import "./IAccessControlEnumerable.sol";
import "./AccessControl.sol";
import "../utils/structs/EnumerableSet.sol";
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
using EnumerableSet for EnumerableSet.AddressSet;
mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
}
function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
return _roleMembers[role].at(index);
}
function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
return _roleMembers[role].length();
}
function _grantRole(bytes32 role, address account) internal virtual override {
super._grantRole(role, account);
_roleMembers[role].add(account);
}
function _revokeRole(bytes32 role, address account) internal virtual override {
super._revokeRole(role, account);
_roleMembers[role].remove(account);
}
}
文件 3 的 48：AccessControlEnumerableUpgradeable.sol
pragma solidity ^0.8.0;
import "./IAccessControlEnumerableUpgradeable.sol";
import "./AccessControlUpgradeable.sol";
import "../utils/structs/EnumerableSetUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerableUpgradeable, AccessControlUpgradeable {
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
mapping(bytes32 => EnumerableSetUpgradeable.AddressSet) private _roleMembers;
function __AccessControlEnumerable_init() internal onlyInitializing {
}
function __AccessControlEnumerable_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
return _roleMembers[role].at(index);
}
function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
return _roleMembers[role].length();
}
function _grantRole(bytes32 role, address account) internal virtual override {
super._grantRole(role, account);
_roleMembers[role].add(account);
}
function _revokeRole(bytes32 role, address account) internal virtual override {
super._revokeRole(role, account);
_roleMembers[role].remove(account);
}
uint256[49] private __gap;
}
文件 4 的 48：AccessControlUpgradeable.sol
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(account),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
uint256[49] private __gap;
}
文件 5 的 48：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
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);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
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);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
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 {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 6 的 48：AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
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);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
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);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
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 {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 7 的 48：Clone.sol
pragma solidity ^0.8.4;
contract Clone {
function _getArgAddress(uint256 argOffset)
internal
pure
returns (address arg)
{
uint256 offset = _getImmutableArgsOffset();
assembly {
arg := shr(0x60, calldataload(add(offset, argOffset)))
}
}
function _getArgUint256(uint256 argOffset)
internal
pure
returns (uint256 arg)
{
uint256 offset = _getImmutableArgsOffset();
assembly {
arg := calldataload(add(offset, argOffset))
}
}
function _getArgUint64(uint256 argOffset)
internal
pure
returns (uint64 arg)
{
uint256 offset = _getImmutableArgsOffset();
assembly {
arg := shr(0xc0, calldataload(add(offset, argOffset)))
}
}
function _getArgUint8(uint256 argOffset) internal pure returns (uint8 arg) {
uint256 offset = _getImmutableArgsOffset();
assembly {
arg := shr(0xf8, calldataload(add(offset, argOffset)))
}
}
function _getImmutableArgsOffset() internal pure returns (uint256 offset) {
assembly {
offset := sub(
calldatasize(),
add(shr(240, calldataload(sub(calldatasize(), 2))), 2)
)
}
}
}
文件 8 的 48：ClonesWithImmutableArgs.sol
pragma solidity ^0.8.4;
library ClonesWithImmutableArgs {
error CreateFail();
function clone(address implementation, bytes memory data)
internal
returns (address instance)
{
unchecked {
uint256 extraLength = data.length + 2;
uint256 creationSize = 0x43 + extraLength;
uint256 runSize = creationSize - 11;
uint256 dataPtr;
uint256 ptr;
assembly {
ptr := mload(0x40)
mstore(
ptr,
0x3d61000000000000000000000000000000000000000000000000000000000000
)
mstore(add(ptr, 0x02), shl(240, runSize))
mstore(
add(ptr, 0x04),
0x80600b3d3981f300000000000000000000000000000000000000000000000000
)
mstore(
add(ptr, 0x0b),
0x363d3d3761000000000000000000000000000000000000000000000000000000
)
mstore(add(ptr, 0x10), shl(240, extraLength))
mstore(
add(ptr, 0x12),
0x603836393d3d3d36610000000000000000000000000000000000000000000000
)
mstore(add(ptr, 0x1b), shl(240, extraLength))
mstore(
add(ptr, 0x1d),
0x013d730000000000000000000000000000000000000000000000000000000000
)
mstore(add(ptr, 0x20), shl(0x60, implementation))
mstore(
add(ptr, 0x34),
0x5af43d82803e903d91603657fd5bf30000000000000000000000000000000000
)
}
extraLength -= 2;
uint256 counter = extraLength;
uint256 copyPtr = ptr + 0x43;
assembly {
dataPtr := add(data, 32)
}
for (; counter >= 32; counter -= 32) {
assembly {
mstore(copyPtr, mload(dataPtr))
}
copyPtr += 32;
dataPtr += 32;
}
uint256 mask = ~(256**(32 - counter) - 1);
assembly {
mstore(copyPtr, and(mload(dataPtr), mask))
}
copyPtr += counter;
assembly {
mstore(copyPtr, shl(240, extraLength))
}
assembly {
instance := create(0, ptr, creationSize)
}
if (instance == address(0)) {
revert CreateFail();
}
}
}
}
文件 9 的 48：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 10 的 48：ContextUpgradeable.sol
pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
uint256[50] private __gap;
}
文件 11 的 48：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 12 的 48：ERC165Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
文件 13 的 48：EnumerableSet.sol
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 14 的 48：EnumerableSetUpgradeable.sol
pragma solidity ^0.8.0;
library EnumerableSetUpgradeable {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 15 的 48：Errors.sol
pragma solidity >=0.8.18;
library Errors {
error NameEmpty();
error AddressEmpty();
error RegistryNameFound(bytes32 name);
error RegistryNameNotFound(bytes32 name);
error RegistryAddressNotFound(address registryAddress);
error RegistryNameVersionNotFound(bytes32 name, uint256 version);
error DuplicateRegistryAddress(address registryAddress);
error ZeroAddress();
error ZeroAmount();
error InvalidRewardSplit();
error TreasuryPctTooHigh();
error PerpetualLockEnabled();
error PerpetualLockDisabled();
error SwapAndLockNotSet();
error GaugeRewardsAlreadyAdded();
error GaugeRewardsNotYetAdded();
error ExecutionNotAllowed();
error ExecutionFailed();
error CoveYfiRewardForwarderNotSet();
error RescueNotAllowed();
error PreviousRewardsPeriodNotCompleted();
error OnlyStakingDelegateCanUpdateUserBalance();
error OnlyStakingDelegateCanAddStakingToken();
error OnlyRewardDistributorCanNotifyRewardAmount();
error StakingTokenAlreadyAdded();
error StakingTokenNotAdded();
error RewardRateTooLow();
error RewardDurationCannotBeZero();
error SlippageTooHigh();
error InvalidTokensReceived();
error InvalidFromToken(address intendedFromToken, address actualFromToken);
error InvalidToToken(address intendedToToken, address actualToToken);
error ExpectedAmountZero();
error InvalidSwapParams();
error SameAddress();
error OnlyMintingEnabled();
error ZeroEthTransfer();
error EthTransferFailed();
error ZeroTokenTransfer();
error NotAuthorized();
error CannotRescueRewardToken();
error InvalidArrayLength();
error PriceFeedOutdated();
error PriceFeedIncorrectRound();
error PriceFeedReturnedZeroPrice();
error NoDYfiToRedeem();
error CallerRewardEthTransferFailed();
error GaugeAlreadyDeployed();
error GaugeNotDeployed();
error InvalidLPToken();
error LPTokenNotAdded();
error LPTokenDoesNotMatchPoolId();
error InsufficientBalance();
error LPTokenAlreadyAdded();
error RewardRateTooHigh();
error InsufficientShares();
error InvalidTo();
error InsufficientGas();
error TakeAwayNotEnoughBalance();
error StrategyNotAddedToVault();
error TransferNotAllowedYet();
error CannotBeBothSenderAndReceiver();
error UnpauseTooEarly();
error PausePeriodTooLong();
error MintingAllowedTooEarly();
error InflationTooLarge();
error AccessControlEnumerableUnauthorizedAccount(address account, bytes32 neededRole);
error Unauthorized();
error ExpectedPause();
error AddressNotContract();
}
文件 16 的 48：GaugeRewardReceiver.sol
pragma solidity 0.8.18;
import { Clone } from "lib/clones-with-immutable-args/src/Clone.sol";
import { IGauge } from "src/interfaces/deps/yearn/veYFI/IGauge.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { StakingDelegateRewards } from "src/StakingDelegateRewards.sol";
import { AccessControlEnumerableUpgradeable } from
"@openzeppelin-upgradeable/contracts/access/AccessControlEnumerableUpgradeable.sol";
import { Rescuable } from "src/Rescuable.sol";
import { ReentrancyGuardUpgradeable } from "@openzeppelin-upgradeable/contracts/security/ReentrancyGuardUpgradeable.sol";
import { Errors } from "src/libraries/Errors.sol";
import { IYearnStakingDelegate } from "src/interfaces/IYearnStakingDelegate.sol";
contract GaugeRewardReceiver is Clone, Rescuable, ReentrancyGuardUpgradeable, AccessControlEnumerableUpgradeable {
using SafeERC20 for IERC20;
constructor() payable {
_disableInitializers();
}
function initialize(address admin_) external initializer {
__ReentrancyGuard_init();
_grantRole(DEFAULT_ADMIN_ROLE, admin_);
IERC20(rewardToken()).forceApprove(stakingDelegateRewards(), type(uint256).max);
}
function harvest(
address swapAndLock,
address treasury,
address coveYfiRewardForwarder,
IYearnStakingDelegate.RewardSplit calldata rewardSplit
)
external
nonReentrant
returns (uint256)
{
if (msg.sender != stakingDelegate()) {
revert Errors.NotAuthorized();
}
if (rewardSplit.treasury + rewardSplit.coveYfi + rewardSplit.user + rewardSplit.lock != 1e18) {
revert Errors.InvalidRewardSplit();
}
IGauge(gauge()).getReward(stakingDelegate());
uint256 totalRewardsAmount = IERC20(rewardToken()).balanceOf(address(this));
uint256 treasuryAmount = totalRewardsAmount * uint256(rewardSplit.treasury) / 1e18;
uint256 coveYfiAmount = totalRewardsAmount * uint256(rewardSplit.coveYfi) / 1e18;
uint256 swapAndLockAmount = totalRewardsAmount * uint256(rewardSplit.lock) / 1e18;
uint256 userAmount = totalRewardsAmount - swapAndLockAmount - treasuryAmount - coveYfiAmount;
if (rewardSplit.treasury != 0) {
IERC20(rewardToken()).safeTransfer(treasury, treasuryAmount);
}
if (coveYfiAmount != 0) {
IERC20(rewardToken()).safeTransfer(coveYfiRewardForwarder, coveYfiAmount);
}
if (swapAndLockAmount != 0) {
IERC20(rewardToken()).safeTransfer(swapAndLock, swapAndLockAmount);
}
if (userAmount != 0) {
StakingDelegateRewards(stakingDelegateRewards()).notifyRewardAmount(gauge(), userAmount);
}
return totalRewardsAmount;
}
function rescue(IERC20 token, address to, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) {
if (address(token) == rewardToken()) {
revert Errors.CannotRescueRewardToken();
}
_rescue(token, to, amount);
}
function stakingDelegate() public pure returns (address) {
return _getArgAddress(0);
}
function gauge() public pure returns (address) {
return _getArgAddress(20);
}
function rewardToken() public pure returns (address) {
return _getArgAddress(40);
}
function stakingDelegateRewards() public pure returns (address) {
return _getArgAddress(60);
}
}
文件 17 的 48：IAccessControl.sol
pragma solidity ^0.8.0;
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
文件 18 的 48：IAccessControlEnumerable.sol
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
interface IAccessControlEnumerable is IAccessControl {
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}
文件 19 的 48：IAccessControlEnumerableUpgradeable.sol
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
interface IAccessControlEnumerableUpgradeable is IAccessControlUpgradeable {
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}
文件 20 的 48：IAccessControlUpgradeable.sol
pragma solidity ^0.8.0;
interface IAccessControlUpgradeable {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
文件 21 的 48：IBaseGauge.sol
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IBaseGauge {
function queueNewRewards(uint256 _amount) external returns (bool);
function earned(address _account) external view returns (uint256);
}
文件 22 的 48：IDYfiRewardPool.sol
pragma solidity ^0.8.18;
interface IDYfiRewardPool {
function claim() external returns (uint256);
}
文件 23 的 48：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 24 的 48：IERC165Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 25 的 48：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 26 的 48：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 27 的 48：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 28 的 48：IERC4626.sol
pragma solidity ^0.8.0;
import "../token/ERC20/IERC20.sol";
import "../token/ERC20/extensions/IERC20Metadata.sol";
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
function asset() external view returns (address assetTokenAddress);
function totalAssets() external view returns (uint256 totalManagedAssets);
function convertToShares(uint256 assets) external view returns (uint256 shares);
function convertToAssets(uint256 shares) external view returns (uint256 assets);
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
function previewDeposit(uint256 assets) external view returns (uint256 shares);
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
function maxMint(address receiver) external view returns (uint256 maxShares);
function previewMint(uint256 shares) external view returns (uint256 assets);
function mint(uint256 shares, address receiver) external returns (uint256 assets);
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
function maxRedeem(address owner) external view returns (uint256 maxShares);
function previewRedeem(uint256 shares) external view returns (uint256 assets);
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}
文件 29 的 48：IGauge.sol
pragma solidity ^0.8.18;
import "./IBaseGauge.sol";
import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";
interface IGauge is IBaseGauge, IERC4626 {
function initialize(address _stakingToken, address _owner) external;
function boostedBalanceOf(address _account) external view returns (uint256);
function getReward(address _account) external returns (bool);
function setRecipient(address _recipient) external;
}
文件 30 的 48：ISnapshotDelegateRegistry.sol
pragma solidity ^0.8.18;
interface ISnapshotDelegateRegistry {
function setDelegate(bytes32 id, address delegate) external;
function delegation(address account, bytes32 id) external view returns (address);
}
文件 31 的 48：IStakingDelegateRewards.sol
pragma solidity ^0.8.18;
import { IAccessControlEnumerable } from "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
interface IStakingDelegateRewards is IAccessControlEnumerable {
function getReward(address stakingToken) external;
function setRewardReceiver(address receiver) external;
}
文件 32 的 48：IVotingYFI.sol
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IVotingYFI is IERC20 {
event ModifyLock(address indexed sender, address indexed user, uint256 amount, uint256 locktime, uint256 ts);
event Withdraw(address indexed user, uint256 amount, uint256 ts);
event Penalty(address indexed user, uint256 amount, uint256 ts);
event Supply(uint256 oldSupply, uint256 newSupply, uint256 ts);
struct LockedBalance {
uint256 amount;
uint256 end;
}
struct Withdrawn {
uint256 amount;
uint256 penalty;
}
struct Point {
int128 bias;
int128 slope;
uint256 ts;
uint256 blk;
}
function totalSupply() external view returns (uint256);
function locked(address _user) external view returns (LockedBalance memory);
function modify_lock(
uint256 _amount,
uint256 _unlock_time,
address _user
)
external
returns (LockedBalance memory);
function withdraw() external returns (Withdrawn memory);
function point_history(address user, uint256 epoch) external view returns (Point memory);
}
文件 33 的 48：IYearnStakingDelegate.sol
pragma solidity ^0.8.18;
import { IVotingYFI } from "./deps/yearn/veYFI/IVotingYFI.sol";
interface IYearnStakingDelegate {
struct RewardSplit {
uint64 treasury;
uint64 coveYfi;
uint64 user;
uint64 lock;
}
struct ExitRewardSplit {
uint128 treasury;
uint128 coveYfi;
}
struct BoostRewardSplit {
uint128 treasury;
uint128 coveYfi;
}
function deposit(address gauge, uint256 amount) external;
function withdraw(address gauge, uint256 amount) external;
function withdraw(address gauge, uint256 amount, address receiver) external;
function lockYfi(uint256 amount) external returns (IVotingYFI.LockedBalance memory);
function harvest(address vault) external returns (uint256);
function setCoveYfiRewardForwarder(address forwarder) external;
function setGaugeRewardSplit(
address gauge,
uint64 treasuryPct,
uint64 coveYfiPct,
uint64 userPct,
uint64 veYfiPct
)
external;
function setBoostRewardSplit(uint128 treasuryPct, uint128 coveYfiPct) external;
function setExitRewardSplit(uint128 treasuryPct, uint128 coveYfiPct) external;
function setSwapAndLock(address swapAndLock) external;
function balanceOf(address user, address gauge) external view returns (uint256);
function totalDeposited(address gauge) external view returns (uint256);
function depositLimit(address gauge) external view returns (uint256);
function availableDepositLimit(address gauge) external view returns (uint256);
function gaugeStakingRewards(address gauge) external view returns (address);
function gaugeRewardReceivers(address gauge) external view returns (address);
function getGaugeRewardSplit(address gauge) external view returns (RewardSplit memory);
function getBoostRewardSplit() external view returns (BoostRewardSplit memory);
function getExitRewardSplit() external view returns (ExitRewardSplit memory);
function treasury() external view returns (address);
}
文件 34 的 48：IYfiRewardPool.sol
pragma solidity ^0.8.18;
interface IYfiRewardPool {
event CheckpointToken(uint256 time, uint256 tokens);
function claim() external returns (uint256);
function checkpoint_token() external;
function checkpoint_total_supply() external;
}
文件 35 的 48：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
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);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
文件 36 的 48：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
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;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
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);
}
}
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);
}
}
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;
}
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);
}
}
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;
}
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);
}
}
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;
}
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);
}
}
}
文件 37 的 48：MathUpgradeable.sol
pragma solidity ^0.8.0;
library MathUpgradeable {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
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;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
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);
}
}
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);
}
}
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;
}
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);
}
}
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;
}
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);
}
}
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;
}
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);
}
}
}
文件 38 的 48：Pausable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
文件 39 的 48：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
文件 40 的 48：ReentrancyGuardUpgradeable.sol
pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";
abstract contract ReentrancyGuardUpgradeable is Initializable {
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;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
uint256[49] private __gap;
}
文件 41 的 48：Rescuable.sol
pragma solidity 0.8.18;
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Errors } from "src/libraries/Errors.sol";
contract Rescuable {
using SafeERC20 for IERC20;
function _rescue(IERC20 token, address to, uint256 balance) internal {
if (address(token) == address(0)) {
uint256 totalBalance = address(this).balance;
balance = balance != 0 ? Math.min(totalBalance, balance) : totalBalance;
if (balance != 0) {
(bool success,) = to.call{ value: balance }("");
if (!success) revert Errors.EthTransferFailed();
return;
}
revert Errors.ZeroEthTransfer();
} else {
uint256 totalBalance = token.balanceOf(address(this));
balance = balance != 0 ? Math.min(totalBalance, balance) : totalBalance;
if (balance != 0) {
token.safeTransfer(to, balance);
return;
}
revert Errors.ZeroTokenTransfer();
}
}
}
文件 42 的 48：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
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));
}
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));
}
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));
}
}
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);
}
}
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");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
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");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 43 的 48：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 44 的 48：SignedMathUpgradeable.sol
pragma solidity ^0.8.0;
library SignedMathUpgradeable {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 45 的 48：StakingDelegateRewards.sol
pragma solidity 0.8.18;
import { AccessControlEnumerable } from "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Errors } from "src/libraries/Errors.sol";
import { IStakingDelegateRewards } from "src/interfaces/IStakingDelegateRewards.sol";
import { IYearnStakingDelegate } from "src/interfaces/IYearnStakingDelegate.sol";
contract StakingDelegateRewards is IStakingDelegateRewards, AccessControlEnumerable {
using SafeERC20 for IERC20;
uint256 private constant _DEFAULT_DURATION = 7 days;
bytes32 public constant TIMELOCK_ROLE = keccak256("TIMELOCK_ROLE");
address private immutable _REWARDS_TOKEN;
address private immutable _STAKING_DELEGATE;
mapping(address => uint256) public periodFinish;
mapping(address => uint256) public rewardRate;
mapping(address => uint256) public rewardsDuration;
mapping(address => uint256) public lastUpdateTime;
mapping(address => uint256) public rewardPerTokenStored;
mapping(address => uint256) public leftOver;
mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
mapping(address => mapping(address => uint256)) public rewards;
mapping(address => address) public rewardDistributors;
mapping(address => address) public rewardReceiver;
event RewardAdded(
address indexed stakingToken, uint256 rewardAmount, uint256 rewardRate, uint256 start, uint256 end
);
event StakingTokenAdded(address indexed stakingToken, address rewardDistributioner);
event UserBalanceUpdated(address indexed user, address indexed stakingToken);
event RewardPaid(address indexed user, address indexed stakingToken, uint256 reward, address receiver);
event RewardsDurationUpdated(address indexed stakingToken, uint256 newDuration);
event Recovered(address token, uint256 amount);
event RewardReceiverSet(address indexed user, address receiver);
constructor(address rewardsToken_, address stakingDelegate_, address admin, address timeLock) payable {
if (rewardsToken_ == address(0) || stakingDelegate_ == address(0)) {
revert Errors.ZeroAddress();
}
_grantRole(DEFAULT_ADMIN_ROLE, admin);
_grantRole(TIMELOCK_ROLE, timeLock);
_setRoleAdmin(TIMELOCK_ROLE, TIMELOCK_ROLE);
_REWARDS_TOKEN = rewardsToken_;
_STAKING_DELEGATE = stakingDelegate_;
}
function getReward(address stakingToken) external {
_getReward(msg.sender, stakingToken);
}
function getReward(address user, address stakingToken) external {
_getReward(user, stakingToken);
}
function setRewardReceiver(address receiver) external {
rewardReceiver[msg.sender] = receiver;
emit RewardReceiverSet(msg.sender, receiver);
}
function notifyRewardAmount(address stakingToken, uint256 reward) external {
if (msg.sender != rewardDistributors[stakingToken]) {
revert Errors.OnlyRewardDistributorCanNotifyRewardAmount();
}
_updateReward(address(0), stakingToken);
uint256 periodFinish_ = periodFinish[stakingToken];
uint256 rewardDuration_ = rewardsDuration[stakingToken];
uint256 leftOverRewards = leftOver[stakingToken];
if (block.timestamp < periodFinish_) {
uint256 remainingTime = periodFinish_ - block.timestamp;
leftOverRewards = leftOverRewards + (remainingTime * rewardRate[stakingToken]);
}
uint256 newRewardAmount = reward + leftOverRewards;
uint256 newRewardRate = newRewardAmount / rewardDuration_;
if (newRewardRate == 0) {
revert Errors.RewardRateTooLow();
}
uint256 newPeriodFinish = block.timestamp + rewardDuration_;
emit RewardAdded(stakingToken, reward, newRewardRate, block.timestamp, newPeriodFinish);
rewardRate[stakingToken] = newRewardRate;
lastUpdateTime[stakingToken] = block.timestamp;
periodFinish[stakingToken] = newPeriodFinish;
leftOver[stakingToken] = newRewardAmount % rewardDuration_;
IERC20(_REWARDS_TOKEN).safeTransferFrom(msg.sender, address(this), reward);
}
function updateUserBalance(
address user,
address stakingToken,
uint256 currentUserBalance,
uint256 currentTotalDeposited
)
external
{
if (msg.sender != _STAKING_DELEGATE) {
revert Errors.OnlyStakingDelegateCanUpdateUserBalance();
}
_updateReward(user, stakingToken, currentUserBalance, currentTotalDeposited);
emit UserBalanceUpdated(user, stakingToken);
}
function addStakingToken(address stakingToken, address rewardDistributioner) external {
if (msg.sender != _STAKING_DELEGATE) {
revert Errors.OnlyStakingDelegateCanAddStakingToken();
}
if (rewardDistributors[stakingToken] != address(0)) {
revert Errors.StakingTokenAlreadyAdded();
}
rewardDistributors[stakingToken] = rewardDistributioner;
rewardsDuration[stakingToken] = _DEFAULT_DURATION;
emit StakingTokenAdded(stakingToken, rewardDistributioner);
emit RewardsDurationUpdated(stakingToken, _DEFAULT_DURATION);
}
function setRewardsDuration(address stakingToken, uint256 rewardsDuration_) external onlyRole(TIMELOCK_ROLE) {
if (rewardsDuration_ == 0) {
revert Errors.RewardDurationCannotBeZero();
}
if (rewardsDuration[stakingToken] == 0) {
revert Errors.StakingTokenNotAdded();
}
if (block.timestamp <= periodFinish[stakingToken]) {
revert Errors.PreviousRewardsPeriodNotCompleted();
}
rewardsDuration[stakingToken] = rewardsDuration_;
emit RewardsDurationUpdated(stakingToken, rewardsDuration_);
}
function recoverERC20(
address tokenAddress,
address to,
uint256 tokenAmount
)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
if (tokenAddress == _REWARDS_TOKEN || rewardDistributors[tokenAddress] != address(0)) {
revert Errors.RescueNotAllowed();
}
emit Recovered(tokenAddress, tokenAmount);
IERC20(tokenAddress).safeTransfer(to, tokenAmount);
}
function getRewardForDuration(address stakingToken) external view returns (uint256) {
return rewardRate[stakingToken] * rewardsDuration[stakingToken];
}
function rewardToken() external view returns (address) {
return _REWARDS_TOKEN;
}
function stakingDelegate() external view returns (address) {
return _STAKING_DELEGATE;
}
function lastTimeRewardApplicable(address stakingToken) public view returns (uint256) {
uint256 finish = periodFinish[stakingToken];
return block.timestamp < finish ? block.timestamp : finish;
}
function rewardPerToken(address stakingToken) external view returns (uint256) {
return _rewardPerToken(stakingToken, IYearnStakingDelegate(_STAKING_DELEGATE).totalDeposited(stakingToken));
}
function _rewardPerToken(address stakingToken, uint256 currentTotalDeposited) internal view returns (uint256) {
if (currentTotalDeposited == 0) {
return rewardPerTokenStored[stakingToken];
}
return rewardPerTokenStored[stakingToken]
+ (lastTimeRewardApplicable(stakingToken) - lastUpdateTime[stakingToken]) * rewardRate[stakingToken] * 1e18
/ currentTotalDeposited;
}
function earned(address account, address stakingToken) external view returns (uint256) {
return _earned(
account,
stakingToken,
IYearnStakingDelegate(_STAKING_DELEGATE).balanceOf(account, stakingToken),
_rewardPerToken(stakingToken, IYearnStakingDelegate(_STAKING_DELEGATE).totalDeposited(stakingToken))
);
}
function _earned(
address account,
address stakingToken,
uint256 userBalance,
uint256 rewardPerToken_
)
internal
view
returns (uint256)
{
return rewards[account][stakingToken]
+ (userBalance * (rewardPerToken_ - userRewardPerTokenPaid[account][stakingToken]) / 1e18);
}
function _getReward(address user, address stakingToken) internal {
_updateReward(user, stakingToken);
uint256 reward = rewards[user][stakingToken];
if (reward > 0) {
rewards[user][stakingToken] = 0;
address receiver = rewardReceiver[user];
if (receiver == address(0)) {
receiver = user;
}
emit RewardPaid(user, stakingToken, reward, receiver);
IERC20(_REWARDS_TOKEN).safeTransfer(receiver, reward);
}
}
function _updateReward(address account, address stakingToken) internal {
_updateReward(
account,
stakingToken,
IYearnStakingDelegate(_STAKING_DELEGATE).balanceOf(account, stakingToken),
IYearnStakingDelegate(_STAKING_DELEGATE).totalDeposited(stakingToken)
);
}
function _updateReward(
address account,
address stakingToken,
uint256 currentUserBalance,
uint256 currentTotalDeposited
)
internal
{
uint256 rewardPerToken_ = _rewardPerToken(stakingToken, currentTotalDeposited);
rewardPerTokenStored[stakingToken] = rewardPerToken_;
lastUpdateTime[stakingToken] = lastTimeRewardApplicable(stakingToken);
if (account != address(0)) {
rewards[account][stakingToken] = _earned(account, stakingToken, currentUserBalance, rewardPerToken_);
userRewardPerTokenPaid[account][stakingToken] = rewardPerToken_;
}
}
}
文件 46 的 48：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
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);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 47 的 48：StringsUpgradeable.sol
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMathUpgradeable.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.log256(value) + 1);
}
}
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);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 48 的 48：YearnStakingDelegate.sol
pragma solidity 0.8.18;
import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IVotingYFI } from "src/interfaces/deps/yearn/veYFI/IVotingYFI.sol";
import { IDYfiRewardPool } from "src/interfaces/deps/yearn/veYFI/IDYfiRewardPool.sol";
import { IYfiRewardPool } from "src/interfaces/deps/yearn/veYFI/IYfiRewardPool.sol";
import { ISnapshotDelegateRegistry } from "src/interfaces/deps/snapshot/ISnapshotDelegateRegistry.sol";
import { IGauge } from "src/interfaces/deps/yearn/veYFI/IGauge.sol";
import { AccessControlEnumerable } from "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import { Errors } from "src/libraries/Errors.sol";
import { Rescuable } from "src/Rescuable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { Pausable } from "@openzeppelin/contracts/security/Pausable.sol";
import { ClonesWithImmutableArgs } from "lib/clones-with-immutable-args/src/ClonesWithImmutableArgs.sol";
import { GaugeRewardReceiver } from "src/GaugeRewardReceiver.sol";
import { StakingDelegateRewards } from "src/StakingDelegateRewards.sol";
import { IYearnStakingDelegate } from "src/interfaces/IYearnStakingDelegate.sol";
contract YearnStakingDelegate is
IYearnStakingDelegate,
AccessControlEnumerable,
ReentrancyGuard,
Rescuable,
Pausable
{
using SafeERC20 for IERC20;
using ClonesWithImmutableArgs for address;
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant TIMELOCK_ROLE = keccak256("TIMELOCK_ROLE");
bytes32 public constant DEPOSITOR_ROLE = keccak256("DEPOSITOR_ROLE");
address private constant _YFI_REWARD_POOL = 0xb287a1964AEE422911c7b8409f5E5A273c1412fA;
address private constant _DYFI_REWARD_POOL = 0x2391Fc8f5E417526338F5aa3968b1851C16D894E;
address private constant _YFI = 0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e;
address private constant _D_YFI = 0x41252E8691e964f7DE35156B68493bAb6797a275;
address private constant _VE_YFI = 0x90c1f9220d90d3966FbeE24045EDd73E1d588aD5;
address private constant _SNAPSHOT_DELEGATE_REGISTRY = 0x469788fE6E9E9681C6ebF3bF78e7Fd26Fc015446;
uint256 private constant _MAX_TREASURY_PCT = 0.2e18;
address private immutable _GAUGE_REWARD_RECEIVER_IMPL;
mapping(address => address) public gaugeStakingRewards;
mapping(address => address) public gaugeRewardReceivers;
mapping(address => mapping(address => uint256)) public balanceOf;
mapping(address => uint256) public totalDeposited;
mapping(address => uint256) public depositLimit;
mapping(address => bool) public blockedTargets;
mapping(address => RewardSplit) private _gaugeRewardSplit;
address private _treasury;
bool private _shouldPerpetuallyLock;
address private _swapAndLock;
address private _coveYfiRewardForwarder;
BoostRewardSplit private _boostRewardSplit;
ExitRewardSplit private _exitRewardSplit;
event LockYfi(address indexed sender, uint256 amount);
event GaugeRewardsSet(address indexed gauge, address stakingRewardsContract, address receiver);
event PerpetualLockSet(bool shouldLock);
event GaugeRewardSplitSet(address indexed gauge, RewardSplit split);
event BoostRewardSplitSet(uint128 treasuryPct, uint128 coveYfiPct);
event ExitRewardSplitSet(uint128 treasuryPct, uint128 coveYfiPct);
event DepositLimitSet(address indexed gaugeToken, uint256 limit);
event SwapAndLockSet(address swapAndLockContract);
event TreasurySet(address newTreasury);
event CoveYfiRewardForwarderSet(address forwarder);
event Deposit(address indexed sender, address indexed gauge, uint256 amount, uint256 newTotalDeposited);
event Withdraw(address indexed sender, address indexed gauge, uint256 amount, uint256 newTotalDeposited);
event StakingDelegateRewardsFaulty(
address stakingDelegateRewards,
address user,
address gauge,
uint256 currentUserBalance,
uint256 currentTotalDeposited
);
constructor(
address gaugeRewardReceiverImpl,
address treasury_,
address admin,
address pauser,
address timelock
)
payable
{
if (
gaugeRewardReceiverImpl == address(0) || treasury_ == address(0) || admin == address(0)
|| pauser == address(0) || timelock == address(0)
) {
revert Errors.ZeroAddress();
}
_setTreasury(treasury_);
_setPerpetualLock(true);
_setBoostRewardSplit(0, 1e18);
_setExitRewardSplit(0, 1e18);
_GAUGE_REWARD_RECEIVER_IMPL = gaugeRewardReceiverImpl;
blockedTargets[_YFI] = true;
blockedTargets[_D_YFI] = true;
blockedTargets[_VE_YFI] = true;
blockedTargets[_YFI_REWARD_POOL] = true;
blockedTargets[_DYFI_REWARD_POOL] = true;
blockedTargets[_SNAPSHOT_DELEGATE_REGISTRY] = true;
blockedTargets[_GAUGE_REWARD_RECEIVER_IMPL] = true;
_setRoleAdmin(TIMELOCK_ROLE, TIMELOCK_ROLE);
_setRoleAdmin(DEPOSITOR_ROLE, TIMELOCK_ROLE);
_grantRole(DEFAULT_ADMIN_ROLE, admin);
_grantRole(TIMELOCK_ROLE, timelock);
_grantRole(PAUSER_ROLE, pauser);
IERC20(_YFI).forceApprove(_VE_YFI, type(uint256).max);
}
function deposit(address gauge, uint256 amount) external onlyRole(DEPOSITOR_ROLE) whenNotPaused {
if (amount == 0) {
revert Errors.ZeroAmount();
}
address stakingDelegateReward = gaugeStakingRewards[gauge];
if (stakingDelegateReward == address(0)) {
revert Errors.GaugeRewardsNotYetAdded();
}
uint256 currentTotalDeposited = totalDeposited[gauge];
uint256 currentUserBalance = balanceOf[msg.sender][gauge];
uint256 newTotalDeposited = currentTotalDeposited + amount;
balanceOf[msg.sender][gauge] = currentUserBalance + amount;
totalDeposited[gauge] = newTotalDeposited;
emit Deposit(msg.sender, gauge, amount, newTotalDeposited);
_checkpointUserBalance(stakingDelegateReward, gauge, msg.sender, currentUserBalance, currentTotalDeposited);
IERC20(gauge).safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(address gauge, uint256 amount, address receiver) external {
_withdraw(gauge, amount, receiver);
}
function withdraw(address gauge, uint256 amount) external {
_withdraw(gauge, amount, msg.sender);
}
function _withdraw(address gauge, uint256 amount, address receiver) internal {
if (amount == 0) {
revert Errors.ZeroAmount();
}
uint256 currentUserBalance = balanceOf[msg.sender][gauge];
uint256 currentTotalDeposited = totalDeposited[gauge];
uint256 newTotalDeposited = currentTotalDeposited - amount;
balanceOf[msg.sender][gauge] = currentUserBalance - amount;
totalDeposited[gauge] = newTotalDeposited;
emit Withdraw(msg.sender, gauge, amount, newTotalDeposited);
_checkpointUserBalance(gaugeStakingRewards[gauge], gauge, msg.sender, currentUserBalance, currentTotalDeposited);
IERC20(gauge).safeTransfer(receiver, amount);
}
function harvest(address gauge) external returns (uint256) {
address swapAndLockContract = _swapAndLock;
if (swapAndLockContract == address(0)) {
revert Errors.SwapAndLockNotSet();
}
address gaugeRewardReceiver = gaugeRewardReceivers[gauge];
if (gaugeRewardReceiver == address(0)) {
revert Errors.GaugeRewardsNotYetAdded();
}
address rewardForwarder = _coveYfiRewardForwarder;
if (rewardForwarder == address(0)) {
revert Errors.CoveYfiRewardForwarderNotSet();
}
return GaugeRewardReceiver(gaugeRewardReceiver).harvest(
swapAndLockContract, _treasury, rewardForwarder, _gaugeRewardSplit[gauge]
);
}
function claimBoostRewards() external {
address rewardForwarder = _coveYfiRewardForwarder;
if (rewardForwarder == address(0)) {
revert Errors.CoveYfiRewardForwarderNotSet();
}
IDYfiRewardPool(_DYFI_REWARD_POOL).claim();
uint256 balance = IERC20(_D_YFI).balanceOf(address(this));
uint256 coveYfiAmount = (balance * _boostRewardSplit.coveYfi) / 1e18;
IERC20(_D_YFI).safeTransfer(rewardForwarder, coveYfiAmount);
IERC20(_D_YFI).safeTransfer(_treasury, balance - coveYfiAmount);
}
function claimExitRewards() external {
address rewardForwarder = _coveYfiRewardForwarder;
if (rewardForwarder == address(0)) {
revert Errors.CoveYfiRewardForwarderNotSet();
}
IYfiRewardPool(_YFI_REWARD_POOL).claim();
uint256 balance = IERC20(_YFI).balanceOf(address(this));
uint256 coveYfiAmount = (balance * _exitRewardSplit.coveYfi) / 1e18;
IERC20(_YFI).safeTransfer(rewardForwarder, coveYfiAmount);
IERC20(_YFI).safeTransfer(_treasury, balance - coveYfiAmount);
}
function lockYfi(uint256 amount) external whenNotPaused returns (IVotingYFI.LockedBalance memory) {
if (amount == 0) {
revert Errors.ZeroAmount();
}
if (!_shouldPerpetuallyLock) {
revert Errors.PerpetualLockDisabled();
}
emit LockYfi(msg.sender, amount);
IERC20(_YFI).safeTransferFrom(msg.sender, address(this), amount);
return IVotingYFI(_VE_YFI).modify_lock(amount, block.timestamp + 4 * 365 days + 4 weeks, address(this));
}
function setCoveYfiRewardForwarder(address forwarder) external onlyRole(TIMELOCK_ROLE) {
if (forwarder == address(0)) {
revert Errors.ZeroAddress();
}
_setCoveYfiRewardForwarder(forwarder);
}
function setTreasury(address treasury_) external onlyRole(TIMELOCK_ROLE) {
if (treasury_ == address(0)) {
revert Errors.ZeroAddress();
}
_setTreasury(treasury_);
}
function setSwapAndLock(address newSwapAndLock) external onlyRole(TIMELOCK_ROLE) {
if (newSwapAndLock == address(0)) {
revert Errors.ZeroAddress();
}
_swapAndLock = newSwapAndLock;
emit SwapAndLockSet(newSwapAndLock);
}
function setGaugeRewardSplit(
address gauge,
uint64 treasuryPct,
uint64 coveYfiPct,
uint64 userPct,
uint64 veYfiPct
)
external
onlyRole(TIMELOCK_ROLE)
{
_setGaugeRewardSplit(gauge, treasuryPct, coveYfiPct, userPct, veYfiPct);
}
function setBoostRewardSplit(uint128 treasuryPct, uint128 coveYfiPct) external onlyRole(TIMELOCK_ROLE) {
_setBoostRewardSplit(treasuryPct, coveYfiPct);
}
function setExitRewardSplit(uint128 treasuryPct, uint128 coveYfiPct) external onlyRole(TIMELOCK_ROLE) {
_setExitRewardSplit(treasuryPct, coveYfiPct);
}
function setDepositLimit(address gaugeToken, uint256 limit) external onlyRole(TIMELOCK_ROLE) {
emit DepositLimitSet(gaugeToken, limit);
depositLimit[gaugeToken] = limit;
}
function setSnapshotDelegate(bytes32 id, address delegate) external onlyRole(TIMELOCK_ROLE) {
if (delegate == address(0)) {
revert Errors.ZeroAddress();
}
ISnapshotDelegateRegistry(_SNAPSHOT_DELEGATE_REGISTRY).setDelegate(id, delegate);
}
function addGaugeRewards(
address gauge,
address stakingDelegateRewards
)
external
nonReentrant
onlyRole(DEFAULT_ADMIN_ROLE)
{
if (gauge == address(0) || stakingDelegateRewards == address(0)) {
revert Errors.ZeroAddress();
}
if (gaugeStakingRewards[gauge] != address(0)) {
revert Errors.GaugeRewardsAlreadyAdded();
}
_setGaugeRewardSplit(gauge, 0, 0, 1e18, 0);
_setGaugeRewards(gauge, stakingDelegateRewards);
}
function updateGaugeRewards(
address gauge,
address stakingDelegateRewards
)
external
nonReentrant
onlyRole(TIMELOCK_ROLE)
{
if (gauge == address(0) || stakingDelegateRewards == address(0)) {
revert Errors.ZeroAddress();
}
address previousStakingDelegateRewards = gaugeStakingRewards[gauge];
if (previousStakingDelegateRewards == address(0)) {
revert Errors.GaugeRewardsNotYetAdded();
}
if (previousStakingDelegateRewards == stakingDelegateRewards) {
revert Errors.GaugeRewardsAlreadyAdded();
}
_setGaugeRewards(gauge, stakingDelegateRewards);
}
function setPerpetualLock(bool lock) external onlyRole(TIMELOCK_ROLE) {
_setPerpetualLock(lock);
}
function earlyUnlock() external onlyRole(TIMELOCK_ROLE) {
if (_shouldPerpetuallyLock) {
revert Errors.PerpetualLockEnabled();
}
IVotingYFI.Withdrawn memory withdrawn = IVotingYFI(_VE_YFI).withdraw();
IERC20(_YFI).safeTransfer(_treasury, withdrawn.amount);
}
function pause() external {
if (!(hasRole(PAUSER_ROLE, msg.sender) || hasRole(DEFAULT_ADMIN_ROLE, msg.sender))) {
revert Errors.Unauthorized();
}
_pause();
}
function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) {
_unpause();
}
function execute(
address target,
bytes calldata data,
uint256 value
)
external
payable
onlyRole(TIMELOCK_ROLE)
returns (bytes memory)
{
if (blockedTargets[target]) {
revert Errors.ExecutionNotAllowed();
}
(bool success, bytes memory result) = target.call{ value: value }(data);
if (!success) {
revert Errors.ExecutionFailed();
}
return result;
}
function availableDepositLimit(address gaugeToken) external view returns (uint256) {
uint256 currentTotalDeposited = totalDeposited[gaugeToken];
uint256 currentDepositLimit = depositLimit[gaugeToken];
if (currentTotalDeposited >= currentDepositLimit) {
return 0;
}
unchecked {
return currentDepositLimit - currentTotalDeposited;
}
}
function getBoostRewardSplit() external view returns (BoostRewardSplit memory) {
return _boostRewardSplit;
}
function getExitRewardSplit() external view returns (ExitRewardSplit memory) {
return _exitRewardSplit;
}
function getGaugeRewardSplit(address gauge) external view returns (RewardSplit memory) {
return _gaugeRewardSplit[gauge];
}
function treasury() external view returns (address) {
return _treasury;
}
function coveYfiRewardForwarder() external view returns (address) {
return _coveYfiRewardForwarder;
}
function swapAndLock() external view returns (address) {
return _swapAndLock;
}
function shouldPerpetuallyLock() external view returns (bool) {
return _shouldPerpetuallyLock;
}
function yfi() external pure returns (address) {
return _YFI;
}
function dYfi() external pure returns (address) {
return _D_YFI;
}
function veYfi() external pure returns (address) {
return _VE_YFI;
}
function _setTreasury(address treasury_) internal {
_treasury = treasury_;
emit TreasurySet(treasury_);
}
function _setCoveYfiRewardForwarder(address forwarder) internal {
_coveYfiRewardForwarder = forwarder;
emit CoveYfiRewardForwarderSet(forwarder);
}
function _setGaugeRewards(address gauge, address stakingDelegateRewards) internal {
gaugeStakingRewards[gauge] = stakingDelegateRewards;
blockedTargets[gauge] = true;
blockedTargets[stakingDelegateRewards] = true;
address receiver =
_GAUGE_REWARD_RECEIVER_IMPL.clone(abi.encodePacked(address(this), gauge, _D_YFI, stakingDelegateRewards));
gaugeRewardReceivers[gauge] = receiver;
blockedTargets[receiver] = true;
emit GaugeRewardsSet(gauge, stakingDelegateRewards, receiver);
GaugeRewardReceiver(receiver).initialize(msg.sender);
IGauge(gauge).setRecipient(receiver);
StakingDelegateRewards(stakingDelegateRewards).addStakingToken(gauge, receiver);
}
function _setPerpetualLock(bool lock) internal {
_shouldPerpetuallyLock = lock;
emit PerpetualLockSet(lock);
}
function _setGaugeRewardSplit(
address gauge,
uint64 treasuryPct,
uint64 coveYfiPct,
uint64 userPct,
uint64 lockPct
)
internal
{
if (uint256(treasuryPct) + coveYfiPct + userPct + lockPct != 1e18) {
revert Errors.InvalidRewardSplit();
}
if (treasuryPct > _MAX_TREASURY_PCT) {
revert Errors.TreasuryPctTooHigh();
}
RewardSplit memory newRewardSplit =
RewardSplit({ treasury: treasuryPct, coveYfi: coveYfiPct, user: userPct, lock: lockPct });
_gaugeRewardSplit[gauge] = newRewardSplit;
emit GaugeRewardSplitSet(gauge, newRewardSplit);
}
function _setBoostRewardSplit(uint128 treasuryPct, uint128 coveYfiPct) internal {
if (uint256(treasuryPct) + coveYfiPct != 1e18) {
revert Errors.InvalidRewardSplit();
}
if (treasuryPct > _MAX_TREASURY_PCT) {
revert Errors.TreasuryPctTooHigh();
}
_boostRewardSplit = BoostRewardSplit({ treasury: treasuryPct, coveYfi: coveYfiPct });
emit BoostRewardSplitSet(treasuryPct, coveYfiPct);
}
function _setExitRewardSplit(uint128 treasuryPct, uint128 coveYfiPct) internal {
if (uint256(treasuryPct) + coveYfiPct != 1e18) {
revert Errors.InvalidRewardSplit();
}
if (treasuryPct > _MAX_TREASURY_PCT) {
revert Errors.TreasuryPctTooHigh();
}
_exitRewardSplit = ExitRewardSplit({ treasury: treasuryPct, coveYfi: coveYfiPct });
emit ExitRewardSplitSet(treasuryPct, coveYfiPct);
}
function _checkpointUserBalance(
address stakingDelegateReward,
address gauge,
address user,
uint256 userBalance,
uint256 currentTotalDeposited
)
internal
{
bytes memory data =
abi.encodeCall(StakingDelegateRewards.updateUserBalance, (user, gauge, userBalance, currentTotalDeposited));
uint256 gasBefore = gasleft();
(bool success,) = address(stakingDelegateReward).call{ gas: gasBefore }(data);
if (gasleft() <= gasBefore / 63) {
revert Errors.InsufficientGas();
}
if (!success) {
emit StakingDelegateRewardsFaulty(stakingDelegateReward, user, gauge, userBalance, currentTotalDeposited);
}
}
}
{
"compilationTarget": {
"src/YearnStakingDelegate.sol": "YearnStakingDelegate"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@crytic/properties/=lib/properties/",
":@openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":@openzeppelin/=lib/openzeppelin-contracts/",
":Yearn-ERC4626-Router/=lib/Yearn-ERC4626-Router/src/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":forge-deploy/=lib/forge-deploy/contracts/",
":forge-std/=lib/forge-std/src/",
":permit2/=lib/permit2/src/",
":script/=script/",
":solmate/=lib/permit2/lib/solmate/src/",
":src/=src/",
":test/=test/",
":tokenized-strategy/=lib/tokenized-strategy/src/",
":yearn-vaults-v3/=lib/yearn-vaults-v3/contracts/"
]
}[{"inputs":[{"internalType":"address","name":"gaugeRewardReceiverImpl","type":"address"},{"internalType":"address","name":"treasury_","type":"address"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"pauser","type":"address"},{"internalType":"address","name":"timelock","type":"address"}],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"CoveYfiRewardForwarderNotSet","type":"error"},{"inputs":[],"name":"CreateFail","type":"error"},{"inputs":[],"name":"ExecutionFailed","type":"error"},{"inputs":[],"name":"ExecutionNotAllowed","type":"error"},{"inputs":[],"name":"GaugeRewardsAlreadyAdded","type":"error"},{"inputs":[],"name":"GaugeRewardsNotYetAdded","type":"error"},{"inputs":[],"name":"InsufficientGas","type":"error"},{"inputs":[],"name":"InvalidRewardSplit","type":"error"},{"inputs":[],"name":"PerpetualLockDisabled","type":"error"},{"inputs":[],"name":"PerpetualLockEnabled","type":"error"},{"inputs":[],"name":"SwapAndLockNotSet","type":"error"},{"inputs":[],"name":"TreasuryPctTooHigh","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint128","name":"treasuryPct","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"coveYfiPct","type":"uint128"}],"name":"BoostRewardSplitSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"forwarder","type":"address"}],"name":"CoveYfiRewardForwarderSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"gauge","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalDeposited","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"gaugeToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"limit","type":"uint256"}],"name":"DepositLimitSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint128","name":"treasuryPct","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"coveYfiPct","type":"uint128"}],"name":"ExitRewardSplitSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"gauge","type":"address"},{"components":[{"internalType":"uint64","name":"treasury","type":"uint64"},{"internalType":"uint64","name":"coveYfi","type":"uint64"},{"internalType":"uint64","name":"user","type":"uint64"},{"internalType":"uint64","name":"lock","type":"uint64"}],"indexed":false,"internalType":"struct IYearnStakingDelegate.RewardSplit","name":"split","type":"tuple"}],"name":"GaugeRewardSplitSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"gauge","type":"address"},{"indexed":false,"internalType":"address","name":"stakingRewardsContract","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"}],"name":"GaugeRewardsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LockYfi","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"shouldLock","type":"bool"}],"name":"PerpetualLockSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"stakingDelegateRewards","type":"address"},{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"gauge","type":"address"},{"indexed":false,"internalType":"uint256","name":"currentUserBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentTotalDeposited","type":"uint256"}],"name":"StakingDelegateRewardsFaulty","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"swapAndLockContract","type":"address"}],"name":"SwapAndLockSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newTreasury","type":"address"}],"name":"TreasurySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"gauge","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTotalDeposited","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPOSITOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TIMELOCK_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"},{"internalType":"address","name":"stakingDelegateRewards","type":"address"}],"name":"addGaugeRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gaugeToken","type":"address"}],"name":"availableDepositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"blockedTargets","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimBoostRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimExitRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"coveYfiRewardForwarder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dYfi","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"depositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"earlyUnlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"execute","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"gaugeRewardReceivers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"gaugeStakingRewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBoostRewardSplit","outputs":[{"components":[{"internalType":"uint128","name":"treasury","type":"uint128"},{"internalType":"uint128","name":"coveYfi","type":"uint128"}],"internalType":"struct IYearnStakingDelegate.BoostRewardSplit","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getExitRewardSplit","outputs":[{"components":[{"internalType":"uint128","name":"treasury","type":"uint128"},{"internalType":"uint128","name":"coveYfi","type":"uint128"}],"internalType":"struct IYearnStakingDelegate.ExitRewardSplit","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"}],"name":"getGaugeRewardSplit","outputs":[{"components":[{"internalType":"uint64","name":"treasury","type":"uint64"},{"internalType":"uint64","name":"coveYfi","type":"uint64"},{"internalType":"uint64","name":"user","type":"uint64"},{"internalType":"uint64","name":"lock","type":"uint64"}],"internalType":"struct IYearnStakingDelegate.RewardSplit","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"}],"name":"harvest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"lockYfi","outputs":[{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"}],"internalType":"struct IVotingYFI.LockedBalance","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"treasuryPct","type":"uint128"},{"internalType":"uint128","name":"coveYfiPct","type":"uint128"}],"name":"setBoostRewardSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"setCoveYfiRewardForwarder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gaugeToken","type":"address"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"setDepositLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"treasuryPct","type":"uint128"},{"internalType":"uint128","name":"coveYfiPct","type":"uint128"}],"name":"setExitRewardSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"},{"internalType":"uint64","name":"treasuryPct","type":"uint64"},{"internalType":"uint64","name":"coveYfiPct","type":"uint64"},{"internalType":"uint64","name":"userPct","type":"uint64"},{"internalType":"uint64","name":"veYfiPct","type":"uint64"}],"name":"setGaugeRewardSplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"lock","type":"bool"}],"name":"setPerpetualLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"},{"internalType":"address","name":"delegate","type":"address"}],"name":"setSnapshotDelegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newSwapAndLock","type":"address"}],"name":"setSwapAndLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"treasury_","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shouldPerpetuallyLock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapAndLock","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalDeposited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"},{"internalType":"address","name":"stakingDelegateRewards","type":"address"}],"name":"updateGaugeRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"veYfi","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gauge","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"yfi","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"}]
