Contract 0xcBE6B83e77cdc011Cc18F6f0Df8444E5783ed982 3

 
Txn Hash
Method
Block
From
To
Value
0xf8788e38fa09fda036de97a035d540f7bb5c955d3cd5e0c5c24df0ae1e0e27b7Claim153566872022-08-17 4:48:402 days 11 hrs ago0x6bb0f021000ec0b398599059d689a8625b9e7af3 IN  SushiSwap: Merkle Distributor0 Ether0.00041118 5.16110261
0x6d5bdfcb1424eee0e7129e938dd73d89d3f199e048044870195f3c8ab034b672Claim153247432022-08-12 3:45:387 days 12 hrs ago0x2088207c76c8c4a8c18760c8cf860146f5d07aa5 IN  SushiSwap: Merkle Distributor0 Ether0.0011521 14.4544794
0x38faba858d8467eec173fc4ec6ec56fc69e14c93bcd8f9c0d789e5325690762bClaim152939522022-08-07 7:58:0712 days 8 hrs ago0xb18977c13f660efe659f04c1220b801a43511667 IN  SushiSwap: Merkle Distributor0 Ether0.00031673 5.05488361
0xfa2416ba89ef8a7adf5df8545ee9e74dd9de272bebb4b4a0e0a460cdd9b72184Claim152891392022-08-06 13:56:2913 days 2 hrs ago0xed2170462e997b9590f77bf2cd3cd283b877eade IN  SushiSwap: Merkle Distributor0 Ether0.00048755 6.11603834
0xa31b10878abab26a8dc08dc93d86be92ce8937415f55d95868973103a2651812Claim152884232022-08-06 11:23:1513 days 5 hrs ago0xe26edca05417a65819295c49fc67272ab247d791 IN  SushiSwap: Merkle Distributor0 Ether0.00029041 3
0x4489969ffdfbbae173e5131e08248713e9c8121dfb2c4253fa6ec8532a5d6d75Claim152875102022-08-06 7:52:4713 days 8 hrs ago0xec7f84251c683a7c80bbefacaa172b4fcc11ce53 IN  SushiSwap: Merkle Distributor0 Ether0.00025072 4
0x27f1c23fa6aac23348eff2b38557db61103572d49e815ed4e96f81873ae9685dClaim152734622022-08-04 3:19:2015 days 13 hrs ago0xd35dc42c3812ace3d313f8303114b731d428a0fa IN  SushiSwap: Merkle Distributor0 Ether0.00055892 7.00939783
0x54d83384a2bd36387c70ac5c0be9b66e1f9eff34c991ca5c934f9aa93dd288baClaim152730372022-08-04 1:46:3815 days 14 hrs ago0xb70119aaebdad6bfc88a618ac35b5cb8bd7bdfe5 IN  SushiSwap: Merkle Distributor0 Ether0.00095626 9.88101945
0x9ea1458334433dcd7074e8dc723225de96c5711741e97ee3d1cbda78de43fcd8Claim152498402022-07-31 10:59:2819 days 5 hrs ago0xb9d4dabd4bd330057c40b97f0bdd11d6c92e2f80 IN  SushiSwap: Merkle Distributor0 Ether0.00043413 5.44610876
0xe9914fda13e2e0124647af03e1cc56379a4b596a9fa0886f24b2c8453cfca036Claim152481032022-07-31 4:28:3419 days 12 hrs ago0x062fe868c746e57c28ec3f47bf40e8868fea6e59 IN  SushiSwap: Merkle Distributor0 Ether0.00039643 4.96981234
0x8a1e88fb447898eb721fe2e3d38caabee19f664c948f30bd49aa4972870a9f5bClaim152451692022-07-30 17:36:3719 days 23 hrs ago0x071b8bc181ae7cb03f5faece9b5b8b25be9b0982 IN  SushiSwap: Merkle Distributor0 Ether0.0017014 21.56187464
0x68a19f6bb6376b3bf6dd82f56400ea1fbf6baf25dff40977a1e42184e385e58cClaim152442412022-07-30 14:06:4120 days 2 hrs agoENS Name dobem.eth IN  SushiSwap: Merkle Distributor0 Ether0.00093496 9.656377
0xa37317e91681905d975507c60b687651504ff75c5dbf2db452c56430881db5f6Claim152369602022-07-29 10:57:2921 days 5 hrs ago0x5c160d106be874649e114617b3de197f936a3a70 IN  SushiSwap: Merkle Distributor0 Ether0.00081378 12.99396251
0x28282c80efdaafde47489a02f187761d88871997af31a915a31f3688a76d9bf7Claim152019912022-07-23 23:55:4626 days 16 hrs ago0x2389817bd285e7ba3cfe5f9d9b3543eb2ac89a2e IN  SushiSwap: Merkle Distributor0 Ether0.00031325 5
0xb194d08657a04bc1ba37ab0eb054fb06b9547a2456600e6e59c1db05463a93d4Claim151903972022-07-22 4:59:2128 days 11 hrs ago0x08b2f6f7927c7523ccde33f447a4a1c17aabdf44 IN  SushiSwap: Merkle Distributor0 Ether0.00060979 7.64841149
0xf91e1681634bdf3b3e4042719e84bd4cc935ca946d313ab864dbb7b770c8374dClaim151849742022-07-21 8:57:3929 days 7 hrs ago0xf37882f0d993b73e2f200fa0b4c5fe8a4fcb4090 IN  SushiSwap: Merkle Distributor0 Ether0.0011785 19.05985749
0xd1bc6961d896333c53bac8c7c2fac005e732b257ee8122cdd25e68dbe97a59b8Claim151706822022-07-19 3:34:1431 days 13 hrs agoENS Name gululuoooo.eth IN  SushiSwap: Merkle Distributor0 Ether0.00144041 18.24967735
0x6054d6a10b2dafbd477d23bc00512742cf9a4d191f8e779afd905e65476ef698Claim151522572022-07-16 7:02:3734 days 9 hrs ago0x21e066b2cbcd114cb69fcfd06ebec5ce4e89c94b IN  SushiSwap: Merkle Distributor0 Ether0.00118284 12.21441607
0x65998bb65702086a5dfbc0764b6238cf2222a28b20cb66bc57c5c1dd5b5c3290Claim151517822022-07-16 5:15:1634 days 11 hrs agoENS Name grateful55.eth IN  SushiSwap: Merkle Distributor0 Ether0.001072 11.07284851
0xc20a8dbc2dfe1dec08811cf169a4b1c366739b7e3696eb7145b7a542774ab82eClaim151086072022-07-09 13:23:1041 days 3 hrs ago0xf3ba4250c3a2fc5b4dd5a1b394f76037f1fdc28f IN  SushiSwap: Merkle Distributor0 Ether0.00048055 7.66923301
0xff162798e9a055196bbf3336e3be433cc2f93e93f5e1bae5cab1845d4bff05f0Claim151000012022-07-08 5:17:5042 days 11 hrs ago0x5c3a08a21b5c30fa7254fc8dac9e8d2e8cec8836 IN  SushiSwap: Merkle Distributor0 Ether0.00174599 21.90211957
0x3e95dde02990937f6a502d53164cb9e46545aaf0ba01b4e2e80d99c4e6aa5975Claim150999822022-07-08 5:13:3642 days 11 hrs ago0xfdd3636caeb29b76fcb9472a93b73d36c7c3f5bf IN  SushiSwap: Merkle Distributor0 Ether0.00166518 26.5978595
0xaf563769327a6959be1dbadc5ce719b49e3f2ec3a61bbe8e273810bf0fcbd92aClaim150931852022-07-07 4:13:0643 days 12 hrs ago0xf096b7a625b576fce67741f4bd6cb89f1676f792 IN  SushiSwap: Merkle Distributor0 Ether0.00087665 11
0x6db9257bdc77b92904acef7b0487699384ccb91d57d893f0d5b788bacafd9b7aClaim150830872022-07-05 14:30:5645 days 2 hrs ago0xd9758b9d6c45505899a4a33bf3c056308089bdc1 IN  SushiSwap: Merkle Distributor0 Ether0.00304861 38.2291146
0xed774c0e04b0c653cb5859c05d72e9604382500ff863274ff7356a52a0a638b6Claim150798612022-07-05 2:36:2545 days 14 hrs ago0xe4f683b80e8e141313dd5f2d0066f66e454a57bf IN  SushiSwap: Merkle Distributor0 Ether0.00308437 38.69203339
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MerkleDistributor

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

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

