PSA: Scheduled Server Maintenance & Upgrades [2nd-December-2021 6:00 AM UTC] - Estimated duration: 3 hours.

Contract 0xD558675a8c8E1fd45002010BaC970B115163dE3a

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xb16b7d1c2bcb98b7a0c664a283a7027798b67c9b1280c56f260b198eb85e9a30Stake131228462021-12-02 5:52:165 mins ago0xd56054fcd6d223d42b92e5e129a322c8ad57f3b8 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.00032456
0x9bdc9c9ad7fd61c179cf7feaba2e627bbfc41ac2faa23f79b54606818030644aWithdraw131227012021-12-02 5:44:4812 mins ago0xbe8d6b409f59ac83b000ea8580b968cb2322a163 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0x05d696ca7efb4f1c595f2c87dcfd519dcc41e5fea41aea29875b822b71610a63Stake131225162021-12-02 5:35:2722 mins ago0xddbe82a61a7b61df7019af3a4c8782e4d3490e50 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.00037856
0x4bcd8c2e996123ccec256e146e9b91cbda9c99d5f3ec73c80a1e57f469a322afStake131223172021-12-02 5:25:2932 mins ago0x358da3eaed07abb72be721a73c407939d958fd0c IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.00045356
0x025c0d184304afc2df4459f8636d09d2547b0b9f969f3334e62813c91979a0a3Stake131222112021-12-02 5:20:1137 mins ago0x8f7116a597c21fcbe350000a86298ffb5c40edd1 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
0xc977dff53043b3c7c294b8b0ac2ff4469bbb4029f8ee3e692262dc028f0c6dddStake131221922021-12-02 5:19:1438 mins ago0x1ed1c5a5c4551ca44c94f478aa84c50018485a5f IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
0xb19a64eaa9e9258b52696ce5c4c5c68f9acdc3e9c4c32ed7f673242bdda6cab4Stake131221632021-12-02 5:17:4639 mins ago0xeeefc48ef27721737e316b27380e6e16bf37cc18 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0003785
0x792780e26f6d61df6fd692630fbca352d2e7a11d8078323f840682fd2a3aa902Withdraw131220872021-12-02 5:13:5743 mins ago0x63923de54f2e5c509448cb16361e9c372919053b IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0x33bf18269bdfc84c53597959071862a13dabf69adf790e78c170f99d1e30a1e8Withdraw131220442021-12-02 5:11:3846 mins ago0x6d8af8c1de4beff647a1cf9bf1efb430ded12056 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0x76435e164ccebde507725128ec9e3a0972dc3a44dadc9e1201e0e8d6c29af37dWithdraw131220252021-12-02 5:10:4147 mins ago0xc5a67f1a620b0514e8c07441363cd32fcad3f6b8 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0xe3d01792fa3fe8e13c05c42119019dda74777d0565ef4c8c723b68ac054ffe73Withdraw131219212021-12-02 5:05:2652 mins ago0x2825b7061507ea906b7a031465cced40af37b63d IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0xe1908e613e9c5e5dea2cd8c6256d6adbede5e4a56a16ca723b4458a99634b06aStake131218832021-12-02 5:03:3254 mins ago0x299a00de651254291ca2c4f1c0f6dba925464c61 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0003785
0x9691b2c9731a87fc5942cf3bcff71a3be3694c4e687dff305227b2981d424240Stake131218652021-12-02 5:02:3855 mins ago0x9c37e4356bb8d8fe1b75f455b89cb49823255094 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.00045344
0x7abf04539a48c5dac2cfa2c41c95d949686c57bdd2fa14a1a0148efddfacd6c2Withdraw131218302021-12-02 5:00:5256 mins ago0x0881bdc3b797d42323b54bba2f4ee06d3dc221aa IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0x48d5382189d99bbd2bd80f68e977af3696a2b7de79e84aa07d144addc9d251aaStake131217922021-12-02 4:58:5858 mins ago0xc44d73d91cc1f323aa184b8f07de4b304453755f IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
0x1ff4a331045a5ffb06d4f058d9b5a9b46bee04fe41cd66c5e22680c80cab256cStake131217422021-12-02 4:56:281 hr 1 min ago0xd02cdb3dff97cedca2fea8ad52a01f842bef75c7 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
0xc4f5621da62a5d0c4d43996dc23ad619bb99e8e2acf3fdd56f9531b5b423b97bWithdraw131216752021-12-02 4:52:561 hr 4 mins ago0x3c70f316c80a512ab317c0e0a8ec6a290ead6852 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0xdccab76d618e6367c8a6d8b992d742a5cbd51fe9f1dd3841bdb775a5cd12d2ecStake131216532021-12-02 4:51:451 hr 5 mins ago0xf49d98677c0cd4170ae88083b484c5b3f3055ccd IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
0xcc49942230bd420e23d57975f7f3efa3eafb6301ae50f12428fe05d3875421b9Stake131216322021-12-02 4:50:421 hr 7 mins ago0x7374a0b9db0a66d80e5a42ebb7b2cc471b707f84 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
0xd9f02860327df2ba90dcd44d2bb6910f95ea8d528f5fdbbff492f1829bdaae60Withdraw131215812021-12-02 4:48:091 hr 9 mins ago0xde52c8468fea398c14936ce9ecbbe18d5b12f427 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000508875
0xc3fac088eecf575b620783bbe75cb7cc215524747009041e36f71e2b136224cfStake131215732021-12-02 4:47:451 hr 9 mins ago0x8c99bf516ae468506770d65662433f23ec8a713d IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004745
0x69b5a190ce9cc48cc51471e5ac45f2f0861632087bf3abe3ca55bed67f277f2fWithdraw131215632021-12-02 4:47:151 hr 10 mins ago0x023c21b381fd91fa6eb9482b2fa87a1f31b75563 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000433875
0x05791ba0e0477365ae9678f74a5ee0106c04984f4dcf3daef0caabf4d90282d4Stake131215032021-12-02 4:44:011 hr 13 mins ago0x172b292c83bb1e2a536dde0eb59f830e5d789228 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004745
0xe9790e693a75dd8d3d5006cb4b8b6f6ac6a9ee3237ef502266993fc0ab28ebe3Withdraw131214862021-12-02 4:43:051 hr 14 mins ago0x1171714ec1bb4a649ea6f9aa36c2b076be8ef3aa IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.000433815
0x5ec95725c768410605d0208b3a4936b5eb7bf02cac4219b649b46cbaa91ca460Stake131214822021-12-02 4:42:531 hr 14 mins ago0x29ce576899c9763953429e76fb4d6399f9cb4717 IN  0xd558675a8c8e1fd45002010bac970b115163de3a0 BNB0.0004535
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
PolsStake

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 800 runs

