Theta Smart Contracts | ThetaScan.io

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

Published Contract:

pragma solidity 0.5.16;
pragma experimental ABIEncoderV2;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @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 addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    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 multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b, string memory errorMessage) 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, errorMessage);

        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) {
        // Solidity only automatically asserts when dividing by 0
        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;
    }
}

contract TDropToken {
    /// @notice EIP-20 token name for this token
    string public constant name = "TDrop Token";

    /// @notice EIP-20 token symbol for this token
    string public constant symbol = "TDROP";

    /// @notice EIP-20 token decimals for this token
    uint8 public constant decimals = 18; 

    /// @notice Max token minted through airdrop
    uint public constant maxAirdrop = 10_000_000_000e18; // 10 billion TDrop. 

    /// @notice Max token minted for staking reward
    uint public maxStakeReward = 4_000_000_000e18; // 4 billion TDrop initially, community can vote on-chain to increase this limit after 4 years per TDrop whitepaper.

    /// @notice Max token minted through liquidity mining
    uint public maxLiquidityMiningReward = 6_000_000_000e18; // 6 billion TDrop, community can vote on-chain to increase this limit after 4 years per TDrop whitepaper.

    /// @notice Total number of tokens in circulation
    uint public totalSupply = 0; 

    /// @notice Accumulated token minted through airdrop
    uint public airdropAccumulated = 0;

    /// @notice Accumulated token minted for staking reward
    uint public stakeRewardAccumulated = 0;

    /// @notice Accumulated token minted through liquidity mining
    uint public liquidityMiningAccumulated = 0;

    /// @notice The super admin address, ultimately this will be set to address(0x0)
    address public superAdmin;

    /// @notice The admin address, ultimately this will be set to the governance contract address
    ///         so the community can colletively decide some of the key parameters (e.g. maxStakeReward)
    ///         through on-chain governance.
    address public admin;

    /// @notice Address which may airdrop new tokens
    address public airdropper;

    // @notice Address which may mint stake reward
    address public stakingPool;

    /// @notice The liquidity miner address (i.e., the marketplace contract address)
    address public liquidityMiner;

    /// @notice if the token is allowed to be transferred
    bool public paused;

    /// @notice Allowance amounts on behalf of others
    mapping (address => mapping (address => uint96)) internal allowances;

    /// @notice Official record of token balances for each account
    mapping (address => uint96) internal balances;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the permit struct used by the contract
    bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    /// @notice An event thats emitted when the super admin address is changed
    event SuperAdminChanged(address superAdmin, address newSuperAdmin);

    /// @notice An event thats emitted when the admin address is changed
    event AdminChanged(address admin, address newAdmin);

    /// @notice An event thats emitted when the airdropper address is changed
    event AirdropperChanged(address airdropper, address newAirdropper);

    /// @notice An event thats emitted when the staking pool address is changed
    event StakingPoolChanged(address stakingPool, address newStakingPool);

    /// @notice An event thats emitted when the liquidityMiner address is changed
    event LiquidityMinerChanged(address liquidityMiner, address newLiquidityMiner);

    /// @notice An event thats emitted when the token contract is paused
    event TokenPaused();

    /// @notice An event thats emitted when the token contract is unpaused
    event TokenUnpaused();

    /// @notice An event thats emitted when new tokens are mined through NFT liquidity mining
    event TokenMined(address recipient, uint amount);

    /// @notice An event thats emitted when tokens are airdropped
    event TokenAirdropped(address airdropper);

    /// @notice An event thats emitted when tokens issued for staking reward
    event StakingRewardIssued(address recipient, uint amount);

    /// @notice The standard EIP-20 transfer event
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @notice The standard EIP-20 approval event
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /**
     * @notice Construct a new TDrop token
     * @param superAdmin_ The account with super admin permission
     * @param admin_ The account with admin permission
     */
    constructor(address superAdmin_, address admin_) public {
        require(superAdmin_ != address(0), "superAdmin_ is address0"); 
        require(admin_ != address(0), "admin_ is address0");

        superAdmin = superAdmin_;
        emit SuperAdminChanged(address(0), superAdmin);
        admin = admin_;
        emit AdminChanged(address(0), admin);
        paused = true;
    }

    /**
     * @notice Change the admin address
     * @param superAdmin_ The address of the new super admin
     */
    function setSuperAdmin(address superAdmin_) onlySuperAdmin external {
        emit SuperAdminChanged(superAdmin, superAdmin_);
        superAdmin = superAdmin_;
    }

    /**
     * @notice Change the admin address
     * @param admin_ The address of the new admin
     *
     * Only superAdmin can change the admin to avoid potential mistakes. For example, 
     * consider a senario where the admin can call both setAdmin() and setAirdropper().
     * The admin might want to call setAirdropper(0x0) to temporarily disable airdrop. However,
     * due to some implementation bugs, the admin could mistakenly call setAdmin(0x0), which
     * puts the contract into an irrecoverable state.
     */
    function setAdmin(address admin_) onlySuperAdmin external {
        emit AdminChanged(admin, admin_);
        admin = admin_;
    }

    /**
     * @notice Change the airdropper address
     * @param airdropper_ The address of the new airdropper
     */
    function setAirdropper(address airdropper_) onlyAdmin external {
        emit AirdropperChanged(airdropper, airdropper_);
        airdropper = airdropper_;
    }

    /**
     * @notice Change the stakingPool address
     * @param stakingPool_ The address of the new airdropper
     */
    function setStakingPool(address stakingPool_) onlyAdmin external {
        emit StakingPoolChanged(stakingPool, stakingPool_);
        stakingPool = stakingPool_;
    }

    /**
     * @notice Change the liquidity miner address
     * @param liquidityMiner_ The address of the new liquidity miner
     */
    function setLiquidityMiner(address liquidityMiner_) onlyAdmin external {
        emit LiquidityMinerChanged(liquidityMiner, liquidityMiner_);
        liquidityMiner = liquidityMiner_;
    }

    /**
     * @notice Pause token transfer
     */
    function pause() onlyAdmin external {
        paused = true;
        emit TokenPaused();
    }

    /**
     * @notice Unpause token transfer
     */
    function unpause() onlyAdmin external {
        paused = false;
        emit TokenUnpaused();
    }

    /**
     * @notice Function to allow community to collectively decide the the maximum stake reward through on-chain governance.
     *         Note that the admin will ultimiately be set to the governance contract address
     */
    function updateMaxStakeReward(uint newMaxStakeReward) onlyAdmin external {
        require(newMaxStakeReward <= 8_000_000_000e18, "newMaxStakeReward exceeds the 8 Billion hardcap");
        maxStakeReward = newMaxStakeReward;
    }

    /**
     * @notice Function to allow community to collectively decide the the maximum NFT liquidity mining reward through on-chain governance.
     *         Note that the admin will ultimiately be set to the governance contract address
     */
    function updateMaxLiquidityMiningReward(uint newMaxLiquidityMiningReward) onlyAdmin external {
        require(newMaxLiquidityMiningReward <= 12_000_000_000e18, "newMaxLiquidityMiningReward exceeds the 12 Billion hardcap");
        maxLiquidityMiningReward = newMaxLiquidityMiningReward;
    }

    /**
     * @notice Mint new tokens
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to be minted
     */
    function _mint(address dst, uint rawAmount) onlyMinters internal {
        require(dst != address(0), "TDrop::mint: cannot transfer to the zero address");

        // mint the amount
        uint96 amount = safe96(rawAmount, "TDrop::mint: amount exceeds 96 bits");
        totalSupply = safe96(SafeMath.add(totalSupply, amount), "TDrop::mint: totalSupply exceeds 96 bits");

        // transfer the amount to the recipient
        balances[dst] = add96(balances[dst], amount, "TDrop::mint: transfer amount overflows");
        emit Transfer(address(0), dst, amount);
    }

    /**
     * @notice Mine new tokens through liquidity mining, only the liquidity miner, i.e. the marketplace contract can call this method
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to be minted
     */
    function mine(address dst, uint rawAmount) onlyLiquidityMiner external {
        uint96 amount = safe96(rawAmount, "TDrop::mine: amount exceeds 96 bits");
        uint96 expectedLiquidityMiningAccumulated = safe96(SafeMath.add(liquidityMiningAccumulated, amount), "TDrop::mine: liquidityMiningAccumulated exceeds 96 bits");
        
        // require(liquidityMiningAccumulated <= maxLiquidityMiningReward, "TDrop::mine: accumlated airdrop token exceeds the max");
        if (expectedLiquidityMiningAccumulated <= maxLiquidityMiningReward) { // graceful handling of over-minting
            liquidityMiningAccumulated = expectedLiquidityMiningAccumulated;
            _mint(dst, rawAmount);
            emit TokenMined(dst, amount);
        }
    }

    /**
     * @notice Airdrop tokens for the given list of addresses
     * @param dsts The addresses of the destination accounts
     * @param rawAmounts The number of tokens to be airdropped to each destination account
     */
    function airdrop(address[] calldata dsts, uint[] calldata rawAmounts) onlyAirdropper external {
        require(dsts.length == rawAmounts.length);
        uint numDsts = dsts.length;
        for (uint i = 0; i < numDsts; i ++) {
            address dst = dsts[i];
            uint rawAmount = rawAmounts[i];
            if (rawAmount == 0) {
                continue;
            }

            _mint(dst, rawAmount);

            uint96 amount = safe96(rawAmount, "TDrop::airdrop: amount exceeds 96 bits");
            airdropAccumulated = safe96(SafeMath.add(airdropAccumulated, amount), "TDrop::airdrop: airdropAccumulated exceeds 96 bits");
            require(airdropAccumulated <= maxAirdrop, "TDrop::airdrop: accumlated airdrop token exceeds the max");
        }

        emit TokenAirdropped(airdropper);
    }

    /**
     * @notice Mine new tokens for staking reward, only the staking contract can call this method
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to be minted
     */
    function stakeReward(address dst, uint rawAmount) onlyStakingPool external {
        uint96 amount = safe96(rawAmount, "TDrop::stakeReward: amount exceeds 96 bits");
        uint96 expectedStakeRewardAccumulated = safe96(SafeMath.add(stakeRewardAccumulated, amount), "TDrop::stakeReward: stakeRewardAccumulated exceeds 96 bits");
        
        //require(stakeRewardAccumulated <= maxStakeReward, "TDrop::stakeReward: accumlated stakeReward token exceeds the max");
        if (expectedStakeRewardAccumulated <= maxStakeReward) { // graceful handling of over-minting
            stakeRewardAccumulated = expectedStakeRewardAccumulated;
            _mint(dst, rawAmount);
            emit StakingRewardIssued(dst, amount);
        }
    }

    /**
     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
     * @param account The address of the account holding the funds
     * @param spender The address of the account spending the funds
     * @return The number of tokens approved
     */
    function allowance(address account, address spender) external view returns (uint) {
        return allowances[account][spender];
    }

    /**
     * @notice Approve `spender` to transfer up to `amount` from `src`
     * @dev This will overwrite the approval amount for `spender`
     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
     * @param spender The address of the account which may transfer tokens
     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
     * @return Whether or not the approval succeeded
     */
    function approve(address spender, uint rawAmount) onlyWhenUnpaused external returns (bool) {
        uint96 amount;
        if (rawAmount == uint(-1)) {
            amount = uint96(-1);
        } else {
            amount = safe96(rawAmount, "TDrop::approve: amount exceeds 96 bits");
        }

        allowances[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /**
     * @notice Triggers an approval from owner to spends
     * @param owner The address to approve from
     * @param spender The address to be approved
     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
     * @param deadline The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
        uint96 amount;
        if (rawAmount == uint(-1)) {
            amount = uint96(-1);
        } else {
            amount = safe96(rawAmount, "TDrop::permit: amount exceeds 96 bits");
        }

        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = _recover(digest, v, r, s);
        require(signatory != address(0), "TDrop::permit: invalid signature");
        require(signatory == owner, "TDrop::permit: unauthorized");
        require(now <= deadline, "TDrop::permit: signature expired");

        allowances[owner][spender] = amount;

        emit Approval(owner, spender, amount);
    }

    function _recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
        require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @notice Get the number of tokens held by the `account`
     * @param account The address of the account to get the balance of
     * @return The number of tokens held
     */
    function balanceOf(address account) external view returns (uint) {
        return balances[account];
    }

    /**
     * @notice Get the number of tokens held by the `account` in the unit of "whole TDrop"
     * @param account The address of the account to get the balance of
     * @return The number of tokens held in the unit of "whole TDrop" without decimal places
     */
    function balanceInWholeCoin(address account) external view returns (uint) {
        return SafeMath.div(balances[account], 1_000_000_000_000_000_000);
    }

    /**
     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transfer(address dst, uint rawAmount) external returns (bool) {
        uint96 amount = safe96(rawAmount, "TDrop::transfer: amount exceeds 96 bits");
        _transferTokens(msg.sender, dst, amount);
        return true;
    }

    /**
     * @notice Transfer `amount` tokens from `src` to `dst`
     * @param src The address of the source account
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
        address spender = msg.sender;
        uint96 spenderAllowance = allowances[src][spender];
        uint96 amount = safe96(rawAmount, "TDrop::approve: amount exceeds 96 bits");

        if (spender != src && spenderAllowance != uint96(-1)) {
            uint96 newAllowance = sub96(spenderAllowance, amount, "TDrop::transferFrom: transfer amount exceeds spender allowance");
            allowances[src][spender] = newAllowance;

            emit Approval(src, spender, newAllowance);
        }

        _transferTokens(src, dst, amount);
        return true;
    }

    function _transferTokens(address src, address dst, uint96 amount) onlyWhenUnpaused internal {
        require(src != address(0), "TDrop::_transferTokens: cannot transfer from the zero address");
        require(dst != address(0), "TDrop::_transferTokens: cannot transfer to the zero address");

        balances[src] = sub96(balances[src], amount, "TDrop::_transferTokens: transfer amount exceeds balance");
        balances[dst] = add96(balances[dst], amount, "TDrop::_transferTokens: transfer amount overflows");
        emit Transfer(src, dst, amount);
    }

    function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
        require(n < 2**96, errorMessage);
        return uint96(n);
    }

    function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        uint96 c = a + b;
        require(c >= a, errorMessage);
        return c;
    }

    function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        require(b <= a, errorMessage);
        return a - b;
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }

    modifier onlySuperAdmin { 
        require(msg.sender == superAdmin, "TDrop::onlySuperAdmin: only the super admin can perform this action");
        _; 
    }

    modifier onlyAdmin { 
        require(msg.sender == admin, "TDrop::onlyAdmin: only the admin can perform this action");
        _; 
    }

    modifier onlyLiquidityMiner { 
        require(msg.sender == liquidityMiner, "TDrop::onlyLiquidityMiner: only the liquidity miner can perform this action");
        _; 
    }

    modifier onlyAirdropper { 
        require(msg.sender == airdropper, "TDrop::onlyAirdropper: only the airdropper can perform this action");
        _; 
    }

    modifier onlyStakingPool { 
        require(msg.sender == stakingPool, "TDrop::onlyStakingPool: only the stakingpool can perform this action");
        _; 
    }

    modifier onlyMinters { 
        require(msg.sender == airdropper || msg.sender == liquidityMiner || msg.sender == stakingPool, "TDrop::onlyMinters: only the minters can perform this action");
        _; 
    }

    modifier onlyWhenUnpaused {
        require(!paused, "TDrop::onlyWhenUnpaused: token is paused");
        _;
    }
}

Contract ABI:

[{"inputs":[{"internalType":"address","name":"superAdmin_","type":"address"},{"internalType":"address","name":"admin_","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"admin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"airdropper","type":"address"},{"indexed":false,"internalType":"address","name":"newAirdropper","type":"address"}],"name":"AirdropperChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"liquidityMiner","type":"address"},{"indexed":false,"internalType":"address","name":"newLiquidityMiner","type":"address"}],"name":"LiquidityMinerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"stakingPool","type":"address"},{"indexed":false,"internalType":"address","name":"newStakingPool","type":"address"}],"name":"StakingPoolChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"StakingRewardIssued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"superAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newSuperAdmin","type":"address"}],"name":"SuperAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"airdropper","type":"address"}],"name":"TokenAirdropped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenMined","type":"event"},{"anonymous":false,"inputs":[],"name":"TokenPaused","type":"event"},{"anonymous":false,"inputs":[],"name":"TokenUnpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"dsts","type":"address[]"},{"internalType":"uint256[]","name":"rawAmounts","type":"uint256[]"}],"name":"airdrop","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"airdropAccumulated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"airdropper","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceInWholeCoin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"liquidityMiner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"liquidityMiningAccumulated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxAirdrop","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxLiquidityMiningReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxStakeReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"mine","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"admin_","type":"address"}],"name":"setAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"airdropper_","type":"address"}],"name":"setAirdropper","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"liquidityMiner_","type":"address"}],"name":"setLiquidityMiner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"stakingPool_","type":"address"}],"name":"setStakingPool","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"superAdmin_","type":"address"}],"name":"setSuperAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"stakeReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"stakeRewardAccumulated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"stakingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"superAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newMaxLiquidityMiningReward","type":"uint256"}],"name":"updateMaxLiquidityMiningReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newMaxStakeReward","type":"uint256"}],"name":"updateMaxStakeReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]