// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)pragmasolidity ^0.8.20;/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/abstractcontractContext{
function_msgSender() internalviewvirtualreturns (address) {
returnmsg.sender;
}
function_msgData() internalviewvirtualreturns (bytescalldata) {
returnmsg.data;
}
function_contextSuffixLength() internalviewvirtualreturns (uint256) {
return0;
}
}
Contract Source Code
File 2 of 6: IERC20.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)pragmasolidity ^0.8.20;/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/interfaceIERC20{
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/eventTransfer(addressindexedfrom, addressindexed 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.
*/eventApproval(addressindexed owner, addressindexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/functiontotalSupply() externalviewreturns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/functionbalanceOf(address account) externalviewreturns (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.
*/functiontransfer(address to, uint256 value) externalreturns (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.
*/functionallowance(address owner, address spender) externalviewreturns (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.
*/functionapprove(address spender, uint256 value) externalreturns (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.
*/functiontransferFrom(addressfrom, address to, uint256 value) externalreturns (bool);
}
Contract Source Code
File 3 of 6: Ownable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)pragmasolidity ^0.8.20;import {Context} from"../utils/Context.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.
*/abstractcontractOwnableisContext{
addressprivate _owner;
/**
* @dev The caller account is not authorized to perform an operation.
*/errorOwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/errorOwnableInvalidOwner(address owner);
eventOwnershipTransferred(addressindexed previousOwner, addressindexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/constructor(address initialOwner) {
if (initialOwner ==address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/modifieronlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/functionowner() publicviewvirtualreturns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/function_checkOwner() internalviewvirtual{
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.
*/functionrenounceOwnership() publicvirtualonlyOwner{
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/functiontransferOwnership(address newOwner) publicvirtualonlyOwner{
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) internalvirtual{
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
Contract Source Code
File 4 of 6: Ownable2Step.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)pragmasolidity ^0.8.20;import {Ownable} from"./Ownable.sol";
/**
* @dev Contract module which provides access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is specified at deployment time in the constructor for `Ownable`. This
* can later be changed with {transferOwnership} and {acceptOwnership}.
*
* This module is used through inheritance. It will make available all functions
* from parent (Ownable).
*/abstractcontractOwnable2StepisOwnable{
addressprivate _pendingOwner;
eventOwnershipTransferStarted(addressindexed previousOwner, addressindexed newOwner);
/**
* @dev Returns the address of the pending owner.
*/functionpendingOwner() publicviewvirtualreturns (address) {
return _pendingOwner;
}
/**
* @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
* Can only be called by the current owner.
*/functiontransferOwnership(address newOwner) publicvirtualoverrideonlyOwner{
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
* Internal function without access restriction.
*/function_transferOwnership(address newOwner) internalvirtualoverride{
delete _pendingOwner;
super._transferOwnership(newOwner);
}
/**
* @dev The new owner accepts the ownership transfer.
*/functionacceptOwnership() publicvirtual{
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
Contract Source Code
File 5 of 6: ReentrancyGuard.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)pragmasolidity ^0.8.20;/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/abstractcontractReentrancyGuard{
// 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.uint256privateconstant NOT_ENTERED =1;
uint256privateconstant ENTERED =2;
uint256private _status;
/**
* @dev Unauthorized reentrant call.
*/errorReentrancyGuardReentrantCall();
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.
*/modifiernonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function_nonReentrantBefore() private{
// On the first call to nonReentrant, _status will be NOT_ENTEREDif (_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() internalviewreturns (bool) {
return _status == ENTERED;
}
}
Contract Source Code
File 6 of 6: Staking.sol
// SPDX-License-Identifier: UNLICENSEDpragmasolidity 0.8.24;import {Ownable2Step, Ownable} from"lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol";
import {ReentrancyGuard} from"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol";
import {IERC20} from"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
/// @title Staking/// @notice $BLOCK stakingcontractStakingisOwnable2Step, ReentrancyGuard{
/*==============================================================
CONSTANTS & IMMUTABLES
==============================================================*//// @notice $BLOCK address
IERC20 publicimmutable token;
/*==============================================================
STORAGE VARIABLES
==============================================================*/structPool {
uint256 poolId;
uint256 amountLimit;
uint256 amount;
uint256[] lockupPeriods;
bool paused;
bool terminated;
}
structStake {
uint256 poolId;
uint256 amount;
uint256 lockupPeriod;
uint256 expiresAt;
bool unstaked;
}
/// @notice Pool ID => Poolmapping(uint256=> Pool) public pools;
/// @notice User => Stake[]mapping(address=> Stake[]) public stakes;
/// @notice User => Stake countmapping(address=>uint256) public stakesCount;
/*==============================================================
FUNCTIONS
==============================================================*//// @notice Staking contract constructor/// @param _initialOwner Initial owner of the contract/// @param _token $BLOCK token addressconstructor(address _initialOwner, address _token) Ownable(_initialOwner) {
if (_token ==address(0)) {
revert InvalidTokenAddressSet();
}
token = IERC20(_token);
}
/// @notice Stake $BLOCK tokens/// @param _poolId Pool ID/// @param _amount Amount of $BLOCK tokens to stake/// @param _lockupPeriod Lockup period in secondsfunctionstake(uint256 _poolId,
uint256 _amount,
uint256 _lockupPeriod
) externalnonReentrant{
if (pools[_poolId].amountLimit ==0) {
revert PoolDoesNotExist();
}
Pool memory pool = pools[_poolId];
if (pool.terminated) {
revert PoolIsTerminated();
} elseif (pool.paused) {
revert PoolIsPaused();
} elseif (_amount + pool.amount > pools[_poolId].amountLimit) {
revert ExceedsLimit();
} elseif (!_exists(pool.lockupPeriods, _lockupPeriod)) {
revert InvalidLockupPeriod();
}
token.transferFrom(msg.sender, address(this), _amount);
stakes[msg.sender].push(
Stake({
poolId: _poolId,
amount: _amount,
lockupPeriod: _lockupPeriod,
expiresAt: block.timestamp+ _lockupPeriod,
unstaked: false
})
);
stakesCount[msg.sender]++;
pools[_poolId].amount += _amount;
emit Staked(msg.sender, _poolId, _amount, _lockupPeriod);
}
/// @notice Unstake $BLOCK tokens/// @param _stakeIds Stake IDfunctionunstake(uint256[] calldata _stakeIds) externalnonReentrant{
uint256 unstakeAmount =0;
for (uint256 i =0; i < _stakeIds.length; i++) {
Stake storage stake_ = stakes[msg.sender][_stakeIds[i]];
if (stake_.unstaked) {
revert AlreadyUnstaked();
}
Pool memory pool = pools[stake_.poolId];
if (!pool.terminated && stake_.expiresAt >block.timestamp) {
revert StakeNotExpired();
}
stake_.unstaked =true;
unstakeAmount += stake_.amount;
}
token.transfer(msg.sender, unstakeAmount);
emit Unstaked(_stakeIds);
}
/*==============================================================
ADMIN FUNCTIONS
==============================================================*//// @notice Create a new pool/// @param _poolId Pool ID/// @param _amountLimit Total limit of the pool/// @param _lockupPeriods Lockup periodsfunctioncreatePool(uint256 _poolId, uint256 _amountLimit, uint256[] calldata _lockupPeriods) externalonlyOwner{
if (pools[_poolId].amountLimit !=0) {
revert PoolAlreadyExists();
} elseif (_amountLimit ==0) {
revert InvalidAmountLimitSet();
}
for (uint256 i =0; i < _lockupPeriods.length; i++) {
if (_lockupPeriods[i] ==0) {
revert InvalidLockupPeriodSet();
}
}
pools[_poolId] = Pool({
poolId: _poolId,
amountLimit: _amountLimit,
lockupPeriods: _lockupPeriods,
amount: 0,
paused: false,
terminated: false
});
emit PoolCreated(_poolId, _amountLimit);
}
/// @notice Pause a pool/// @param _poolId Pool IDfunctionpausePool(uint256 _poolId) externalonlyOwner{
pools[_poolId].paused =true;
emit PoolPaused(_poolId);
}
/// @notice Unpause a pool/// @param _poolId Pool IDfunctionunpausePool(uint256 _poolId) externalonlyOwner{
pools[_poolId].paused =false;
emit PoolUnpaused(_poolId);
}
/// @notice Terminate a pool/// @param _poolId Pool IDfunctionterminatePool(uint256 _poolId) externalonlyOwner{
pools[_poolId].terminated =true;
emit PoolTerminated(_poolId);
}
/*==============================================================
INTERNAL FUNCTIONS
==============================================================*//// @notice Check if a lockup period exists/// @param _periods Lockup periods/// @param _period Lockup periodfunction_exists(uint256[] memory _periods,
uint256 _period
) internalpurereturns (bool) {
for (uint256 i =0; i < _periods.length; i++) {
if (_periods[i] == _period) {
returntrue;
}
}
returnfalse;
}
/*==============================================================
EVENTS
==============================================================*//// @notice Emitted when a pool is created/// @param poolId Pool ID/// @param amountLimit Total limit of the pooleventPoolCreated(uint256indexed poolId, uint256indexed amountLimit);
/// @notice Emitted when a pool is paused/// @param poolId Pool IDeventPoolPaused(uint256indexed poolId);
/// @notice Emitted when a pool is unpaused/// @param poolId Pool IDeventPoolUnpaused(uint256indexed poolId);
/// @notice Emitted when a pool is terminated/// @param poolId Pool IDeventPoolTerminated(uint256indexed poolId);
/// @notice Emitted when a user stakes to a pool/// @param walletAddress Address of staker/// @param poolId Pool ID/// @param amount Amount of $BLOCK tokens staked/// @param lockupPeriod Lockup periodeventStaked(addressindexed walletAddress,
uint256indexed poolId,
uint256 amount,
uint256indexed lockupPeriod
);
/// @notice Emitted when a user unstakes from a pool/// @param stakeIds Stake IDseventUnstaked(uint256[] indexed stakeIds);
/*==============================================================
ERRORS
==============================================================*//// @notice Error when pool does not existerrorPoolDoesNotExist();
/// @notice Error when pool already existserrorPoolAlreadyExists();
/// @notice Error when pool is pausederrorPoolIsPaused();
/// @notice Error when pool is terminatederrorPoolIsTerminated();
/// @notice Error when pool amount limit is exceedederrorExceedsLimit();
/// @notice Error when lockup period is invaliderrorInvalidLockupPeriod();
/// @notice Error when stake is already unstakederrorTransferFailed();
/// @notice Error when stake is already unstakederrorAlreadyUnstaked();
/// @notice Error when stake is not expirederrorStakeNotExpired();
/// @notice Error when stake does not existerrorStakeDoesNotExist();
/// @notice Error when adding invalid token addresserrorInvalidTokenAddressSet();
/// @notice Error when setting invalid amount limiterrorInvalidAmountLimitSet();
/// @notice Error when setting invalid lockup perioderrorInvalidLockupPeriodSet();
}