Other Settings:
default evmVersion
File 1 of 11 : PolsStake.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// import "hardhat/console.sol";

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; // OZ contracts v4
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; // OZ contracts v4

contract PolsStake is AccessControl, ReentrancyGuard {
    using SafeERC20 for IERC20;

    // bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");

    event Stake(address indexed wallet, uint256 amount, uint256 date);
    event Withdraw(address indexed wallet, uint256 amount, uint256 date);
    event Claimed(address indexed wallet, address indexed rewardToken, uint256 amount);

    event RewardTokenChanged(address indexed oldRewardToken, uint256 returnedAmount, address indexed newRewardToken);
    event LockTimePeriodChanged(uint48 lockTimePeriod);
    event StakeRewardFactorChanged(uint256 stakeRewardFactor);
    event StakeRewardEndTimeChanged(uint48 stakeRewardEndTime);
    event RewardsBurned(address indexed staker, uint256 amount);
    event ERC20TokensRemoved(address indexed tokenAddress, address indexed receiver, uint256 amount);

    uint48 public constant MAX_TIME = type(uint48).max; // = 2^48 - 1

    struct User {
        uint48 stakeTime;
        uint48 unlockTime;
        uint160 stakeAmount;
        uint256 accumulatedRewards;
    }

    mapping(address => User) public userMap;

    uint256 public tokenTotalStaked; // sum of all staked tokens

    address public immutable stakingToken; // address of token which can be staked into this contract
    address public rewardToken; // address of reward token

    /**
     * Using block.timestamp instead of block.number for reward calculation
     * 1) Easier to handle for users
     * 2) Should result in same rewards across different chain with different block times
     * 3) "The current block timestamp must be strictly larger than the timestamp of the last block, ...
     *     but the only guarantee is that it will be somewhere between the timestamps ...
     *     of two consecutive blocks in the canonical chain."
     *    https://docs.soliditylang.org/en/v0.7.6/cheatsheet.html?highlight=block.timestamp#global-variables
     */

    uint48 public lockTimePeriod; // time in seconds a user has to wait after calling unlock until staked token can be withdrawn
    uint48 public stakeRewardEndTime; // unix time in seconds when the reward scheme will end
    uint256 public stakeRewardFactor; // time in seconds * amount of staked token to receive 1 reward token

    constructor(address _stakingToken, uint48 _lockTimePeriod) {
        require(_stakingToken != address(0), "stakingToken.address == 0");
        require(_lockTimePeriod < 366 days, "lockTimePeriod >= 366 days");
        stakingToken = _stakingToken;
        lockTimePeriod = _lockTimePeriod;
        // set some defaults
        stakeRewardFactor = 1000 * 1 days; // default : a user has to stake 1000 token for 1 day to receive 1 reward token
        stakeRewardEndTime = uint48(block.timestamp + 366 days); // default : reward scheme ends in 1 year
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    /**
     * based on OpenZeppelin SafeCast v4.3
     * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.3/contracts/utils/math/SafeCast.sol
     */

    function toUint48(uint256 value) internal pure returns (uint48) {
        require(value <= type(uint48).max, "value doesn't fit in 48 bits");
        return uint48(value);
    }

    function toUint160(uint256 value) internal pure returns (uint160) {
        require(value <= type(uint160).max, "value doesn't fit in 160 bits");
        return uint160(value);
    }

    /**
     * External API functions
     */

    function stakeTime(address _staker) external view returns (uint48 dateTime) {
        return userMap[_staker].stakeTime;
    }

    function stakeAmount(address _staker) external view returns (uint256 balance) {
        return userMap[_staker].stakeAmount;
    }

    // redundant with stakeAmount() for compatibility
    function balanceOf(address _staker) external view returns (uint256 balance) {
        return userMap[_staker].stakeAmount;
    }

    function userAccumulatedRewards(address _staker) external view returns (uint256 rewards) {
        return userMap[_staker].accumulatedRewards;
    }

    /**
     * @dev return unix epoch time when staked tokens will be unlocked
     * @dev return MAX_INT_UINT48 = 2**48-1 if user has no token staked
     * @dev this always allows an easy check with : require(block.timestamp > getUnlockTime(account));
     * @return unlockTime unix epoch time in seconds
     */
    function getUnlockTime(address _staker) public view returns (uint48 unlockTime) {
        return userMap[_staker].stakeAmount > 0 ? userMap[_staker].unlockTime : MAX_TIME;
    }

    /**
     * @return balance of reward tokens held by this contract
     */
    function getRewardTokenBalance() public view returns (uint256 balance) {
        if (rewardToken == address(0)) return 0;
        balance = IERC20(rewardToken).balanceOf(address(this));
        if (stakingToken == rewardToken) {
            balance -= tokenTotalStaked;
        }
    }

    // onlyOwner / DEFAULT_ADMIN_ROLE functions --------------------------------------------------

    /**
     * @notice setting rewardToken to address(0) disables claim/mint
     * @notice if there was a reward token set before, return remaining tokens to msg.sender/admin
     * @param newRewardToken address
     */
    function setRewardToken(address newRewardToken) external nonReentrant onlyRole(DEFAULT_ADMIN_ROLE) {
        address oldRewardToken = rewardToken;
        uint256 rewardBalance = getRewardTokenBalance(); // balance of oldRewardToken
        if (rewardBalance > 0) {
            IERC20(oldRewardToken).safeTransfer(msg.sender, rewardBalance);
        }
        rewardToken = newRewardToken;
        emit RewardTokenChanged(oldRewardToken, rewardBalance, newRewardToken);
    }

    /**
     * @notice set time a user has to wait after calling unlock until staked token can be withdrawn
     * @param _lockTimePeriod time in seconds
     */
    function setLockTimePeriod(uint48 _lockTimePeriod) external onlyRole(DEFAULT_ADMIN_ROLE) {
        lockTimePeriod = _lockTimePeriod;
        emit LockTimePeriodChanged(_lockTimePeriod);
    }

    /**
     * @notice see calculateUserClaimableReward() docs
     * @dev requires that reward token has the same decimals as stake token
     * @param _stakeRewardFactor time in seconds * amount of staked token to receive 1 reward token
     */
    function setStakeRewardFactor(uint256 _stakeRewardFactor) external onlyRole(DEFAULT_ADMIN_ROLE) {
        stakeRewardFactor = _stakeRewardFactor;
        emit StakeRewardFactorChanged(_stakeRewardFactor);
    }

    /**
     * @notice set block time when stake reward scheme will end
     * @param _stakeRewardEndTime unix time in seconds
     */
    function setStakeRewardEndTime(uint48 _stakeRewardEndTime) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(stakeRewardEndTime > block.timestamp, "time has to be in the future");
        stakeRewardEndTime = _stakeRewardEndTime;
        emit StakeRewardEndTimeChanged(_stakeRewardEndTime);
    }

    /**
     * ADMIN_ROLE has to set BURNER_ROLE
     * allows an external (lottery token sale) contract to substract rewards
     */
    function burnRewards(address _staker, uint256 _amount) external onlyRole(BURNER_ROLE) {
        User storage user = _updateRewards(_staker);

        if (_amount < user.accumulatedRewards) {
            user.accumulatedRewards -= _amount; // safe
        } else {
            user.accumulatedRewards = 0; // burn at least all what's there
        }
        emit RewardsBurned(_staker, _amount);
    }

    /** msg.sender external view convenience functions *********************************/

    function stakeAmount_msgSender() public view returns (uint256) {
        return userMap[msg.sender].stakeAmount;
    }

    function stakeTime_msgSender() external view returns (uint48) {
        return userMap[msg.sender].stakeTime;
    }

    function getUnlockTime_msgSender() external view returns (uint48 unlockTime) {
        return getUnlockTime(msg.sender);
    }

    function userClaimableRewards_msgSender() external view returns (uint256) {
        return userClaimableRewards(msg.sender);
    }

    function userAccumulatedRewards_msgSender() external view returns (uint256) {
        return userMap[msg.sender].accumulatedRewards;
    }

    function userTotalRewards_msgSender() external view returns (uint256) {
        return userTotalRewards(msg.sender);
    }

    function getEarnedRewardTokens_msgSender() external view returns (uint256) {
        return getEarnedRewardTokens(msg.sender);
    }

    /** public external view functions (also used internally) **************************/

    /**
     * calculates unclaimed rewards
     * unclaimed rewards = expired time since last stake/unstake transaction * current staked amount
     *
     * We have to cover 6 cases here :
     * 1) block time < stake time < end time   : should never happen => error
     * 2) block time < end time   < stake time : should never happen => error
     * 3) end time   < block time < stake time : should never happen => error
     * 4) end time   < stake time < block time : staked after reward period is over => no rewards
     * 5) stake time < block time < end time   : end time in the future
     * 6) stake time < end time   < block time : end time in the past & staked before
     * @param _staker address
     * @return claimableRewards = timePeriod * stakeAmount
     */
    function userClaimableRewards(address _staker) public view returns (uint256) {
        User storage user = userMap[_staker];
        // case 1) 2) 3)
        // stake time in the future - should never happen - actually an (internal ?) error
        if (block.timestamp <= user.stakeTime) return 0;

        // case 4)
        // staked after reward period is over => no rewards
        // end time < stake time < block time
        if (stakeRewardEndTime <= user.stakeTime) return 0;

        uint256 timePeriod;

        // case 5
        // we have not reached the end of the reward period
        // stake time < block time < end time
        if (block.timestamp <= stakeRewardEndTime) {
            timePeriod = block.timestamp - user.stakeTime; // covered by case 1) 2) 3) 'if'
        } else {
            // case 6
            // user staked before end of reward period , but that is in the past now
            // stake time < end time < block time
            timePeriod = stakeRewardEndTime - user.stakeTime; // covered case 4)
        }

        return timePeriod * user.stakeAmount;
    }

    function userTotalRewards(address _staker) public view returns (uint256) {
        return userClaimableRewards(_staker) + userMap[_staker].accumulatedRewards;
    }

    function getEarnedRewardTokens(address _staker) public view returns (uint256 claimableRewardTokens) {
        if (address(rewardToken) == address(0) || stakeRewardFactor == 0) {
            return 0;
        } else {
            return userTotalRewards(_staker) / stakeRewardFactor; // safe
        }
    }

    /**
     *  @dev whenver the staked balance changes do ...
     *
     *  @dev calculate userClaimableRewards = previous staked amount * (current time - last stake time)
     *  @dev add userClaimableRewards to userAccumulatedRewards
     *  @dev reset userClaimableRewards to 0 by setting stakeTime to current time
     *  @dev not used as doing it inline, local, within a function consumes less gas
     *
     *  @return user reference pointer for further processing
     */
    function _updateRewards(address _staker) internal returns (User storage user) {
        // calculate reward credits using previous staking amount and previous time period
        // add new reward credits to already accumulated reward credits
        user = userMap[_staker];
        user.accumulatedRewards += userClaimableRewards(_staker);

        // update stake Time to current time (start new reward period)
        // will also reset userClaimableRewards()
        user.stakeTime = toUint48(block.timestamp);
    }

    /**
     * add stake token to staking pool
     * @dev requires the token to be approved for transfer
     * @dev we assume that (our) stake token is not malicious, so no special checks
     * @param _amount of token to be staked
     */
    function _stake(uint256 _amount) internal returns (uint256) {
        require(_amount > 0, "stake amount must be > 0");

        User storage user = _updateRewards(msg.sender); // update rewards and return reference to user

        user.stakeAmount = toUint160(user.stakeAmount + _amount);
        tokenTotalStaked += _amount;

        user.unlockTime = toUint48(block.timestamp + lockTimePeriod);

        // using SafeERC20 for IERC20 => will revert in case of error
        IERC20(stakingToken).safeTransferFrom(msg.sender, address(this), _amount);

        emit Stake(msg.sender, _amount, toUint48(block.timestamp)); // = user.stakeTime
        return _amount;
    }

    /**
     * withdraw staked token, ...
     * do not withdraw rewards token (it might not be worth the gas)
     * @return amount of tokens sent to user's account
     */
    function _withdraw(uint256 amount) internal returns (uint256) {
        require(amount > 0, "amount to withdraw not > 0");
        require(block.timestamp > getUnlockTime(msg.sender), "staked tokens are still locked");

        User storage user = _updateRewards(msg.sender); // update rewards and return reference to user

        require(amount <= user.stakeAmount, "withdraw amount > staked amount");
        user.stakeAmount -= toUint160(amount);
        tokenTotalStaked -= amount;

        // using SafeERC20 for IERC20 => will revert in case of error
        IERC20(stakingToken).safeTransfer(msg.sender, amount);

        emit Withdraw(msg.sender, amount, toUint48(block.timestamp)); // = user.stakeTime
        return amount;
    }

    /**
     * claim reward tokens for accumulated reward credits
     * ... but do not unstake staked token
     */
    function _claim() internal returns (uint256) {
        require(rewardToken != address(0), "no reward token contract");
        uint256 earnedRewardTokens = getEarnedRewardTokens(msg.sender);
        require(earnedRewardTokens > 0, "no tokens to claim");

        // like _updateRewards() , but reset all rewards to 0
        User storage user = userMap[msg.sender];
        user.accumulatedRewards = 0;
        user.stakeTime = toUint48(block.timestamp); // will reset userClaimableRewards to 0
        // user.stakeAmount = unchanged

        require(earnedRewardTokens <= getRewardTokenBalance(), "not enough reward tokens"); // redundant but dedicated error message
        IERC20(rewardToken).safeTransfer(msg.sender, earnedRewardTokens);

        emit Claimed(msg.sender, rewardToken, earnedRewardTokens);
        return earnedRewardTokens;
    }

    function stake(uint256 _amount) external nonReentrant returns (uint256) {
        return _stake(_amount);
    }

    function claim() external nonReentrant returns (uint256) {
        return _claim();
    }

    function withdraw(uint256 amount) external nonReentrant returns (uint256) {
        return _withdraw(amount);
    }

    function withdrawAll() external nonReentrant returns (uint256) {
        return _withdraw(stakeAmount_msgSender());
    }

    /**
     * Do not accept accidently sent ETH :
     * If neither a receive Ether nor a payable fallback function is present,
     * the contract cannot receive Ether through regular transactions and throws an exception.
     * https://docs.soliditylang.org/en/v0.8.7/contracts.html#receive-ether-function
     */

    /**
     * @notice withdraw accidently sent ERC20 tokens
     * @param _tokenAddress address of token to withdraw
     */
    function removeOtherERC20Tokens(address _tokenAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(_tokenAddress != address(stakingToken), "can not withdraw staking token");
        uint256 balance = IERC20(_tokenAddress).balanceOf(address(this));
        IERC20(_tokenAddress).safeTransfer(msg.sender, balance);
        emit ERC20TokensRemoved(_tokenAddress, msg.sender, balance);
    }
}