// Sources flattened with hardhat v2.0.10 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

// SPDX-License-Identifier: MIXED

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


// File @openzeppelin/contracts/cryptography/[email protected]

pragma solidity >=0.6.0 <0.8.0;

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


// File contracts/interfaces/IMerkleDistributor.sol

pragma solidity >=0.5.0;

// 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 the current claiming week
    function week() external view returns (uint32);
    // Returns true if the claim function is frozen
    function frozen() external view returns (bool);
    // 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;
    // Freezes the claim function and allow the merkleRoot to be changed.
    function freeze() external;
    // Unfreezes the claim function.
    function unfreeze() external;
    // Update the merkle root and increment the week.
    function updateMerkleRoot(bytes32 newMerkleRoot) external;

    // This event is triggered whenever a call to #claim succeeds.
    event Claimed(uint256 index, uint256 amount, address indexed account, uint256 indexed week);
    // This event is triggered whenever the merkle root gets updated.
    event MerkleRootUpdated(bytes32 indexed merkleRoot, uint32 indexed week);
}


// File contracts/Ownable.sol

// Audit on 5-Jan-2021 by Keno and BoringCrypto

// P1 - P3: OK
pragma solidity 0.6.12;

// Source: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol + Claimable.sol
// Edited by BoringCrypto

