Contract Source Code:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Ownable
struct OwnableStorage {
address _owner;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
assembly {
$.slot := OwnableStorageLocation
}
}
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
function __Ownable_init(address initialOwner) internal onlyInitializing {
__Ownable_init_unchained(initialOwner);
}
function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
OwnableStorage storage $ = _getOwnableStorage();
return $._owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
OwnableStorage storage $ = _getOwnableStorage();
address oldOwner = $._owner;
$._owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../utils/introspection/IERC165.sol";
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
/**
* @dev An operation with an ERC-20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
* consider using {ReentrancyGuardTransient} instead.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be NOT_ENTERED
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
_status = ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "./utils/ContractGuard.sol";
import "./utils/ShareWrapper.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IBasisAsset.sol";
import "./interfaces/ITreasury.sol";
import "./interfaces/IBoardroom.sol";
import "./interfaces/IEscrow.sol";
import "./interfaces/IOracle.sol";
/// @title Boardroom
/// @notice This contract handles staking, reward allocation, and reward distribution for share holders.
/// It supports multi-peg rewards by maintaining a separate reward snapshot history for each peg token.
/// The contract is protected against reentrancy and is upgradeable.
contract Boardroom is IBoardroom, ShareWrapper, ContractGuard, ReentrancyGuard, OwnableUpgradeable {
using SafeERC20 for IERC20;
/* ========== DATA STRUCTURES ========== */
/// @notice Holds per-member reward data.
struct Memberseat {
uint256 lastSnapshotIndex; // Index of the last snapshot when rewards were updated.
uint256 rewardEarned; // Accumulated rewards earned but not yet claimed.
}
/// @notice Represents a snapshot of the boardroom state for a peg token.
struct BoardroomSnapshot {
uint256 time; // Block number when the snapshot was taken.
uint256 rewardReceived; // Total rewards received in this snapshot.
uint256 rewardPerShare; // Cumulative reward per share (scaled by 1e18).
}
/// @notice Stores data for a pending withdrawal request.
struct PendingWithdraw {
uint256 amount; // Amount of staked shares requested for withdrawal.
uint256 unlockEpoch; // Epoch at which the withdrawal can be finalized.
}
/* ========== STATE VARIABLES ========== */
ITreasury public treasury; // Treasury contract reference.
address[] public pegTokens; // List of peg token addresses (e.g., GREEN, BLUE).
/// @notice Maps a member to their epoch timer start (used for lockup periods).
mapping(address => uint256) public epochTimerStart;
/// @notice Maps a peg token and member to their reward data.
mapping(address => mapping(address => Memberseat)) public members;
/// @notice Maps a peg token to its snapshot history.
mapping(address => BoardroomSnapshot[]) public boardroomHistory;
/// @notice Stores pending withdrawal requests for each member.
mapping(address => PendingWithdraw) public pendingWithdrawals;
/// @notice Number of epochs a member must wait after staking before they can withdraw.
uint256 public withdrawLockupEpochs;
/// @notice Number of epochs a member must wait after staking before they can claim rewards.
uint256 public rewardLockupEpochs;
/// @notice If a member does not claim rewards within this number of epochs, rewards will be burned.
uint256 public claimRewardsBurnEpochs;
/// @notice Configurable burn percentage for the immediate claim option (in basis points, where 10000 = 100%).
uint256 public immediateClaimSacrificePercent;
/// @notice Configurable vesting duration for Option 2 (in seconds).
uint256 public vestingDuration;
/// @notice Mapping from a peg token address to its escrow token address (for vesting claims).
mapping(address => address) public escrowTokens;
// For Option 3:
IWETH public wrappedSonic;
/// @notice Maps a peg token address to its Sonic-price oracle address.
mapping(address => address) public tokenInSonicOracles;
/// @notice Address of the collateral pool to which Sonic is forwarded.
address public collateralPool;
/// @notice Peg stability module fee in basis points (e.g., 1500 for 15%). Must be between 500 (5%) and 3000 (30%).
uint256 public pegStabilityModuleFee;
/* =================== Added variables for proxy compatibility =================== */
// Reserved for future variables
/* ========== EVENTS ========== */
/// @notice Emitted when a member stakes shares.
event Staked(address indexed user, uint256 amount);
/// @notice Emitted when a member requests a pending withdrawal.
event PendingWithdrawRequested(address indexed user, uint256 amount, uint256 unlockEpoch);
/// @notice Emitted when a member cancels a pending withdrawal.
event CancelPendingWithdraw(address indexed user, uint256 amount);
/// @notice Emitted when a member finalizes a pending withdrawal.
event PendingWithdrawFinalized(address indexed user, uint256 amount);
/// @notice Emitted when a member claims rewards.
event RewardPaid(address indexed token, address indexed user, uint256 reward);
/// @notice Emitted when rewards are added to the boardroom snapshot.
event RewardAdded(address indexed token, address indexed user, uint256 reward);
/// @notice Emitted when a member sacrifices (burns) their reward.
event RewardSacrificed(address indexed token, address indexed user, uint256 reward);
/// @notice Emitted when a vested reward is recorded.
event VestedRewardRecorded(address indexed token, address indexed user, uint256 amount, uint256 vestingEnd);
/// @notice Emitted when native Sonic is used as a bribe.
event SonicBribed(address indexed user, uint256 amount);
/* ========== MODIFIERS ========== */
/// @notice Restricts function execution to the Treasury contract.
modifier onlyTreasury() {
require(address(treasury) == msg.sender, "Boardroom: caller is not the treasury");
_;
}
/// @notice Ensures the caller has a positive staked balance.
modifier memberExists() {
require(balanceOf(msg.sender) > 0, "Boardroom: The member does not exist");
_;
}
/// @notice Updates reward data for the given member across all peg tokens.
modifier updateReward(address _member) {
if (_member != address(0)) {
uint256 len = pegTokens.length;
for (uint256 i = 0; i < len; ++i) {
address token = pegTokens[i];
Memberseat memory seat = members[token][_member];
seat.rewardEarned = earned(token, _member);
seat.lastSnapshotIndex = latestSnapshotIndex(token);
members[token][_member] = seat;
}
}
_;
}
/* ========== GOVERNANCE FUNCTIONS ========== */
/**
* @notice Initializes the Boardroom.
* @param _green Address of the GREEN token.
* @param _blue Address of the BLUE token.
* @param _red Address of the RED token used for shares.
* @param _collateralPool The collateral pool address.
* @param _treasury The Treasury contract.
*/
function initialize(
address _green,
address _blue,
address _red,
address _collateralPool,
ITreasury _treasury
) external initializer {
OwnableUpgradeable.__Ownable_init(msg.sender);
// Set the share token to RED.
share = IERC20(_red);
collateralPool = _collateralPool;
treasury = _treasury;
// Configure peg tokens (GREEN and BLUE).
pegTokens.push(_green);
pegTokens.push(_blue);
// Initialize snapshot history for each peg token with an initial snapshot.
boardroomHistory[_green].push(BoardroomSnapshot({
time: block.number,
rewardReceived: 0,
rewardPerShare: 0
}));
boardroomHistory[_blue].push(BoardroomSnapshot({
time: block.number,
rewardReceived: 0,
rewardPerShare: 0
}));
// Set lockup parameters.
withdrawLockupEpochs = 6; // 6 epochs lockup for withdrawal.
rewardLockupEpochs = 2; // 2 epochs lockup for reward claim.
claimRewardsBurnEpochs = 8; // Rewards unclaimed for 8 epochs will be burned.
// Set default immediate claim sacrifice percentage to 30% (3000 basis points).
immediateClaimSacrificePercent = 3000;
// Set default vesting duration for Option 2.
vestingDuration = 7 days;
// Set default peg stability module fee to 15% (1500 basis points).
pegStabilityModuleFee = 1500;
wrappedSonic = IWETH(0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38);
}
/**
* @notice Allows the contract to receive native Sonic.
*/
receive() external payable {
// Accept native Sonic deposits.
}
/**
* @notice Sets the lockup durations for withdrawal, reward claim, and reward burn.
* @param _withdrawLockupEpochs Number of epochs to lock withdrawal.
* @param _rewardLockupEpochs Number of epochs to lock reward claims.
* @param _claimRewardsBurnEpochs Number of epochs after which unclaimed rewards are burned.
*/
function setLockUp(
uint256 _withdrawLockupEpochs,
uint256 _rewardLockupEpochs,
uint256 _claimRewardsBurnEpochs
) external onlyOwner {
require(_rewardLockupEpochs <= 21 && _withdrawLockupEpochs <= 21 && _claimRewardsBurnEpochs <= 21, "lockupEpochs cannot exceed 1 week");
require(_rewardLockupEpochs + 2 <= _claimRewardsBurnEpochs, "Need window for user to claim before burning rewards");
require(_claimRewardsBurnEpochs >= 6, "At least 2 days before rewards are burnt");
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
claimRewardsBurnEpochs = _claimRewardsBurnEpochs;
}
/**
* @notice Updates the immediate claim sacrifice percentage.
* @param _percent The new percentage in basis points (e.g., 5000 for 50%). Must be between 0 and 10000.
*/
function setImmediateClaimSacrificePercent(uint256 _percent) external onlyOwner {
require(_percent <= 10000, "Invalid percentage");
immediateClaimSacrificePercent = _percent;
}
/**
* @notice Sets the vesting duration for Option 2 (vesting claim).
* @param _duration The new vesting duration in seconds.
*/
function setVestingDuration(uint256 _duration) external onlyOwner {
require(_duration > 0, "Vesting duration must be > 0");
vestingDuration = _duration;
}
/**
* @notice Sets the escrow token address for a given peg token.
* @param _pegToken The peg token address.
* @param _escrowToken The corresponding escrow token address.
*/
function setEscrowToken(address _pegToken, address _escrowToken) external onlyOwner {
require(_escrowToken != address(0), "Zero address");
escrowTokens[_pegToken] = _escrowToken;
}
/**
* @notice Sets the Wrapped Sonic contract.
* @param _wrappedSonic The address of the Wrapped Sonic contract.
*/
function setWSonic(IWETH _wrappedSonic) external onlyOwner {
require(address(_wrappedSonic) != address(0), "Invalid Wrapped Sonic address");
wrappedSonic = _wrappedSonic;
}
/**
* @notice Sets the Sonic oracle for a given peg token.
* @param _pegToken The peg token address.
* @param _oracle The oracle address that returns the token price in Sonic.
*/
function setTokenInSonicOracle(address _pegToken, address _oracle) external onlyOwner {
require(_pegToken != address(0) && _oracle != address(0), "Invalid address");
tokenInSonicOracles[_pegToken] = _oracle;
}
/**
* @notice Sets the collateral pool address.
* @param _collateralPool The new collateral pool address.
*/
function setCollateralPool(address _collateralPool) external onlyOwner {
require(_collateralPool != address(0), "Invalid collateral pool address");
collateralPool = _collateralPool;
}
/**
* @notice Sets the peg stability module fee.
* @param _fee The new fee in basis points (e.g., 1500 for 15%).
* It must be between 500 (5%) and 3000 (30%).
*/
function setPegStabilityModuleFee(uint256 _fee) external onlyOwner {
require(_fee >= 500 && _fee <= 3000, "Boardroom: fee must be between 5% and 30%");
pegStabilityModuleFee = _fee;
}
/**
* @notice Adds a new peg token to the boardroom.
* @param _token The peg token address to add.
*/
function addPegToken(address _token) external onlyOwner {
require(boardroomHistory[_token].length == 0, "Boardroom: boardroomHistory exists");
require(IERC20(_token).totalSupply() > 0, "Boardroom: invalid token");
uint256 len = pegTokens.length;
for (uint256 i = 0; i < len; ++i) {
require(pegTokens[i] != _token, "Boardroom: existing token");
}
pegTokens.push(_token);
boardroomHistory[_token].push(BoardroomSnapshot({
time: block.number,
rewardReceived: 0,
rewardPerShare: 0
}));
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Returns the latest snapshot index for a given peg token.
* @param _token The peg token address.
* @return The index of the latest snapshot.
*/
function latestSnapshotIndex(address _token) public view returns (uint256) {
return boardroomHistory[_token].length - 1;
}
/**
* @notice Retrieves the latest snapshot for a given peg token.
* @param _token The peg token address.
* @return The latest BoardroomSnapshot.
*/
function getLatestSnapshot(address _token) internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[_token][latestSnapshotIndex(_token)];
}
/**
* @notice Retrieves the last snapshot index for a member and peg token.
* @param _token The peg token address.
* @param _member The member's address.
* @return The snapshot index.
*/
function getLastSnapshotIndexOf(address _token, address _member) public view returns (uint256) {
return members[_token][_member].lastSnapshotIndex;
}
/**
* @notice Retrieves the last snapshot for a member for a specific peg token.
* @param _token The peg token address.
* @param _member The member's address.
* @return The BoardroomSnapshot at the member's last snapshot index.
*/
function getLastSnapshotOf(address _token, address _member) internal view returns (BoardroomSnapshot memory) {
return boardroomHistory[_token][getLastSnapshotIndexOf(_token, _member)];
}
/**
* @notice Checks whether a member can claim rewards based on the lockup period.
* @param member The member's address.
* @return True if the member can claim rewards.
*/
function canClaimReward(address member) external view returns (bool) {
return epochTimerStart[member] + rewardLockupEpochs <= treasury.epoch();
}
/**
* @notice Provides information on whether a member's rewards will be burnt if unclaimed and the burn epoch.
* @param member The member's address.
* @return _burned True if rewards will be burnt.
* @return _burningEpoch The epoch at which rewards will be burnt.
*/
function burningRewardsInfo(address member) external view returns (bool _burned, uint256 _burningEpoch) {
uint256 startEpoch = epochTimerStart[member];
_burned = startEpoch + claimRewardsBurnEpochs <= treasury.epoch();
_burningEpoch = 0;
if (startEpoch > 0 && startEpoch <= treasury.epoch()) {
_burningEpoch = startEpoch + claimRewardsBurnEpochs;
}
}
/**
* @notice Returns the current treasury epoch.
* @return The current epoch.
*/
function epoch() external view returns (uint256) {
return treasury.epoch();
}
/**
* @notice Returns the timestamp for the next treasury epoch.
* @return The next epoch's timestamp.
*/
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
/**
* @notice Returns the length (in seconds) of the next treasury epoch.
* @return The epoch length.
*/
function nextEpochLength() external view returns (uint256) {
return treasury.nextEpochLength();
}
/**
* @notice Retrieves the peg token price from the Treasury.
* @param _token The peg token address.
* @return The peg token price.
*/
function getPegTokenPrice(address _token) external view returns (uint256) {
return treasury.getPegTokenPrice(_token);
}
/**
* @notice Retrieves the peg token price in Sonic by querying the corresponding oracle.
* @param _token The peg token address.
* @return The price in Sonic (scaled by 1e18).
*/
function getPegTokenPriceInSonic(address _token) public view returns (uint256) {
try IOracle(tokenInSonicOracles[_token]).twap(_token, 1e18) returns (uint144 price) {
return uint256(price);
} catch {
revert("Boardroom: oracle failed");
}
}
/**
* @notice Calculates the total Sonic fee required for claiming rewards using Option 3.
* @param _user The address of the member.
* @return totalSonicFee The total amount of Sonic (in wei) required as a bribe fee.
*/
function getSonicFeeForOption3(address _user) external view returns (uint256 totalSonicFee) {
uint256 len = pegTokens.length;
totalSonicFee = 0;
for (uint256 i = 0; i < len; ++i) {
address token = pegTokens[i];
uint256 reward = earned(token, _user);
// Calculation: fee = (priceInSonic * reward * pegStabilityModuleFee) / 1e22.
// getPegTokenPriceInSonic returns the token price in Sonic scaled by 1e18,
// pegStabilityModuleFee is in basis points (e.g., 1500 for 15%),
// and dividing by 1e22 adjusts the scale.
totalSonicFee += getPegTokenPriceInSonic(token) * reward * pegStabilityModuleFee / 1e22;
}
}
/**
* @notice Returns the reward per share for a given peg token.
* @param _token The peg token address.
* @return The reward per share (scaled by 1e18).
*/
function rewardPerShare(address _token) public view returns (uint256) {
return getLatestSnapshot(_token).rewardPerShare;
}
/**
* @notice Returns the number of peg tokens configured.
* @return The count of peg tokens.
*/
function numOfPegTokens() public view returns (uint256) {
return pegTokens.length;
}
/**
* @notice Calculates the reward earned by a member for a specific peg token.
* @param _token The peg token address.
* @param _member The member's address.
* @return The total earned reward.
*/
function earned(address _token, address _member) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot(_token).rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(_token, _member).rewardPerShare;
return (balanceOf(_member) * (latestRPS - storedRPS) / 1e18) + members[_token][_member].rewardEarned;
}
/**
* @notice Returns the earned rewards for each peg token for a member.
* @param _member The member's address.
* @return _numOfPegTokens The number of peg tokens.
* @return _pegTokenAddresses The list of peg token addresses.
* @return _earnedPegTokens The list of earned rewards per peg token.
*/
function earnedAll(address _member) external view returns (uint256 _numOfPegTokens, address[] memory _pegTokenAddresses, uint256[] memory _earnedPegTokens) {
_numOfPegTokens = numOfPegTokens();
_pegTokenAddresses = new address[](_numOfPegTokens);
_earnedPegTokens = new uint256[](_numOfPegTokens);
for (uint256 i = 0; i < _numOfPegTokens; i++) {
_pegTokenAddresses[i] = pegTokens[i];
_earnedPegTokens[i] = earned(_pegTokenAddresses[i], _member);
}
}
function vestingSchedule(address _token, address _member) public view returns (uint256 _claimable, uint256 _remaining, uint256 _endTime) {
(uint256 _totalAmount, uint256 _claimedAmount, uint256 _startTime, uint256 _duration) = IEscrow(escrowTokens[_token]).vestingSchedule(_member);
if (_duration > 0) {
_endTime = _startTime + _duration;
uint256 elapsed = block.timestamp > _endTime ? _duration : block.timestamp - _startTime;
uint256 vestedAmount = (_totalAmount * elapsed) / _duration;
_claimable = (vestedAmount <= _claimedAmount) ? 0 : vestedAmount - _claimedAmount;
_remaining = _totalAmount - vestedAmount;
}
}
function vestingScheduleAll(address _member) external view returns (uint256 _numOfPegTokens, address[] memory _pegTokenAddresses, uint256[] memory _claimables, uint256[] memory _remainings, uint256[] memory _endTimes) {
_numOfPegTokens = numOfPegTokens();
_pegTokenAddresses = new address[](_numOfPegTokens);
_claimables = new uint256[](_numOfPegTokens);
_remainings = new uint256[](_numOfPegTokens);
_endTimes = new uint256[](_numOfPegTokens);
for (uint256 i = 0; i < _numOfPegTokens; i++) {
address _token = pegTokens[i];
_pegTokenAddresses[i] = _token;
(_claimables[i], _remainings[i], _endTimes[i]) = vestingSchedule(_token, _member);
}
}
/* ========== MUTATIVE FUNCTIONS ========== */
/**
* @notice Stakes share tokens into the boardroom.
* Updates reward data, claims pending rewards if available, and resets the epoch timer.
* @param amount The amount of shares to stake.
*/
function stake(uint256 amount) public override onlyOneBlock nonReentrant updateReward(msg.sender) {
require(amount > 0, "Boardroom: Cannot stake 0");
uint256 currentEpoch = treasury.epoch();
if (epochTimerStart[msg.sender] + claimRewardsBurnEpochs <= treasury.epoch()) {
_claimReward(0); // Option 3 may require sonic bribe cost calculation.
} else {
// Reset timer if reward lockup is still active.
epochTimerStart[msg.sender] = currentEpoch;
}
super.stake(amount);
epochTimerStart[msg.sender] = currentEpoch; // Reset lockup timer after staking.
emit Staked(msg.sender, amount);
}
/**
* @notice Initiates a withdrawal request by moving a specified amount of staked shares to a pending state.
* The shares stop earning rewards immediately.
* @param _amount The amount of shares to withdraw.
*/
function requestWithdraw(uint256 _amount) public onlyOneBlock nonReentrant memberExists updateReward(msg.sender) {
require(_amount > 0, "Boardroom: Cannot withdraw 0");
uint256 unlockEpoch = treasury.epoch() + withdrawLockupEpochs;
PendingWithdraw memory pending = pendingWithdrawals[msg.sender];
pending.amount += _amount;
pending.unlockEpoch = unlockEpoch;
pendingWithdrawals[msg.sender] = pending;
_sacrificeReward(_amount);
super._withdraw(_amount);
emit PendingWithdrawRequested(msg.sender, _amount, unlockEpoch);
}
/**
* @notice Cancels the current pending withdrawal request, returning the pending shares back to staked balance.
*/
function cancelPendingWithdraw() external onlyOneBlock nonReentrant updateReward(msg.sender) {
PendingWithdraw memory pending = pendingWithdrawals[msg.sender];
uint256 amountToCancel = pending.amount;
require(amountToCancel > 0, "Boardroom: no pending withdraw to cancel");
delete pendingWithdrawals[msg.sender]; // Clear pending withdrawal.
super._cancelWithdraw(amountToCancel);
emit CancelPendingWithdraw(msg.sender, amountToCancel);
}
/**
* @notice Finalizes a pending withdrawal after the lockup period has expired.
* Transfers the pending share tokens back to the member's wallet.
*/
function finalizeWithdraw() external onlyOneBlock nonReentrant updateReward(msg.sender) {
PendingWithdraw memory pending = pendingWithdrawals[msg.sender];
require(pending.unlockEpoch <= treasury.epoch(), "Boardroom: still in withdraw lockup");
uint256 amountToWithdraw = pending.amount;
delete pendingWithdrawals[msg.sender]; // Clear pending withdrawal.
super._claimPendingWithdraw(amountToWithdraw);
emit PendingWithdrawFinalized(msg.sender, amountToWithdraw);
}
/**
* @notice Exits the boardroom by requesting withdrawal of all staked shares.
*/
function exit() external {
requestWithdraw(balanceOf(msg.sender));
}
/**
* @dev Internal function that sacrifices a portion of a member's reward when initiating a withdrawal.
* The sacrificed reward is burned.
* @param _withdrawAmount The amount of staked shares being withdrawn.
*/
function _sacrificeReward(uint256 _withdrawAmount) internal updateReward(msg.sender) {
uint256 len = pegTokens.length;
for (uint256 i = 0; i < len; ++i) {
address token = pegTokens[i];
uint256 reward = members[token][msg.sender].rewardEarned;
if (reward > 0) {
uint256 burnAmount = reward * _withdrawAmount / balanceOf(msg.sender);
members[token][msg.sender].rewardEarned -= burnAmount;
IBasisAsset(token).burn(burnAmount);
emit RewardSacrificed(token, msg.sender, burnAmount);
}
}
}
function claimReward() external {
require(epochTimerStart[msg.sender] + rewardLockupEpochs <= treasury.epoch(), "Boardroom: still in reward lockup");
_claimReward(1);
}
/**
* @notice Claims accumulated rewards for all peg tokens for the caller.
* Supports three options:
* Option 1: Immediate Claim – burns a configurable percentage of the reward and pays out the rest.
* Option 2: Vesting Claim – locks the reward in a vesting schedule.
* Option 3: Option for direct claim with a Sonic bribe fee (for dynamic pricing via oracles).
* @param _option The option selected (1 for Immediate, 2 for Vesting, 3 for direct claim with Sonic bribe).
*/
function claimRewardWithOption(uint256 _option) external payable {
require(_option == 3 || msg.value == 0, "Only option 3 is payable");
require(epochTimerStart[msg.sender] + rewardLockupEpochs <= treasury.epoch(), "Boardroom: still in reward lockup");
_claimReward(_option);
}
/**
* @dev Internal function to claim rewards based on the selected option.
* For Option 1, a configurable percentage of the reward is burned.
* For Option 2, rewards are locked in the escrow token (vesting).
* For Option 3, a Sonic bribe fee is calculated and deducted.
* @param _option The claim option selected.
*/
function _claimReward(uint256 _option) internal updateReward(msg.sender) {
bool willBurn = epochTimerStart[msg.sender] + claimRewardsBurnEpochs <= treasury.epoch();
epochTimerStart[msg.sender] = treasury.epoch(); // Reset timer after claim.
uint256 len = pegTokens.length;
uint256 totalSonicFee = 0;
for (uint256 i = 0; i < len; ++i) {
address token = pegTokens[i];
uint256 reward = members[token][msg.sender].rewardEarned;
if (reward > 0) {
members[token][msg.sender].rewardEarned = 0;
if (willBurn) {
IBasisAsset(token).burn(reward);
emit RewardSacrificed(token, msg.sender, reward);
} else {
if (_option == 1) {
// Option 1: Immediate Claim with configurable sacrifice.
uint256 immediateReward = reward * (10000 - immediateClaimSacrificePercent) / 10000;
uint256 sacrifice = reward * immediateClaimSacrificePercent / 10000;
IBasisAsset(token).burn(sacrifice);
IERC20(token).safeTransfer(msg.sender, immediateReward);
emit RewardPaid(token, msg.sender, immediateReward);
emit RewardSacrificed(token, msg.sender, sacrifice);
} else if (_option == 2) {
// Option 2: Vesting Claim.
// Retrieve the escrow token for the peg token.
address escrowToken = escrowTokens[token];
require(escrowToken != address(0), "Boardroom: escrow token not set");
IERC20(token).approve(escrowToken, reward);
IEscrow(escrowToken).startVesting(msg.sender, reward, vestingDuration);
IERC20(token).approve(escrowToken, 0);
emit VestedRewardRecorded(token, msg.sender, reward, block.timestamp + vestingDuration);
} else if (_option == 3) {
// Option 3: Direct Claim with Sonic bribe fee.
totalSonicFee += getPegTokenPriceInSonic(token) * reward * pegStabilityModuleFee / 1e22;
IERC20(token).safeTransfer(msg.sender, reward);
emit RewardPaid(token, msg.sender, reward);
} else {
revert("Boardroom: unsupported claim option");
}
}
}
}
if (totalSonicFee > 0) {
require(msg.value >= totalSonicFee, "Boardroom: insufficient Sonic for bribe fee");
emit SonicBribed(msg.sender, totalSonicFee);
}
if (msg.value > totalSonicFee) {
uint256 refund = msg.value - totalSonicFee;
(bool success, ) = msg.sender.call{value: refund}("");
require(success, "Boardroom: refund failed");
}
}
/**
* @notice Claims vested rewards for a specific peg token.
* @param _token The peg token address for which vested rewards are claimed.
*/
function claimVestedReward(address _token) public nonReentrant {
IEscrow _escrowToken = IEscrow(escrowTokens[_token]);
if (_escrowToken.availableToClaim(msg.sender) > 0) {
_escrowToken.claimFor(msg.sender);
}
}
function claimAllVestedRewards() public {
uint256 len = pegTokens.length;
for (uint256 i = 0; i < len; ++i) {
claimVestedReward(pegTokens[i]);
}
}
/**
* @notice Allocates seigniorage rewards for a specific peg token.
* Callable by the Treasury contract.
* @param _token The peg token address.
* @param _amount The amount of reward to allocate.
*/
function allocateSeignioragePegToken(address _token, uint256 _amount) external override onlyTreasury {
require(_amount > 0, "Boardroom: Cannot allocate 0");
uint256 totalStaked = totalSupply();
require(totalStaked > 0, "Boardroom: Cannot allocate when totalSupply is 0");
require(boardroomHistory[_token].length > 0, "Boardroom: No snapshot history for token");
uint256 prevRPS = getLatestSnapshot(_token).rewardPerShare;
uint256 nextRPS = prevRPS + _amount * 1e18 / totalStaked;
BoardroomSnapshot memory newSnapshot = BoardroomSnapshot({
time: block.number,
rewardReceived: _amount,
rewardPerShare: nextRPS
});
boardroomHistory[_token].push(newSnapshot);
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
emit RewardAdded(_token, msg.sender, _amount);
}
/**
* @notice Collects all native Sonic from the contract, wraps it into wS (Wrapped Sonic), and forwards it to bribesSafe.
*/
function collectSonic() external {
require(address(wrappedSonic) != address(0), "Boardroom: wrappedSonic not set");
uint256 amount = address(this).balance;
require(amount > 0, "Boardroom: No Sonic balance to collect");
wrappedSonic.deposit{value: amount}();
IERC20(wrappedSonic).safeTransfer(collateralPool, amount);
}
/* ========== GOVERNANCE & ADMIN FUNCTIONS ========== */
/**
* @notice Allows the owner to recover unsupported tokens (except core tokens).
* @param _token The token to recover.
* @param _amount The amount to recover.
* @param _to The recipient address.
*/
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOwner {
uint256 len = pegTokens.length;
for (uint256 i = 0; i < len; ++i) {
require(address(_token) != pegTokens[i], "Boardroom: reward token");
}
_token.safeTransfer(_to, _amount);
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
function transferOwnership(address newOwner_) external;
function totalBurned() external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
interface IBoardroom {
function allocateSeignioragePegToken(address _token, uint256 _amount) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
interface IEpoch {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function nextEpochLength() external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
interface IEscrow {
function vestingSchedule(address _user) external view returns (uint256 totalAmount, uint256 claimedAmount, uint256 startTime, uint256 duration);
function totalClaimed(address _user) external view returns (uint256);
function availableToClaim(address _user) external view returns (uint256);
function fullClaimTime(address _user) external view returns (uint256);
function startVesting(address _user, uint256 _amount, uint256 _vestingDuration) external;
function claim() external;
function claimFor(address _user) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
interface IOracle {
function update() external;
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut);
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut);
function getPegPrice() external view returns (uint256);
function getPegPriceUpdated() external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
import "./IEpoch.sol";
interface ITreasury is IEpoch {
function getPegTokenPrice(address _token) external view returns (uint256);
function getPegTokenUpdatedPrice(address _token) external view returns (uint256);
function getPegTokenLockedBalance(address _token) external view returns (uint256);
function getPegTokenCirculatingSupply(address _token) external view returns (uint256);
function getPegTokenExpansionRate(address _token) external view returns (uint256);
function getPegTokenExpansionAmount(address _token) external view returns (uint256);
function previousEpochGreenPrice() external view returns (uint256);
function boardroom() external view returns (address);
function boardroomSharedPercent() external view returns (uint256);
function daoFund() external view returns (address);
function daoFundSharedPercent() external view returns (uint256);
function collateralPool() external view returns (address);
function collateralPoolSharedPercent() external view returns (uint256);
function devFund() external view returns (address);
function devFundSharedPercent() external view returns (uint256);
function isSharePrinter(address account) external view returns (bool);
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.28;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title ShareWrapper
* @dev A lightweight wrapper for staking an ERC20-based "share" token.
* Users can stake tokens, which increases the total staked balance,
* and can withdraw or claim them later. This contract is meant to be
* inherited by a higher-level Boardroom-like contract.
*/
contract ShareWrapper {
using SafeERC20 for IERC20;
/// @notice The share token that users stake.
IERC20 public share;
/// @dev Tracks the total staked supply of the share token.
uint256 private _totalStaked;
/// @dev Tracks each user's staked balance.
mapping(address => uint256) private _stakedBalances;
/**
* @notice Returns the total staked supply of the share token.
*/
function totalSupply() public view returns (uint256) {
return _totalStaked;
}
/**
* @notice Returns the staked balance of a given account.
* @param account The address of the user.
*/
function balanceOf(address account) public view returns (uint256) {
return _stakedBalances[account];
}
/**
* @notice Allows a user to stake a specified amount of the share token.
* The contract adjusts for any potential deflationary token behavior
* by measuring the contract's share balance before and after transfer.
* @param amount The amount of the share token to stake.
*/
function stake(uint256 amount) public virtual {
uint256 previousBalance = share.balanceOf(address(this));
share.safeTransferFrom(msg.sender, address(this), amount);
// Recalculate the actual transferred amount in case of deflationary token mechanics.
amount = share.balanceOf(address(this)) - previousBalance;
_totalStaked += amount;
_stakedBalances[msg.sender] += amount;
}
/**
* @dev Internal function that reduces the caller's staked balance without
* transferring tokens back to them. This is intended for "pending withdraw"
* logic where the tokens remain in the contract until a finalize step.
* @param amount The amount to remove from the caller's staked balance.
*/
function _withdraw(uint256 amount) internal virtual {
uint256 userStakedBalance = _stakedBalances[msg.sender];
require(userStakedBalance >= amount, "ShareWrapper: withdraw request exceeds staked balance");
_totalStaked -= amount;
_stakedBalances[msg.sender] = userStakedBalance - amount;
}
/**
* @dev Internal function that restores a user's staked balance after a withdraw
* request has been canceled. This effectively re-stakes the tokens for the user.
* @param amount The amount to re-stake to the caller's balance.
*/
function _cancelWithdraw(uint256 amount) internal virtual {
_totalStaked += amount;
_stakedBalances[msg.sender] += amount;
}
/**
* @dev Internal function that transfers share tokens from the contract
* to the caller, finalizing the withdrawal process.
* @param amount The amount of share tokens to transfer to the user.
*/
function _claimPendingWithdraw(uint256 amount) internal virtual {
share.safeTransfer(msg.sender, amount);
}
}