File 2 of 11 : AccessControl.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
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;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    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) private {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

File 3 of 11 : ReentrancyGuard.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract 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;

    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 make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

File 4 of 11 : SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    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");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

File 5 of 11 : IAccessControl.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

File 6 of 11 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

File 7 of 11 : Strings.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

File 8 of 11 : ERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

File 9 of 11 : IERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * 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[EIP 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);
}

File 10 of 11 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @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);
}

File 11 of 11 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

Settings
{
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 800
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_stakingToken","type":"address"},{"internalType":"uint48","name":"_lockTimePeriod","type":"uint48"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":true,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20TokensRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint48","name":"lockTimePeriod","type":"uint48"}],"name":"LockTimePeriodChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"returnedAmount","type":"uint256"},{"indexed":true,"internalType":"address","name":"newRewardToken","type":"address"}],"name":"RewardTokenChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsBurned","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":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"date","type":"uint256"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint48","name":"stakeRewardEndTime","type":"uint48"}],"name":"StakeRewardEndTimeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"stakeRewardFactor","type":"uint256"}],"name":"StakeRewardFactorChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"date","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BURNER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TIME","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burnRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"getEarnedRewardTokens","outputs":[{"internalType":"uint256","name":"claimableRewardTokens","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEarnedRewardTokens_msgSender","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardTokenBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"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":"address","name":"_staker","type":"address"}],"name":"getUnlockTime","outputs":[{"internalType":"uint48","name":"unlockTime","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUnlockTime_msgSender","outputs":[{"internalType":"uint48","name":"unlockTime","type":"uint48"}],"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":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockTimePeriod","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"}],"name":"removeOtherERC20Tokens","outputs":[],"stateMutability":"nonpayable","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":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint48","name":"_lockTimePeriod","type":"uint48"}],"name":"setLockTimePeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRewardToken","type":"address"}],"name":"setRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint48","name":"_stakeRewardEndTime","type":"uint48"}],"name":"setStakeRewardEndTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stakeRewardFactor","type":"uint256"}],"name":"setStakeRewardFactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"stakeAmount","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeAmount_msgSender","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeRewardEndTime","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeRewardFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"stakeTime","outputs":[{"internalType":"uint48","name":"dateTime","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeTime_msgSender","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"tokenTotalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"userAccumulatedRewards","outputs":[{"internalType":"uint256","name":"rewards","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"userAccumulatedRewards_msgSender","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"userClaimableRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"userClaimableRewards_msgSender","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userMap","outputs":[{"internalType":"uint48","name":"stakeTime","type":"uint48"},{"internalType":"uint48","name":"unlockTime","type":"uint48"},{"internalType":"uint160","name":"stakeAmount","type":"uint160"},{"internalType":"uint256","name":"accumulatedRewards","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_staker","type":"address"}],"name":"userTotalRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"userTotalRewards_msgSender","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000007e624fa0e1c4abfd309cc15719b7e2580887f5700000000000000000000000000000000000000000000000000000000000093a80

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x7e624fa0e1c4abfd309cc15719b7e2580887f570
Arg [1] : _lockTimePeriod (uint48): 604800

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000007e624fa0e1c4abfd309cc15719b7e2580887f570
Arg [1] : 0000000000000000000000000000000000000000000000000000000000093a80


Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.