// T1 - T4: OK
contract OwnableData {
    // V1 - V5: OK
    address public owner;
    // V1 - V5: OK
    address public pendingOwner;
}

// T1 - T4: OK
contract Ownable is OwnableData {
    // E1: OK
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor () internal {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    // F1 - F9: OK
    // C1 - C21: OK
    function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
        if (direct) {
            // Checks
            require(newOwner != address(0) || renounce, "Ownable: zero address");

            // Effects
            emit OwnershipTransferred(owner, newOwner);
            owner = newOwner;
        } else {
            // Effects
            pendingOwner = newOwner;
        }
    }

    // F1 - F9: OK
    // C1 - C21: OK
    function claimOwnership() public {
        address _pendingOwner = pendingOwner;

        // Checks
        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");

        // Effects
        emit OwnershipTransferred(owner, _pendingOwner);
        owner = _pendingOwner;
        pendingOwner = address(0);
    }

    // M1 - M5: OK
    // C1 - C21: OK
    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }
}


// File contracts/MerkleDistributor.sol
pragma solidity 0.6.12;

contract MerkleDistributor is IMerkleDistributor, Ownable {
    address public immutable override token;
    bytes32 public override merkleRoot;
    uint32 public override week;
    bool public override frozen;

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

    constructor(address token_, bytes32 merkleRoot_) public {
        token = token_;
        merkleRoot = merkleRoot_;
        week = 0;
        frozen = false;
    }

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

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

    function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external override {
        require(!frozen, 'MerkleDistributor: Claiming is frozen.');
        require(!isClaimed(index), 'MerkleDistributor: Drop already claimed.');

        // 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, amount, account, week);
    }

    function freeze() public override onlyOwner {
        frozen = true;
    }

    function unfreeze() public override onlyOwner {
        frozen = false;
    }

    function updateMerkleRoot(bytes32 _merkleRoot) public override onlyOwner {
        require(frozen, 'MerkleDistributor: Contract not frozen.');

        // Increment the week (simulates the clearing of the claimedBitMap)
        week = week + 1;
        // Set the new merkle root
        merkleRoot = _merkleRoot;

        emit MerkleRootUpdated(merkleRoot, week);
    }
}


