Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• library MerkleProof
•    - function verify(
• interface IMerkleDistributor
•    - function token()
•    - function merkleRoot()
•    - function isClaimed(uint256 index)
•    - function claim(
•  contract MerkleDistributor is IMer ... *
•    - function pause()
•    - function unpause()
•    - function setBlacklisted(address _acco ...
•    - function isClaimed(uint256 index)
•    - function _setClaimed(uint256 index)
•    - function claim(
•    - function governanceRecoverUnsupported ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-05-26
*/

// SPDX-License-Identifier: UNLICENSED

pragma solidity >=0.6.11;

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

/**
 * @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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * 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);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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;
    }
}

/**
 * @dev These functions deal with verification of Merkle trees (hash trees),
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

// Allows anyone to claim a token if they exist in a merkle root.
interface IMerkleDistributor {
    // Returns the address of the token distributed by this contract.
    function token() external view returns (address);

    // Returns the merkle root of the merkle tree containing account balances available to claim.
    function merkleRoot() external view returns (bytes32);

    // Returns true if the index has been marked claimed.
    function isClaimed(uint256 index) external view returns (bool);

    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.
    function claim(
        uint256 index,
        address account,
        uint256 amount,
        bytes32[] calldata merkleProof
    ) external;

    // This event is triggered whenever a call to #claim succeeds.
    event Claimed(uint256 index, address account, uint256 amount);
}

contract MerkleDistributor is IMerkleDistributor {
    address public operator;
    uint256 public startTime;

    address public immutable override token;
    bytes32 public immutable override merkleRoot;

    // This is a packed array of booleans.
    mapping(uint256 => uint256) private claimedBitMap;

    mapping(address => bool) public blacklisted; // if the snapshot is wrong we need to block the account to receive token
    bool public paused;

    constructor(address token_, bytes32 merkleRoot_) public {
        token = token_;
        merkleRoot = merkleRoot_;
        operator = msg.sender;
        startTime = block.timestamp;
    }

    modifier onlyOperator() {
        require(operator == msg.sender, "caller is not the operator");
        _;
    }

    modifier notPaused() {
        require(!paused, "distribution is paused");
        _;
    }

    function pause() external onlyOperator {
        paused = true;
    }

    function unpause() external onlyOperator {
        paused = false;
    }

    function setBlacklisted(address _account, bool _status) external onlyOperator {
        blacklisted[_account] = _status;
    }

    function isClaimed(uint256 index) public view override returns (bool) {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        uint256 claimedWord = claimedBitMap[claimedWordIndex];
        uint256 mask = (1 << claimedBitIndex);
        return claimedWord & mask == mask;
    }

    function _setClaimed(uint256 index) private {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);
    }

    function claim(
        uint256 index,
        address account,
        uint256 amount,
        bytes32[] calldata merkleProof
    ) external override notPaused {
        require(!isClaimed(index), "MerkleDistributor: Drop already claimed.");
        require(!blacklisted[account], "MerkleDistributor: Account is blocked.");

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(index, account, amount));
        require(MerkleProof.verify(merkleProof, merkleRoot, node), "MerkleDistributor: Invalid proof.");

        // Mark it claimed and send the token.
        _setClaimed(index);
        require(IERC20(token).transfer(account, amount), "MerkleDistributor: Transfer failed.");

        emit Claimed(index, account, amount);
    }

    function governanceRecoverUnsupported(address _token, uint256 _amount) external onlyOperator {
        IERC20(_token).transfer(operator, _amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"blacklisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"governanceRecoverUnsupported","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"bool","name":"_status","type":"bool"}],"name":"setBlacklisted","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000049e833337ece7afe375e44f4e3e8481029218e5cc1b7a17ed91c8492c88461c0b939d29a43e552057306aea696ca9ba19d1e3e53

-----Decoded View---------------
Arg [0] : token_ (address): 0x49E833337ECe7aFE375e44F4E3e8481029218E5c
Arg [1] : merkleRoot_ (bytes32): 0xc1b7a17ed91c8492c88461c0b939d29a43e552057306aea696ca9ba19d1e3e53

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000049e833337ece7afe375e44f4e3e8481029218e5c
Arg [1] : c1b7a17ed91c8492c88461c0b939d29a43e552057306aea696ca9ba19d1e3e53

12492:2744:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15079:154;;;;;;;;;;;;;;;;-1:-1:-1;15079:154:0;;;;;;;;;:::i;:::-;;14285:786;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14285:786:0;;-1:-1:-1;14285:786:0;-1:-1:-1;14285:786:0;:::i;12657:44::-;;;:::i;:::-;;;;;;;;;;;;;;;;13470:74;;;:::i;12548:23::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12936:18;;;:::i;:::-;;;;;;;;;;;;;;;;;;12578:24;;;:::i;13391:71::-;;;:::i;13688:331::-;;;;;;;;;;;;;;;;-1:-1:-1;13688:331:0;;:::i;13552:128::-;;;;;;;;;;;;;;;;-1:-1:-1;13552:128:0;;;;;;;;;;;:::i;12812:43::-;;;;;;;;;;;;;;;;-1:-1:-1;12812:43:0;;;;:::i;12611:39::-;;;:::i;15079:154::-;13208:8;;:22;:8;13220:10;13208:22;13200:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15207:8:::1;::::0;;15183:42:::1;::::0;;;;;:23:::1;15207:8:::0;;::::1;15183:42;::::0;::::1;::::0;;;;;;;;;:23;;::::1;::::0;::::1;::::0;:42;;;;;::::1;::::0;;;;;;;;;;;:23;:42;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;;15079:154:0:o;14285:786::-;13330:6;;;;13329:7;13321:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14471:16:::1;14481:5;14471:9;:16::i;:::-;14470:17;14462:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14552:20;::::0;::::1;;::::0;;;:11:::1;:20;::::0;;;;;::::1;;14551:21;14543:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14665:12;14707:5;14714:7;14723:6;14690:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14680:51;;;;;;14665:66;;14750:49;14769:11;;14750:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;14782:10:0::1;::::0;-1:-1:-1;14794:4:0;;-1:-1:-1;14750:18:0::1;::::0;-1:-1:-1;14750:49:0:i:1;:::-;14742:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14898:18;14910:5;14898:11;:18::i;:::-;14942:5;14935:22;;;14958:7;14967:6;14935:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;14935:39:0;14927:87:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15032:31;::::0;;;;;::::1;::::0;::::1;;::::0;::::1;::::0;;;;;;;;;::::1;::::0;;;;;;;::::1;13374:1;14285:786:::0;;;;;:::o;12657:44::-;;;:::o;13470:74::-;13208:8;;:22;:8;13220:10;13208:22;13200:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13522:6:::1;:14:::0;;;::::1;::::0;;13470:74::o;12548:23::-;;;;;;:::o;12936:18::-;;;;;;:::o;12578:24::-;;;;:::o;13391:71::-;13208:8;;:22;:8;13220:10;13208:22;13200:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13441:6:::1;:13:::0;;;::::1;13450:4;13441:13;::::0;;13391:71::o;13688:331::-;13804:3;13796:11;;13752:4;13888:31;;;:13;:31;;;;;;13946:1;13844:11;;;;13946:20;;;;13985:18;;;:26;;13688:331::o;13552:128::-;13208:8;;:22;:8;13220:10;13208:22;13200:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13641:21:::1;::::0;;;::::1;;::::0;;;:11:::1;:21;::::0;;;;:31;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;13552:128::o;12812:43::-;;;;;;;;;;;;;;;:::o;12611:39::-;;;:::o;10740:830::-;10865:4;10905;10865;10922:525;10946:5;:12;10942:1;:16;10922:525;;;10980:20;11003:5;11009:1;11003:8;;;;;;;;;;;;;;10980:31;;11048:12;11032;:28;11028:408;;11202:12;11216;11185:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11175:55;;;;;;11160:70;;11028:408;;;11392:12;11406;11375:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11365:55;;;;;;11350:70;;11028:408;-1:-1:-1;10960:3:0;;10922:525;;;-1:-1:-1;11542:20:0;;;;10740:830;-1:-1:-1;;;10740:830:0:o;14027:250::-;14117:3;14109:11;;14082:24;14213:31;;;:13;:31;;;;;;;14248:1;14157:11;;;;14248:20;;;;14213:56;;;14179:90;;14027:250::o

ipfs://334218dce078ad979344e1d6bd9f4dafaade6013b64643c6a33f0d07acb249b4