Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
/*

██████╗ ███████╗██████╗  █████╗ ███████╗███████╗
██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔════╝██╔════╝
██║  ██║█████╗  ██████╔╝███████║███████╗█████╗  
██║  ██║██╔══╝  ██╔══██╗██╔══██║╚════██║██╔══╝  
██████╔╝███████╗██████╔╝██║  ██║███████║███████╗
╚═════╝ ╚══════╝╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝
                                               

* Debase: RandomizedCounter.sol
* Description:
* Counts rebases and distributes rewards when a random threshold is triggered.
* Coded by: punkUnknown
*/

pragma solidity >=0.6.6;

import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/math/Math.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/upgrades/contracts/Initializable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

interface IRandomNumberConsumer {
    function getRandomNumber(uint256 userProvidedSeed) external;

    function fee() external view returns (uint256);
}

contract LPTokenWrapper {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 public y;

    function setStakeToken(address _y) internal {
        y = IERC20(_y);
    }

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function stake(uint256 amount) public virtual {
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        y.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(uint256 amount) public virtual {
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        y.safeTransfer(msg.sender, amount);
    }
}

contract RandomizedCounter is
    Ownable,
    Initializable,
    LPTokenWrapper,
    ReentrancyGuard
{
    using Address for address;

    event LogEmergencyWithdraw(uint256 timestamp);
    event LogSetCountThreshold(uint256 countThreshold_);
    event LogSetBeforePeriodFinish(bool beforePeriodFinish_);
    event LogSetCountInSequence(bool countInSequence_);
    event LogSetRewardPercentage(uint256 rewardPercentage_);
    event LogSetRevokeReward(bool revokeReward_);
    event LogSetRevokeRewardPrecentage(uint256 revokeRewardPrecentage_);
    event LogSetNormalDistribution(
        uint256 noramlDistributionMean_,
        uint256 normalDistributionDeviation_,
        uint256[100] normalDistribution_
    );
    event LogSetRandomNumberConsumer(
        IRandomNumberConsumer randomNumberConsumer_
    );
    event LogSetMultiSigAddress(address multiSigAddress_);
    event LogSetMultiSigRewardPercentage(uint256 multiSigRewardPercentage_);
    event LogRevokeRewardDuration(uint256 revokeRewardDuration_);
    event LogLastRandomThreshold(uint256 lastRandomThreshold_);
    event LogSetBlockDuration(uint256 blockDuration_);
    event LogStartNewDistributionCycle(
        uint256 poolShareAdded_,
        uint256 rewardRate_,
        uint256 periodFinish_,
        uint256 count_
    );
    event LogRandomThresold(uint256 randomNumber);
    event LogSetPoolEnabled(bool poolEnabled_);
    event LogSetEnableUserLpLimit(bool enableUserLpLimit_);
    event LogSetEnablePoolLpLimit(bool enablePoolLpLimit_);
    event LogSetUserLpLimit(uint256 userLpLimit_);
    event LogSetPoolLpLimit(uint256 poolLpLimit_);
    event LogRewardsClaimed(uint256 rewardAmount_);
    event LogRewardAdded(uint256 reward);
    event LogRewardRevoked(
        uint256 revokeDuratoin,
        uint256 precentageRevoked,
        uint256 amountRevoked
    );
    event LogClaimRevoked(uint256 claimAmountRevoked_);
    event LogStaked(address indexed user, uint256 amount);
    event LogWithdrawn(address indexed user, uint256 amount);
    event LogRewardPaid(address indexed user, uint256 reward);
    event LogManualPoolStarted(uint256 startedAt);

    IERC20 public debase;
    address public policy;
    bool public poolEnabled;

    uint256 public periodFinish;
    uint256 public rewardRate;
    uint256 public lastUpdateBlock;
    uint256 public rewardPerTokenStored;
    uint256 public rewardPercentage;
    uint256 public rewardDistributed;

    uint256 public blockDuration;

    //Flag to enable amount of lp that can be staked by a account
    bool public enableUserLpLimit;
    //Amount of lp that can be staked by a account
    uint256 public userLpLimit;

    //Flag to enable total amount of lp that can be staked by all users
    bool public enablePoolLpLimit;
    //Total amount of lp tat can be staked
    uint256 public poolLpLimit;

    uint256 public revokeRewardDuration;

    // Should revoke reward
    bool public revokeReward;

    uint256 public lastRewardPercentage;

    // The count of s hitting their target
    uint256 public count;

    // Flag to enable or disable   sequence checker
    bool public countInSequence;

    bool public newBufferFunds;

    // Address for the random number contract (chainlink vrf)
    IRandomNumberConsumer public randomNumberConsumer;

    //Address of the link token
    IERC20 public link;

    // Flag to send reward before stabilizer pool period time finished
    bool public beforePeriodFinish;

    // The mean for the normal distribution added
    uint256 public normalDistributionMean;

    // The deviation for te normal distribution added
    uint256 public normalDistributionDeviation;

    // The array of normal distribution value data
    uint256[100] public normalDistribution;

    address public multiSigAddress;
    uint256 public multiSigRewardPercentage;
    uint256 public multiSigRewardToClaimShare;

    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    modifier enabled() {
        require(poolEnabled, "Pool isn't enabled");
        _;
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateBlock = lastBlockRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    /**
     * @notice Function to set how much reward the stabilizer will request
     */
    function setRewardPercentage(uint256 rewardPercentage_) external onlyOwner {
        rewardPercentage = rewardPercentage_;
        emit LogSetRewardPercentage(rewardPercentage);
    }

    /**
     * @notice Function to enable or disable count should be in sequence
     */
    function setCountInSequence(bool countInSequence_) external onlyOwner {
        countInSequence = countInSequence_;
        count = 0;
        emit LogSetCountInSequence(!countInSequence);
    }

    /**
     * @notice Function to enable or disable reward revoking
     */
    function setRevokeReward(bool revokeReward_) external onlyOwner {
        revokeReward = revokeReward_;
        emit LogSetRevokeReward(revokeReward);
    }

    /**
     * @notice Function to set how much of the reward duration should be revoked
     */
    function setRevokeRewardDuration(uint256 revokeRewardDuration_)
        external
        onlyOwner
    {
        revokeRewardDuration = revokeRewardDuration_;
        emit LogRevokeRewardDuration(revokeRewardDuration);
    }

    /**
     * @notice Function to allow reward distribution before previous rewards have been distributed
     */
    function setBeforePeriodFinish(bool beforePeriodFinish_)
        external
        onlyOwner
    {
        beforePeriodFinish = beforePeriodFinish_;
        emit LogSetBeforePeriodFinish(beforePeriodFinish);
    }

    /**
     * @notice Function to set reward drop period
     */
    function setBlockDuration(uint256 blockDuration_) external onlyOwner {
        require(blockDuration >= 1);
        blockDuration = blockDuration_;
        emit LogSetBlockDuration(blockDuration);
    }

    /**
     * @notice Function enabled or disable pool staking,withdraw
     */
    function setPoolEnabled(bool poolEnabled_) external onlyOwner {
        poolEnabled = poolEnabled_;
        count = 0;
        emit LogSetPoolEnabled(poolEnabled);
    }

    /**
     * @notice Function to enable user lp limit
     */
    function setEnableUserLpLimit(bool enableUserLpLimit_) external onlyOwner {
        enableUserLpLimit = enableUserLpLimit_;
        emit LogSetEnableUserLpLimit(enableUserLpLimit);
    }

    /**
     * @notice Function to set user lp limit
     */
    function setUserLpLimit(uint256 userLpLimit_) external onlyOwner {
        require(
            userLpLimit_ <= poolLpLimit,
            "User lp limit cant be more than pool limit"
        );
        userLpLimit = userLpLimit_;
        emit LogSetUserLpLimit(userLpLimit);
    }

    /**
     * @notice Function to enable pool lp limit
     */
    function setEnablePoolLpLimit(bool enablePoolLpLimit_) external onlyOwner {
        enablePoolLpLimit = enablePoolLpLimit_;
        emit LogSetEnablePoolLpLimit(enablePoolLpLimit);
    }

    /**
     * @notice Function to set pool lp limit
     */
    function setPoolLpLimit(uint256 poolLpLimit_) external onlyOwner {
        require(
            poolLpLimit_ >= userLpLimit,
            "Pool lp limit cant be less than user lp limit"
        );
        poolLpLimit = poolLpLimit_;
        emit LogSetPoolLpLimit(poolLpLimit);
    }

    /**
     * @notice Function to set address of the random number consumer (chain link vrf)
     */
    function setRandomNumberConsumer(
        IRandomNumberConsumer randomNumberConsumer_
    ) external onlyOwner {
        randomNumberConsumer = IRandomNumberConsumer(randomNumberConsumer_);
        emit LogSetRandomNumberConsumer(randomNumberConsumer);
    }

    function setMultiSigRewardPercentage(uint256 multiSigRewardPercentage_)
        external
        onlyOwner
    {
        multiSigRewardPercentage = multiSigRewardPercentage_;
        emit LogSetMultiSigRewardPercentage(multiSigRewardPercentage);
    }

    function setMultiSigAddress(address multiSigAddress_) external onlyOwner {
        multiSigAddress = multiSigAddress_;
        emit LogSetMultiSigAddress(multiSigAddress);
    }

    /**
     * @notice Function to set the normal distribution array and its associated mean/deviation
     */
    function setNormalDistribution(
        uint256 normalDistributionMean_,
        uint256 normalDistributionDeviation_,
        uint256[100] calldata normalDistribution_
    ) external onlyOwner {
        normalDistributionMean = normalDistributionMean_;
        normalDistributionDeviation = normalDistributionDeviation_;
        normalDistribution = normalDistribution_;
        emit LogSetNormalDistribution(
            normalDistributionMean,
            normalDistributionDeviation,
            normalDistribution
        );
    }

    function initialize(
        address debase_,
        address pairToken_,
        address policy_,
        address randomNumberConsumer_,
        address link_,
        uint256 rewardPercentage_,
        uint256 blockDuration_,
        bool enableUserLpLimit_,
        uint256 userLpLimit_,
        bool enablePoolLpLimit_,
        uint256 poolLpLimit_,
        uint256 revokeRewardDuration_,
        uint256 normalDistributionMean_,
        uint256 normalDistributionDeviation_,
        uint256[100] memory normalDistribution_
    ) public initializer {
        setStakeToken(pairToken_);
        debase = IERC20(debase_);
        link = IERC20(link_);
        randomNumberConsumer = IRandomNumberConsumer(randomNumberConsumer_);
        policy = policy_;
        count = 0;

        blockDuration = blockDuration_;
        enableUserLpLimit = enableUserLpLimit_;
        userLpLimit = userLpLimit_;
        enablePoolLpLimit = enablePoolLpLimit_;
        poolLpLimit = poolLpLimit_;
        rewardPercentage = rewardPercentage_;
        revokeRewardDuration = revokeRewardDuration_;
        countInSequence = true;
        normalDistribution = normalDistribution_;
        normalDistributionMean = normalDistributionMean_;
        normalDistributionDeviation = normalDistributionDeviation_;
    }

    /**
     * @notice When a rebase happens this function is called by the rebase function. If the supplyDelta is positive (supply increase) a random
     * will be constructed using Chainlink VRF. The mod of the random number is taken to get a number between 0-100. This result
     * is used as a index to get a number from the normal distribution array. The number returned will be compared against the current count of
     * positive rebases and if the count is equal to or greater that the number obtained from array, then the pool will request rewards from the stabilizer pool.
     */
    function checkStabilizerAndGetReward(
        int256 supplyDelta_,
        int256 rebaseLag_,
        uint256 exchangeRate_,
        uint256 debasePolicyBalance
    ) external returns (uint256 rewardAmount_) {
        require(
            msg.sender == policy,
            "Only debase policy contract can call this"
        );

        if (newBufferFunds) {
            uint256 previousUnusedRewardToClaim =
                debase.totalSupply().mul(lastRewardPercentage).div(10**18);

            if (
                debase.balanceOf(address(this)) >= previousUnusedRewardToClaim
            ) {
                debase.safeTransfer(policy, previousUnusedRewardToClaim);
                emit LogRewardsClaimed(previousUnusedRewardToClaim);
            }
            newBufferFunds = false;
        }

        if (supplyDelta_ > 0) {
            count = count.add(1);

            // Call random number fetcher only if the random number consumer has link in its balance to do so. Otherwise return 0
            if (
                link.balanceOf(address(randomNumberConsumer)) >=
                randomNumberConsumer.fee() &&
                (beforePeriodFinish || block.number >= periodFinish)
            ) {
                uint256 rewardToClaim =
                    debasePolicyBalance.mul(rewardPercentage).div(10**18);

                uint256 multiSigRewardAmount =
                    rewardToClaim.mul(multiSigRewardPercentage).div(10**18);

                lastRewardPercentage = rewardToClaim.mul(10**18).div(
                    debase.totalSupply()
                );

                multiSigRewardToClaimShare = multiSigRewardAmount
                    .mul(10**18)
                    .div(debase.totalSupply());

                uint256 totalRewardToClaim =
                    rewardToClaim.add(multiSigRewardAmount);

                if (totalRewardToClaim <= debasePolicyBalance) {
                    newBufferFunds = true;
                    randomNumberConsumer.getRandomNumber(block.number);
                    emit LogRewardsClaimed(totalRewardToClaim);
                    return totalRewardToClaim;
                }
            }
        } else if (countInSequence) {
            count = 0;

            if (revokeReward && block.number < periodFinish) {
                uint256 timeRemaining = periodFinish.sub(block.number);
                // Rewards will only be revoked from period after the current period so unclaimed rewards arent taken away.
                if (timeRemaining >= revokeRewardDuration) {
                    //Set reward distribution period back
                    periodFinish = periodFinish.sub(revokeRewardDuration);
                    //Calculate reward to rewark by amount the reward moved back
                    uint256 rewardToRevokeShare =
                        rewardRate.mul(revokeRewardDuration);

                    uint256 rewardToRevokeAmount =
                        debase.totalSupply().mul(rewardToRevokeShare).div(
                            10**18
                        );

                    lastUpdateBlock = block.number;

                    debase.safeTransfer(policy, rewardToRevokeAmount);
                    emit LogRewardRevoked(
                        revokeRewardDuration,
                        rewardToRevokeShare,
                        rewardToRevokeAmount
                    );
                }
            }
        }
        return 0;
    }

    function claimer(uint256 randomNumber) external {
        require(
            msg.sender == address(randomNumberConsumer),
            "Only debase policy contract can call this"
        );
        newBufferFunds = false;

        uint256 lastRandomThreshold = normalDistribution[randomNumber.mod(100)];
        emit LogLastRandomThreshold(lastRandomThreshold);

        if (count >= lastRandomThreshold) {
            startNewDistributionCycle();
            count = 0;

            if (multiSigRewardToClaimShare != 0) {
                uint256 amountToClaim =
                    debase.totalSupply().mul(multiSigRewardToClaimShare).div(
                        10**18
                    );

                debase.transfer(multiSigAddress, amountToClaim);
            }
        } else {
            uint256 rewardToClaim =
                debase.totalSupply().mul(lastRewardPercentage).div(10**18);

            debase.safeTransfer(policy, rewardToClaim);
            emit LogClaimRevoked(rewardToClaim);
        }
    }

    /**
     * @notice Function allows for emergency withdrawal of all reward tokens back into stabilizer fund
     */
    function emergencyWithdraw() external onlyOwner {
        debase.safeTransfer(policy, debase.balanceOf(address(this)));
        emit LogEmergencyWithdraw(block.number);
    }

    function lastBlockRewardApplicable() internal view returns (uint256) {
        return Math.min(block.number, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply() == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored.add(
                lastBlockRewardApplicable()
                    .sub(lastUpdateBlock)
                    .mul(rewardRate)
                    .mul(10**18)
                    .div(totalSupply())
            );
    }

    function earned(address account) public view returns (uint256) {
        return
            balanceOf(account)
                .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
                .div(10**18)
                .add(rewards[account]);
    }

    // stake visibility is public as overriding LPTokenWrapper's stake() function
    function stake(uint256 amount)
        public
        override
        nonReentrant
        updateReward(msg.sender)
        enabled
    {
        require(
            !address(msg.sender).isContract(),
            "Caller must not be a contract"
        );
        require(amount > 0, "Cannot stake 0");

        if (enablePoolLpLimit) {
            uint256 lpBalance = totalSupply();
            require(
                amount.add(lpBalance) <= poolLpLimit,
                "Cant stake pool lp limit reached"
            );
        }
        if (enableUserLpLimit) {
            uint256 userLpBalance = balanceOf(msg.sender);
            require(
                userLpBalance.add(amount) <= userLpLimit,
                "Cant stake more than lp limit"
            );
        }

        super.stake(amount);
        emit LogStaked(msg.sender, amount);
    }

    function withdraw(uint256 amount)
        public
        override
        nonReentrant
        updateReward(msg.sender)
    {
        require(amount > 0, "Cannot withdraw 0");
        super.withdraw(amount);
        emit LogWithdrawn(msg.sender, amount);
    }

    function exit() external {
        withdraw(balanceOf(msg.sender));
        getReward();
    }

    function getReward() public nonReentrant updateReward(msg.sender) enabled {
        uint256 reward = earned(msg.sender);
        if (reward > 0) {
            rewards[msg.sender] = 0;

            uint256 rewardToClaim =
                debase.totalSupply().mul(reward).div(10**18);

            debase.safeTransfer(msg.sender, rewardToClaim);

            emit LogRewardPaid(msg.sender, rewardToClaim);
            rewardDistributed = rewardDistributed.add(reward);
        }
    }

    function startNewDistributionCycle() internal updateReward(address(0)) {
        // https://sips.synthetix.io/sips/sip-77
        require(
            debase.balanceOf(address(this)) < uint256(-1) / 10**18,
            "Rewards: rewards too large, would lock"
        );

        if (block.number >= periodFinish) {
            rewardRate = lastRewardPercentage.div(blockDuration);
        } else {
            uint256 remaining = periodFinish.sub(block.number);
            uint256 leftover = remaining.mul(rewardRate);
            rewardRate = lastRewardPercentage.add(leftover).div(blockDuration);
        }
        lastUpdateBlock = block.number;
        periodFinish = block.number.add(blockDuration);

        emit LogStartNewDistributionCycle(
            lastRewardPercentage,
            rewardRate,
            periodFinish,
            count
        );
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <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);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./IERC20.sol";
import "../../math/SafeMath.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 SafeMath for uint256;
    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'
        // solhint-disable-next-line max-line-length
        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).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

pragma solidity >=0.4.24 <0.7.0;


/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "../GSN/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.
 *
 * By default, the owner account will be the one that deploys the contract. 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 Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <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 () internal {
        _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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <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;
        // solhint-disable-next-line no-inline-assembly
        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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"claimAmountRevoked_","type":"uint256"}],"name":"LogClaimRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"LogEmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"lastRandomThreshold_","type":"uint256"}],"name":"LogLastRandomThreshold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startedAt","type":"uint256"}],"name":"LogManualPoolStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"randomNumber","type":"uint256"}],"name":"LogRandomThresold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"revokeRewardDuration_","type":"uint256"}],"name":"LogRevokeRewardDuration","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"LogRewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"LogRewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"revokeDuratoin","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"precentageRevoked","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountRevoked","type":"uint256"}],"name":"LogRewardRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardAmount_","type":"uint256"}],"name":"LogRewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"beforePeriodFinish_","type":"bool"}],"name":"LogSetBeforePeriodFinish","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"blockDuration_","type":"uint256"}],"name":"LogSetBlockDuration","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"countInSequence_","type":"bool"}],"name":"LogSetCountInSequence","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"countThreshold_","type":"uint256"}],"name":"LogSetCountThreshold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enablePoolLpLimit_","type":"bool"}],"name":"LogSetEnablePoolLpLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enableUserLpLimit_","type":"bool"}],"name":"LogSetEnableUserLpLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"multiSigAddress_","type":"address"}],"name":"LogSetMultiSigAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"multiSigRewardPercentage_","type":"uint256"}],"name":"LogSetMultiSigRewardPercentage","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"noramlDistributionMean_","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"normalDistributionDeviation_","type":"uint256"},{"indexed":false,"internalType":"uint256[100]","name":"normalDistribution_","type":"uint256[100]"}],"name":"LogSetNormalDistribution","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"poolEnabled_","type":"bool"}],"name":"LogSetPoolEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"poolLpLimit_","type":"uint256"}],"name":"LogSetPoolLpLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract IRandomNumberConsumer","name":"randomNumberConsumer_","type":"address"}],"name":"LogSetRandomNumberConsumer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"revokeReward_","type":"bool"}],"name":"LogSetRevokeReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"revokeRewardPrecentage_","type":"uint256"}],"name":"LogSetRevokeRewardPrecentage","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardPercentage_","type":"uint256"}],"name":"LogSetRewardPercentage","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"userLpLimit_","type":"uint256"}],"name":"LogSetUserLpLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"poolShareAdded_","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardRate_","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"periodFinish_","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"count_","type":"uint256"}],"name":"LogStartNewDistributionCycle","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beforePeriodFinish","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"blockDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"supplyDelta_","type":"int256"},{"internalType":"int256","name":"rebaseLag_","type":"int256"},{"internalType":"uint256","name":"exchangeRate_","type":"uint256"},{"internalType":"uint256","name":"debasePolicyBalance","type":"uint256"}],"name":"checkStabilizerAndGetReward","outputs":[{"internalType":"uint256","name":"rewardAmount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"randomNumber","type":"uint256"}],"name":"claimer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"countInSequence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debase","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enablePoolLpLimit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableUserLpLimit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"debase_","type":"address"},{"internalType":"address","name":"pairToken_","type":"address"},{"internalType":"address","name":"policy_","type":"address"},{"internalType":"address","name":"randomNumberConsumer_","type":"address"},{"internalType":"address","name":"link_","type":"address"},{"internalType":"uint256","name":"rewardPercentage_","type":"uint256"},{"internalType":"uint256","name":"blockDuration_","type":"uint256"},{"internalType":"bool","name":"enableUserLpLimit_","type":"bool"},{"internalType":"uint256","name":"userLpLimit_","type":"uint256"},{"internalType":"bool","name":"enablePoolLpLimit_","type":"bool"},{"internalType":"uint256","name":"poolLpLimit_","type":"uint256"},{"internalType":"uint256","name":"revokeRewardDuration_","type":"uint256"},{"internalType":"uint256","name":"normalDistributionMean_","type":"uint256"},{"internalType":"uint256","name":"normalDistributionDeviation_","type":"uint256"},{"internalType":"uint256[100]","name":"normalDistribution_","type":"uint256[100]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastRewardPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"link","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiSigAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiSigRewardPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiSigRewardToClaimShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"newBufferFunds","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"normalDistribution","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"normalDistributionDeviation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"normalDistributionMean","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"policy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLpLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"randomNumberConsumer","outputs":[{"internalType":"contract IRandomNumberConsumer","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revokeReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"revokeRewardDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardDistributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"beforePeriodFinish_","type":"bool"}],"name":"setBeforePeriodFinish","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockDuration_","type":"uint256"}],"name":"setBlockDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"countInSequence_","type":"bool"}],"name":"setCountInSequence","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enablePoolLpLimit_","type":"bool"}],"name":"setEnablePoolLpLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enableUserLpLimit_","type":"bool"}],"name":"setEnableUserLpLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"multiSigAddress_","type":"address"}],"name":"setMultiSigAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"multiSigRewardPercentage_","type":"uint256"}],"name":"setMultiSigRewardPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"normalDistributionMean_","type":"uint256"},{"internalType":"uint256","name":"normalDistributionDeviation_","type":"uint256"},{"internalType":"uint256[100]","name":"normalDistribution_","type":"uint256[100]"}],"name":"setNormalDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"poolEnabled_","type":"bool"}],"name":"setPoolEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"poolLpLimit_","type":"uint256"}],"name":"setPoolLpLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IRandomNumberConsumer","name":"randomNumberConsumer_","type":"address"}],"name":"setRandomNumberConsumer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"revokeReward_","type":"bool"}],"name":"setRevokeReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"revokeRewardDuration_","type":"uint256"}],"name":"setRevokeRewardDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"rewardPercentage_","type":"uint256"}],"name":"setRewardPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"userLpLimit_","type":"uint256"}],"name":"setUserLpLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"userLpLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"y","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