// File @openzeppelin/contracts/utils/[email protected]

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


// File @openzeppelin/contracts/math/[email protected]

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


// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity >=0.6.0 <0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

Contract Security Audit

Contract ABI

[{"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":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"uint256","name":"week","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"indexed":true,"internalType":"uint32","name":"week","type":"uint32"}],"name":"MerkleRootUpdated","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":"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":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"freeze","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"frozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"},{"internalType":"bool","name":"direct","type":"bool"},{"internalType":"bool","name":"renounce","type":"bool"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unfreeze","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"updateMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"week","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"}]

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

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

0000000000000000000000006b3595068778dd592e39a122f4f5a5cf09c90fe246b5d189cdd7d522e3c120e9750a570e1aa74ab969a0fb2f55536e9479e88918

-----Decoded View---------------
Arg [0] : token_ (address): 0x6b3595068778dd592e39a122f4f5a5cf09c90fe2
Arg [1] : merkleRoot_ (bytes32): 0x46b5d189cdd7d522e3c120e9750a570e1aa74ab969a0fb2f55536e9479e88918

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000006b3595068778dd592e39a122f4f5a5cf09c90fe2
Arg [1] : 46b5d189cdd7d522e3c120e9750a570e1aa74ab969a0fb2f55536e9479e88918


Deployed ByteCode Sourcemap

7730:2421:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7916:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;6667:432;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;6667:432:0;;;;;;;;;;;;;;;;;:::i;:::-;;8865:725;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8865:725:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8865:725:0;;-1:-1:-1;8865:725:0;-1:-1:-1;8865:725:0;:::i;7841:34::-;;;:::i;:::-;;;;;;;;;;;;;;;;9769:379;;;;;;;;;;;;;;;;-1:-1:-1;9769:379:0;;:::i;7882:27::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;7148:340;;;:::i;9598:76::-;;;:::i;9682:79::-;;;:::i;6253:20::-;;;:::i;:::-;;;;-1:-1:-1;;;;;6253:20:0;;;;;;;;;;;;;;8250:337;;;;;;;;;;;;;;;;-1:-1:-1;8250:337:0;;:::i;6300:27::-;;;:::i;7795:39::-;;;:::i;7916:27::-;;;;;;;;;:::o;6667:432::-;7591:5;;-1:-1:-1;;;;;7591:5:0;7577:10;:19;7569:64;;;;;-1:-1:-1;;;7569:64:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7569:64:0;;;;;;;;;;;;;;;6772:6:::1;6768:324;;;-1:-1:-1::0;;;;;6826:22:0;::::1;::::0;::::1;::::0;:34:::1;;;6852:8;6826:34;6818:68;;;::::0;;-1:-1:-1;;;6818:68:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;6818:68:0;;;;;;;;;;;;;::::1;;6953:5;::::0;;6932:37:::1;::::0;-1:-1:-1;;;;;6932:37:0;;::::1;::::0;6953:5;::::1;::::0;6932:37:::1;::::0;::::1;6984:5;:16:::0;;-1:-1:-1;;;;;;6984:16:0::1;-1:-1:-1::0;;;;;6984:16:0;::::1;;::::0;;6768:324:::1;;;7057:12;:23:::0;;-1:-1:-1;;;;;;7057:23:0::1;-1:-1:-1::0;;;;;7057:23:0;::::1;;::::0;;6768:324:::1;6667:432:::0;;;:::o;8865:725::-;8998:6;;;;;;;8997:7;8989:58;;;;-1:-1:-1;;;8989:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9067:16;9077:5;9067:9;:16::i;:::-;9066:17;9058:70;;;;-1:-1:-1;;;9058:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9178:12;9220:5;9227:7;9236:6;9203:40;;;;;;;;;;;-1:-1:-1;;;;;9203:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9193:51;;;;;;9178:66;;9263:49;9282:11;;9263:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9295:10:0;;;-1:-1:-1;9307:4:0;;-1:-1:-1;9263:18:0;:49::i;:::-;9255:95;;;;-1:-1:-1;;;9255:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9411:18;9423:5;9411:11;:18::i;:::-;9455:5;-1:-1:-1;;;;;9448:22:0;;9471:7;9480:6;9448:39;;;;;;;;;;;;;-1:-1:-1;;;;;9448:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9448:39:0;9440:87;;;;-1:-1:-1;;;9440:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9577:4;;9545:37;;;;;;;;;;;;;;9577:4;;;;;-1:-1:-1;;;;;9545:37:0;;;;;;;;;;;8865:725;;;;;;:::o;7841:34::-;;;;:::o;9769:379::-;7591:5;;-1:-1:-1;;;;;7591:5:0;7577:10;:19;7569:64;;;;;-1:-1:-1;;;7569:64:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7569:64:0;;;;;;;;;;;;;;;9861:6:::1;::::0;;;::::1;;;9853:58;;;;-1:-1:-1::0;;;9853:58:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10008:4;::::0;;-1:-1:-1;;10001:15:0;::::1;10008:4:::0;::::1;::::0;;::::1;:8;10001:15:::0;::::1;;::::0;;;;10063:10:::1;:24:::0;;;10105:35:::1;::::0;10135:4;::::1;::::0;10063:24;;10105:35:::1;::::0;-1:-1:-1;;10105:35:0::1;9769:379:::0;:::o;7882:27::-;;;;;;:::o;7148:340::-;7216:12;;-1:-1:-1;;;;;7216:12:0;7268:10;:27;;7260:72;;;;;-1:-1:-1;;;7260:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7391:5;;;7370:42;;-1:-1:-1;;;;;7370:42:0;;;;7391:5;;;7370:42;;;7423:5;:21;;-1:-1:-1;;;;;7423:21:0;;;-1:-1:-1;;;;;;7423:21:0;;;;;;;7455:25;;;;;;;7148:340::o;9598:76::-;7591:5;;-1:-1:-1;;;;;7591:5:0;7577:10;:19;7569:64;;;;;-1:-1:-1;;;7569:64:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7569:64:0;;;;;;;;;;;;;;;9653:6:::1;:13:::0;;-1:-1:-1;;9653:13:0::1;::::0;::::1;::::0;;9598:76::o;9682:79::-;7591:5;;-1:-1:-1;;;;;7591:5:0;7577:10;:19;7569:64;;;;;-1:-1:-1;;;7569:64:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7569:64:0;;;;;;;;;;;;;;;9739:6:::1;:14:::0;;-1:-1:-1;;9739:14:0::1;::::0;;9682:79::o;6253:20::-;;;-1:-1:-1;;;;;6253:20:0;;:::o;8250:337::-;8464:4;;;;8314;8450:19;;;:13;:19;;;;;;;;8366:3;8358:11;;8450:37;;;;;;;;8464:4;8406:11;;;;8514:20;;;;8553:18;;;:26;;8250:337::o;6300:27::-;;;-1:-1:-1;;;;;6300:27:0;;:::o;7795:39::-;;;:::o;3472:796::-;3563:4;3603;3563;3620:525;3644:5;:12;3640:1;:16;3620:525;;;3678:20;3701:5;3707:1;3701:8;;;;;;;;;;;;;;3678:31;;3746:12;3730;:28;3726:408;;3900:12;3914;3883:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3873:55;;;;;;3858:70;;3726:408;;;4090:12;4104;4073:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4063:55;;;;;;4048:70;;3726:408;-1:-1:-1;3658:3:0;;3620:525;;;-1:-1:-1;4240:20:0;;;;3472:796;-1:-1:-1;;;3472:796:0:o;8595:262::-;8801:4;;;;8650:24;8787:19;;;:13;:19;;;;;;;;8685:3;8677:11;;8787:37;;;;;;;;;8828:1;8725:11;;;;8828:20;;;;8787:62;;;8747:102;;8595:262::o

Swarm Source

ipfs://0193ca03216f8913081efec7032ed4b9edac29334632cb187e590909fa048d57
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.