608060405260006100176001600160e01b0361006b16565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600160365561006f565b3390565b613555806200007f6000396000f3fe608060405234801561001057600080fd5b50600436106103b95760003560e01c80637b0a47ee116101f4578063ae9a94fe1161011a578063dcb76686116100ad578063e9483ac01161007c578063e9483ac0146108e4578063e9fad8ee146108ec578063ebe2b12b146108f4578063f2fde38b146108fc576103b9565b8063dcb7668614610896578063dd37f2171461089e578063dd54682d146108bd578063df136d65146108dc576103b9565b8063be46aec6116100e9578063be46aec614610876578063c0c1c9f21461087e578063cd3daf9d14610886578063db2e21bc1461088e576103b9565b8063ae9a94fe14610820578063b43313ea14610849578063b55baee314610851578063bcb31edc14610859576103b9565b80639210466911610192578063a218141b11610161578063a218141b146107eb578063a56dfe4a146107f3578063a694fc3a146107fb578063ad5eb04c14610818576103b9565b8063921046691461076a57806394cc1722146107895780639609930d146107a65780639cd65f97146107c5576103b9565b80638798a9d2116101ce5780638798a9d2146106f05780638b8763471461071f5780638da5cb5b146107455780639161cb881461074d576103b9565b80637b0a47ee146106c35780637c2032e7146106cb57806381ee77c3146106e8576103b9565b80632e1a7d4d116102e4578063560354ab1161027757806370a082311161024657806370a0823114610670578063715018a61461069657806375302c391461069e578063769149cb146106a6576103b9565b8063560354ab1461063b5780635817cd5a146106585780635d649ea9146106605780636422380a14610668576103b9565b806346df22da116102b357806346df22da146105ef578063508a8571146105f7578063529f35e91461061457806352d472eb14610633576103b9565b80632e1a7d4d1461058f57806335a4dfd9146105ac5780633d18b912146105cb578063442cc331146105d3576103b9565b80631516def71161035c5780631fb8784b1161032b5780631fb8784b1461056f578063201e908e14610577578063273ca5101461057f57806327b7566d14610587576103b9565b80631516def71461054f57806318160ddd146105575780631c4695f41461055f5780631ca841b914610567576103b9565b80630700037d116103985780630700037d14610422578063077f2cfc1461044857806309653674146104705780630ce6ca731461048d576103b9565b80628cc262146103be5780630505c8c9146103f657806306661abd1461041a575b600080fd5b6103e4600480360360208110156103d457600080fd5b50356001600160a01b0316610922565b60408051918252519081900360200190f35b6103fe6109a8565b604080516001600160a01b039092168252519081900360200190f35b6103e46109b7565b6103e46004803603602081101561043857600080fd5b50356001600160a01b03166109bd565b61046e6004803603602081101561045e57600080fd5b50356001600160a01b03166109cf565b005b61046e6004803603602081101561048657600080fd5b5035610a81565b61046e6004803603610e408110156104a457600080fd5b60408051610c8081810183526001600160a01b038535811695602081013582169594810135821694606082013583169460808301359093169360a08301359360c08401359360e0810135151593610100820135936101208301351515936101408401359361016081013593610180820135936101a0830135939183019291610e408301916101c08401906064908390839080828437600092019190915250919450610b149350505050565b6103fe610d17565b6103e4610d26565b6103fe610d2d565b6103e4610d3c565b6103e4610d42565b6103e4610d48565b6103e4610d4e565b6103e4610d54565b61046e600480360360208110156105a557600080fd5b5035610d5a565b61046e600480360360208110156105c257600080fd5b50351515610ea3565b61046e610f47565b6105db61117b565b604080519115158252519081900360200190f35b6103fe611189565b61046e6004803603602081101561060d57600080fd5b503561119e565b61046e6004803603602081101561062a57600080fd5b50351515611272565b6103e461132d565b61046e6004803603602081101561065157600080fd5b5035611333565b6105db6113c6565b6105db6113cf565b6103fe6113d8565b6103e46004803603602081101561068657600080fd5b50356001600160a01b03166113e7565b61046e611402565b6105db6114a4565b6103e4600480360360208110156106bc57600080fd5b50356114ad565b6103e46114c1565b61046e600480360360208110156106e157600080fd5b50356114c7565b6103e4611748565b6103e46004803603608081101561070657600080fd5b508035906020810135906040810135906060013561174e565b6103e46004803603602081101561073557600080fd5b50356001600160a01b0316611ddb565b6103fe611ded565b61046e6004803603602081101561076357600080fd5b5035611dfc565b61046e6004803603602081101561078057600080fd5b50351515611ed0565b61046e6004803603602081101561079f57600080fd5b5035611f78565b61046e600480360360208110156107bc57600080fd5b5035151561200b565b61046e600480360360208110156107db57600080fd5b50356001600160a01b03166120af565b6103e461216d565b6103fe612173565b61046e6004803603602081101561081157600080fd5b5035612182565b6105db612477565b61046e6004803603610cc081101561083757600080fd5b50803590602081013590604001612487565b6103e4612568565b6103e461256e565b61046e6004803603602081101561086f57600080fd5b5035612574565b6105db612617565b6105db612627565b6103e4612630565b61046e612689565b6103e46127ae565b61046e600480360360208110156108b457600080fd5b503515156127b4565b61046e600480360360208110156108d357600080fd5b5035151561286a565b6103e461290c565b6103e4612912565b61046e612918565b6103e4612933565b61046e6004803603602081101561091257600080fd5b50356001600160a01b0316612939565b6001600160a01b038116600090815260b4602090815260408083205460b39092528220546109a2919061099690670de0b6b3a76400009061098a9061097590610969612630565b9063ffffffff612a3116565b61097e886113e7565b9063ffffffff612a7a16565b9063ffffffff612ad316565b9063ffffffff612b1516565b92915050565b6038546001600160a01b031681565b60475481565b60b46020526000908152604090205481565b6109d7612b6f565b6000546001600160a01b03908116911614610a27576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b60b080546001600160a01b0319166001600160a01b03838116919091179182905560408051929091168252517f3babdeb15c28ef720787b925e65feba0f02a5e6f3a8f44bc089aad9381ba0271916020908290030190a150565b610a89612b6f565b6000546001600160a01b03908116911614610ad9576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b603d8190556040805182815290517fca5f448edeb07809efa2b7e5d18e0a32311dcf2cace215033ceee706a6ee00239181900360200190a150565b600054600160a81b900460ff1680610b2f5750610b2f612b73565b80610b445750600054600160a01b900460ff16155b610b7f5760405162461bcd60e51b815260040180806020018281038252602e815260200180613471602e913960400191505060405180910390fd5b600054600160a81b900460ff16158015610bb6576000805460ff60a01b1960ff60a81b19909116600160a81b1716600160a01b1790555b610bbf8f612b79565b8f603760006101000a8154816001600160a01b0302191690836001600160a01b031602179055508b604960006101000a8154816001600160a01b0302191690836001600160a01b031602179055508c604860026101000a8154816001600160a01b0302191690836001600160a01b031602179055508d603860006101000a8154816001600160a01b0302191690836001600160a01b03160217905550600060478190555089603f8190555088604060006101000a81548160ff0219169083151502179055508760418190555086604260006101000a81548160ff021916908315150217905550856043819055508a603d81905550846044819055506001604860006101000a81548160ff02191690831515021790555081604c906064610ce6929190613334565b50604a849055604b8390558015610d05576000805460ff60a81b191690555b50505050505050505050505050505050565b60b0546001600160a01b031681565b6034545b90565b6049546001600160a01b031681565b60b25481565b60445481565b603f5481565b60435481565b60b15481565b60026036541415610db2576040805162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015290519081900360640190fd5b600260365533610dc0612630565b603c55610dcb612b9b565b603b556001600160a01b03811615610e1257610de681610922565b6001600160a01b038216600090815260b46020908152604080832093909355603c5460b3909152919020555b60008211610e5b576040805162461bcd60e51b8152602060048201526011602482015270043616e6e6f74207769746864726177203607c1b604482015290519081900360640190fd5b610e6482612ba9565b60408051838152905133917fe0535c2eb3e1755a11a8ee1dba6e7b72ea1487e87be0d02fca7c1038eaacbd5c919081900360200190a250506001603655565b610eab612b6f565b6000546001600160a01b03908116911614610efb576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6042805460ff191682151517908190556040805160ff90921615158252517f14094d8417a433fdc1c983b6b5e17736796f4b29ea67842f51940ee5c1831efc916020908290030190a150565b60026036541415610f9f576040805162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015290519081900360640190fd5b600260365533610fad612630565b603c55610fb8612b9b565b603b556001600160a01b03811615610fff57610fd381610922565b6001600160a01b038216600090815260b46020908152604080832093909355603c5460b3909152919020555b603854600160a01b900460ff16611052576040805162461bcd60e51b8152602060048201526012602482015271141bdbdb081a5cdb89dd08195b98589b195960721b604482015290519081900360640190fd5b600061105d33610922565b905080156111725733600090815260b46020908152604080832083905560375481516318160ddd60e01b8152915161110493670de0b6b3a76400009361098a9388936001600160a01b03909116926318160ddd9260048082019391829003018186803b1580156110cc57600080fd5b505afa1580156110e0573d6000803e3d6000fd5b505050506040513d60208110156110f657600080fd5b50519063ffffffff612a7a16565b603754909150611124906001600160a01b0316338363ffffffff612c0e16565b60408051828152905133917f75a1ecbfe1abd9ef0713e9084387744bef3d38fc1f1fbcbada3abd09c802baee919081900360200190a2603e5461116d908363ffffffff612b1516565b603e55505b50506001603655565b604854610100900460ff1681565b6048546201000090046001600160a01b031681565b6111a6612b6f565b6000546001600160a01b039081169116146111f6576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6041548110156112375760405162461bcd60e51b815260040180806020018281038252602d8152602001806134c9602d913960400191505060405180910390fd5b60438190556040805182815290517fbbb033bebe27fdaf4d3f136969d59ea07defbf3be88e8daa8c333747f6cb6a449181900360200190a150565b61127a612b6f565b6000546001600160a01b039081169116146112ca576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b60388054821515600160a01b90810260ff60a01b1990921691909117918290556000604755604080519190920460ff161515815290517f0fc5960ebe0d769d367a5952c3d384663054acd195413084d4c5e3a71c4a7d859181900360200190a150565b603d5481565b61133b612b6f565b6000546001600160a01b0390811691161461138b576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b60448190556040805182815290517fd16dba6f37311fae894eb27a37aea8c19c3b3024f6832c1a4d27e0bea3fa47569181900360200190a150565b60425460ff1681565b60455460ff1681565b6037546001600160a01b031681565b6001600160a01b031660009081526035602052604090205490565b61140a612b6f565b6000546001600160a01b0390811691161461145a576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b60405460ff1681565b604c81606481106114ba57fe5b0154905081565b603a5481565b6048546201000090046001600160a01b031633146115165760405162461bcd60e51b81526004018080602001828103825260298152602001806133e16029913960400191505060405180910390fd5b6048805461ff00191690556000604c61153683606463ffffffff612c6516565b6064811061154057fe5b01546040805182815290519192507f8f7c13710bc2e58b02640e18873e9cb6c8b4aefdf38dc6e9616c63ddbe4d92eb919081900360200190a180604754106116875761158a612ca7565b600060475560b254156116825760006115f9670de0b6b3a764000061098a60b254603760009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cc57600080fd5b60375460b0546040805163a9059cbb60e01b81526001600160a01b03928316600482015260248101859052905193945091169163a9059cbb916044808201926020929091908290030181600087803b15801561165457600080fd5b505af1158015611668573d6000803e3d6000fd5b505050506040513d602081101561167e57600080fd5b5050505b611744565b60006116e9670de0b6b3a764000061098a604654603760009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cc57600080fd5b60385460375491925061170f916001600160a01b0390811691168363ffffffff612c0e16565b6040805182815290517fe7b1673165332a48801f9a6ff982390fcce303f97a6849f2c730863cc558fcc59181900360200190a1505b5050565b60415481565b6038546000906001600160a01b0316331461179a5760405162461bcd60e51b81526004018080602001828103825260298152602001806133e16029913960400191505060405180910390fd5b604854610100900460ff16156118f157600061180c670de0b6b3a764000061098a604654603760009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cc57600080fd5b603754604080516370a0823160e01b8152306004820152905192935083926001600160a01b03909216916370a0823191602480820192602092909190829003018186803b15801561185c57600080fd5b505afa158015611870573d6000803e3d6000fd5b505050506040513d602081101561188657600080fd5b5051106118e4576038546037546118b0916001600160a01b0391821691168363ffffffff612c0e16565b6040805182815290517fc902dde1f6a9ed97cba3af732e19d293747ff92cfede186b3de3ac2847bf9d729181900360200190a15b506048805461ff00191690555b6000851315611c825760475461190e90600163ffffffff612b1516565b604781905550604860029054906101000a90046001600160a01b03166001600160a01b031663ddca3f436040518163ffffffff1660e01b815260040160206040518083038186803b15801561196257600080fd5b505afa158015611976573d6000803e3d6000fd5b505050506040513d602081101561198c57600080fd5b5051604954604854604080516370a0823160e01b8152620100009092046001600160a01b03908116600484015290519216916370a0823191602480820192602092909190829003018186803b1580156119e457600080fd5b505afa1580156119f8573d6000803e3d6000fd5b505050506040513d6020811015611a0e57600080fd5b505110801590611a335750604954600160a01b900460ff1680611a3357506039544310155b15611c7d576000611a5b670de0b6b3a764000061098a603d5486612a7a90919063ffffffff16565b90506000611a80670de0b6b3a764000061098a60b15485612a7a90919063ffffffff16565b9050611b17603760009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b158015611ad357600080fd5b505afa158015611ae7573d6000803e3d6000fd5b505050506040513d6020811015611afd57600080fd5b505161098a84670de0b6b3a764000063ffffffff612a7a16565b604655603754604080516318160ddd60e01b81529051611ba4926001600160a01b0316916318160ddd916004808301926020929190829003018186803b158015611b6057600080fd5b505afa158015611b74573d6000803e3d6000fd5b505050506040513d6020811015611b8a57600080fd5b505161098a83670de0b6b3a764000063ffffffff612a7a16565b60b2556000611bb9838363ffffffff612b1516565b9050848111611c79576048805461010061ff0019909116179081905560408051632cdc85e960e21b81524360048201529051620100009092046001600160a01b03169163b37217a49160248082019260009290919082900301818387803b158015611c2357600080fd5b505af1158015611c37573d6000803e3d6000fd5b50506040805184815290517fc902dde1f6a9ed97cba3af732e19d293747ff92cfede186b3de3ac2847bf9d729350908190036020019150a19250611dd3915050565b5050505b611dcf565b60485460ff1615611dcf57600060475560455460ff168015611ca5575060395443105b15611dcf57603954600090611cc0904363ffffffff612a3116565b90506044548110611dcd57604454603954611ce09163ffffffff612a3116565b603955604454603a54600091611cfc919063ffffffff612a7a16565b90506000611d5e670de0b6b3a764000061098a84603760009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110cc57600080fd5b43603b55603854603754919250611d88916001600160a01b0390811691168363ffffffff612c0e16565b6044546040805191825260208201849052818101839052517f1694f62a505b0e4a55d580df64f7e62af07daee76a3e0beb8f9024eb71f0f6d89181900360600190a150505b505b5060005b949350505050565b60b36020526000908152604090205481565b6000546001600160a01b031690565b611e04612b6f565b6000546001600160a01b03908116911614611e54576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b604354811115611e955760405162461bcd60e51b815260040180806020018281038252602a81526020018061349f602a913960400191505060405180910390fd5b60418190556040805182815290517fc7468f249cdc379fbbba5af00534396af85bfcd2124135df9f7c0dd728ff23d09181900360200190a150565b611ed8612b6f565b6000546001600160a01b03908116911614611f28576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6048805460ff1916821515179081905560006047556040805160ff909216158252517fc1816aba3152c207369171109b5a1297502e53af09a57dc7791d40ad416ceb84916020908290030190a150565b611f80612b6f565b6000546001600160a01b03908116911614611fd0576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b60b18190556040805182815290517f4ab7ac4b42a98396150c18af6cda4c149419af88e1e091fad27cd0ae59b0fbcf9181900360200190a150565b612013612b6f565b6000546001600160a01b03908116911614612063576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6045805460ff191682151517908190556040805160ff90921615158252517fbd6aa27a186644eab4bee9ee35e77e0585bde57801732ae3500e882013ba2101916020908290030190a150565b6120b7612b6f565b6000546001600160a01b03908116911614612107576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b604880546001600160a01b038084166201000090810262010000600160b01b03199093169290921792839055604080519290930416815290517f66bf1e9a1d478d6d27f5bd162c3ace8f2217b57cad10ae3faa70a9559992e8fa9181900360200190a150565b603b5481565b6033546001600160a01b031681565b600260365414156121da576040805162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015290519081900360640190fd5b6002603655336121e8612630565b603c556121f3612b9b565b603b556001600160a01b0381161561223a5761220e81610922565b6001600160a01b038216600090815260b46020908152604080832093909355603c5460b3909152919020555b603854600160a01b900460ff1661228d576040805162461bcd60e51b8152602060048201526012602482015271141bdbdb081a5cdb89dd08195b98589b195960721b604482015290519081900360640190fd5b61229633612eba565b156122e8576040805162461bcd60e51b815260206004820152601d60248201527f43616c6c6572206d757374206e6f74206265206120636f6e7472616374000000604482015290519081900360640190fd5b6000821161232e576040805162461bcd60e51b815260206004820152600e60248201526d043616e6e6f74207374616b6520360941b604482015290519081900360640190fd5b60425460ff16156123ae576000612343610d26565b604354909150612359848363ffffffff612b1516565b11156123ac576040805162461bcd60e51b815260206004820181905260248201527f43616e74207374616b6520706f6f6c206c70206c696d69742072656163686564604482015290519081900360640190fd5b505b60405460ff161561242f5760006123c4336113e7565b6041549091506123da828563ffffffff612b1516565b111561242d576040805162461bcd60e51b815260206004820152601d60248201527f43616e74207374616b65206d6f7265207468616e206c70206c696d6974000000604482015290519081900360640190fd5b505b61243882612ec0565b60408051838152905133917f56b2fb41a9acac73203c4c159f5cca6ff3bfa8f53e8cd40d6c682404b0adde3d919081900360200190a250506001603655565b604954600160a01b900460ff1681565b61248f612b6f565b6000546001600160a01b039081169116146124df576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b604a839055604b8290556124f6604c826064613372565b507f2600ae90bc8482ac44efb4e6ac17d440665c195f6e0bba9ad16d1e1b5749b286604a54604b54604c604051808481526020018381526020018260648015612554576020028201915b815481526020019060010190808311612540575b5050935050505060405180910390a1505050565b60465481565b604b5481565b61257c612b6f565b6000546001600160a01b039081169116146125cc576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6001603f5410156125dc57600080fd5b603f8190556040805182815290517f3785ba91aa39d946a094688c634e4b7b8a68e01e6f8617958324a109905765919181900360200190a150565b603854600160a01b900460ff1681565b60485460ff1681565b600061263a610d26565b6126475750603c54610d2a565b612684612675612655610d26565b61098a670de0b6b3a764000061097e603a5461097e603b54610969612b9b565b603c549063ffffffff612b1516565b905090565b612691612b6f565b6000546001600160a01b039081169116146126e1576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b603854603754604080516370a0823160e01b81523060048201529051612779936001600160a01b039081169316916370a08231916024808301926020929190829003018186803b15801561273457600080fd5b505afa158015612748573d6000803e3d6000fd5b505050506040513d602081101561275e57600080fd5b50516037546001600160a01b0316919063ffffffff612c0e16565b6040805143815290517fb950f0e041f52284e48472541258aa49498abf66dff930f928f143f2704105c09181900360200190a1565b604a5481565b6127bc612b6f565b6000546001600160a01b0390811691161461280c576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b60498054821515600160a01b90810260ff60a01b199092169190911791829055604080519190920460ff161515815290517f7409667185e4202d42493086e621a8c103b5ccb64a55dcd22ae6a4f02ea568ac9181900360200190a150565b612872612b6f565b6000546001600160a01b039081169116146128c2576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6040805460ff191682151517808255815160ff9091161515815290517f5f0e19a2afa327808daff87bc35dc945e6c93ba018fb74d3b725438f3d61f5f1916020908290030190a150565b603c5481565b603e5481565b612929612924336113e7565b610d5a565b612931610f47565b565b60395481565b612941612b6f565b6000546001600160a01b03908116911614612991576040805162461bcd60e51b81526020600482018190526024820152600080516020613451833981519152604482015290519081900360640190fd5b6001600160a01b0381166129d65760405162461bcd60e51b81526004018080602001828103825260268152602001806133bb6026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b6000612a7383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612f23565b9392505050565b600082612a89575060006109a2565b82820282848281612a9657fe5b0414612a735760405162461bcd60e51b81526004018080602001828103825260218152602001806134306021913960400191505060405180910390fd5b6000612a7383836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612fba565b600082820183811015612a73576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b3390565b303b1590565b603380546001600160a01b0319166001600160a01b0392909216919091179055565b60006126844360395461301f565b603454612bbc908263ffffffff612a3116565b60345533600090815260356020526040902054612bdf908263ffffffff612a3116565b33600081815260356020526040902091909155603354612c0b916001600160a01b039091169083612c0e565b50565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052612c60908490613035565b505050565b6000612a7383836040518060400160405280601881526020017f536166654d6174683a206d6f64756c6f206279207a65726f00000000000000008152506130e6565b6000612cb1612630565b603c55612cbc612b9b565b603b556001600160a01b03811615612d0357612cd781610922565b6001600160a01b038216600090815260b46020908152604080832093909355603c5460b3909152919020555b603754604080516370a0823160e01b815230600482015290517812725dd1d243aba0e75fe645cc4873f9e65afe688c928e1f21926001600160a01b0316916370a08231916024808301926020929190829003018186803b158015612d6657600080fd5b505afa158015612d7a573d6000803e3d6000fd5b505050506040513d6020811015612d9057600080fd5b505110612dce5760405162461bcd60e51b815260040180806020018281038252602681526020018061340a6026913960400191505060405180910390fd5b6039544310612df457603f54604654612dec9163ffffffff612ad316565b603a55612e46565b603954600090612e0a904363ffffffff612a3116565b90506000612e23603a5483612a7a90919063ffffffff16565b9050612e40603f5461098a83604654612b1590919063ffffffff16565b603a5550505b43603b819055603f54612e5f919063ffffffff612b1516565b6039819055604654603a5460475460408051938452602084019290925282820193909352606082019290925290517fce4b5af00c06253418c3848234c1b2598e1955d5b3f9e8e2d1de362f9124f7b39181900360800190a150565b3b151590565b603454612ed3908263ffffffff612b1516565b60345533600090815260356020526040902054612ef6908263ffffffff612b1516565b33600081815260356020526040902091909155603354612c0b916001600160a01b03909116903084613148565b60008184841115612fb25760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015612f77578181015183820152602001612f5f565b50505050905090810190601f168015612fa45780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600081836130095760405162461bcd60e51b8152602060048201818152835160248401528351909283926044909101919085019080838360008315612f77578181015183820152602001612f5f565b50600083858161301557fe5b0495945050505050565b600081831061302e5781612a73565b5090919050565b606061308a826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166131a89092919063ffffffff16565b805190915015612c60578080602001905160208110156130a957600080fd5b5051612c605760405162461bcd60e51b815260040180806020018281038252602a8152602001806134f6602a913960400191505060405180910390fd5b600081836131355760405162461bcd60e51b8152602060048201818152835160248401528351909283926044909101919085019080838360008315612f77578181015183820152602001612f5f565b5082848161313f57fe5b06949350505050565b604080516001600160a01b0380861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b1790526131a2908590613035565b50505050565b6060611dd38484600085856131bc85612eba565b61320d576040805162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b60006060866001600160a01b031685876040518082805190602001908083835b6020831061324c5780518252601f19909201916020918201910161322d565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d80600081146132ae576040519150601f19603f3d011682016040523d82523d6000602084013e6132b3565b606091505b50915091506132c38282866132ce565b979650505050505050565b606083156132dd575081612a73565b8251156132ed5782518084602001fd5b60405162461bcd60e51b8152602060048201818152845160248401528451859391928392604401919085019080838360008315612f77578181015183820152602001612f5f565b8260648101928215613362579160200282015b82811115613362578251825591602001919060010190613347565b5061336e9291506133a0565b5090565b8260648101928215613362579160200282015b82811115613362578235825591602001919060010190613385565b610d2a91905b8082111561336e57600081556001016133a656fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f20616464726573734f6e6c792064656261736520706f6c69637920636f6e74726163742063616e2063616c6c2074686973526577617264733a207265776172647320746f6f206c617267652c20776f756c64206c6f636b536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572436f6e747261637420696e7374616e63652068617320616c7265616479206265656e20696e697469616c697a656455736572206c70206c696d69742063616e74206265206d6f7265207468616e20706f6f6c206c696d6974506f6f6c206c70206c696d69742063616e74206265206c657373207468616e2075736572206c70206c696d69745361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a2646970667358221220e7784edd48016cc65df7233382be90b0a95f2aa4eeed1bb3ce7b5a01d156035a64736f6c63430006060033

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