Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-05-03
*/

// SPDX-License-Identifier: GPL-3.0
// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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





            
// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)


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




      

// https://docs.synthetix.io/contracts/source/contracts/owned
contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor(address _owner) {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(
            msg.sender == nominatedOwner,
            "You must be nominated before you can accept ownership"
        );
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        _onlyOwner();
        _;
    }

    function _onlyOwner() private view {
        require(
            msg.sender == owner,
            "Only the contract owner may perform this action"
        );
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}





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




         
// OpenZeppelin Contracts v4.4.0 (utils/cryptography/MerkleProof.sol)


/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
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) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        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));
            }
        }
        return computedHash;
    }
}



       
// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
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) {
        unchecked {
            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) {
        unchecked {
            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) {
        unchecked {
            // 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) {
        unchecked {
            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) {
        unchecked {
            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) {
        return a + b;
    }

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

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}





            
// OpenZeppelin Contracts v4.4.0 (token/ERC20/utils/SafeERC20.sol)

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

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

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

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

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

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

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

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





////import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
////import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
////import "@openzeppelin/contracts/utils/math/SafeMath.sol";
////import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
////import "../interfaces/IMerkleDistributor.sol";
////import "../common/Owned.sol";

contract MerkleDistributor is IMerkleDistributor, Owned {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

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

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

    uint256 public immutable ownerUnlockTime;

    constructor(
        address _owner,
        address _token,
        bytes32 _merkleRoot,
        uint256 _daysUntilUnlock
    ) Owned(_owner) {
        require(_owner != address(0), "Owner must be non-zero address");
        require(_token != address(0), "Airdrop token must be non-zero address");
        require(_merkleRoot != bytes32(0), "Merkle root must be non-zero");
        require(
            _daysUntilUnlock > 0,
            "Days until owner unlock must be in the future"
        );
        token = _token;
        merkleRoot = _merkleRoot;
        ownerUnlockTime = block.timestamp.add(_daysUntilUnlock * 1 days);
    }

    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 {
        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);
        IERC20(token).safeTransfer(account, amount);

        emit Claimed(index, account, amount);
    }

    // Used for recovery purposes
    function recoverERC20(address tokenAddress, uint256 tokenAmount)
        external
        onlyOwner
    {
        require(
            tokenAddress == address(token)
                ? block.timestamp >= ownerUnlockTime
                : true,
            "MerkleDistributor: Cannot withdraw the token before unlock time"
        );
        IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
        emit Recovered(tokenAddress, tokenAmount);
    }

    /* ========== EVENTS ========== */
    event Recovered(address token, uint256 amount);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"_daysUntilUnlock","type":"uint256"}],"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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","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":"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":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000e5b5514e0618f4b55736c0c0c78ccd6f8ac146310000000000000000000000006b175474e89094c44da98b954eedeac495271d0f5c4fa8d61ff0a9d0f136c9dbcb60a179adca6adc31c0b5042a738ca956b6f6fd000000000000000000000000000000000000000000000000000000000000005a

-----Decoded View---------------
Arg [0] : _owner (address): 0xe5b5514e0618f4B55736c0c0C78CCD6F8AC14631
Arg [1] : _token (address): 0x6B175474E89094C44Da98b954EedeAC495271d0F
Arg [2] : _merkleRoot (bytes32): 0x5c4fa8d61ff0a9d0f136c9dbcb60a179adca6adc31c0b5042a738ca956b6f6fd
Arg [3] : _daysUntilUnlock (uint256): 90

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000e5b5514e0618f4b55736c0c0c78ccd6f8ac14631
Arg [1] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f
Arg [2] : 5c4fa8d61ff0a9d0f136c9dbcb60a179adca6adc31c0b5042a738ca956b6f6fd
Arg [3] : 000000000000000000000000000000000000000000000000000000000000005a

26477:2952:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11328:141;;;;;;:::i;:::-;;:::i;:::-;;28139:686;;;;;;:::i;:::-;;:::i;26654:44::-;;;;;;;;1360:25:1;;;1348:2;1333:18;26654:44:0;;;;;;;;11104:29;;;;;-1:-1:-1;;;;;11104:29:0;;;;;;-1:-1:-1;;;;;1560:32:1;;;1542:51;;1530:2;1515:18;11104:29:0;1396:203:1;26809:40:0;;;;;11477:308;;;:::i;28868:463::-;;;;;;:::i;:::-;;:::i;11077:20::-;;;;;-1:-1:-1;;;;;11077:20:0;;;27516:331;;;;;;:::i;:::-;;:::i;:::-;;;2395:14:1;;2388:22;2370:41;;2358:2;2343:18;27516:331:0;2230:187:1;26608:39:0;;;;;11328:141;11823:12;:10;:12::i;:::-;11400:14:::1;:23:::0;;-1:-1:-1;;;;;;11400:23:0::1;-1:-1:-1::0;;;;;11400:23:0;::::1;::::0;;::::1;::::0;;;11439:22:::1;::::0;1542:51:1;;;11439:22:0::1;::::0;1530:2:1;1515:18;11439:22:0::1;;;;;;;11328:141:::0;:::o;28139:686::-;28315:16;28325:5;28315:9;:16::i;:::-;28314:17;28306:70;;;;-1:-1:-1;;;28306:70:0;;2624:2:1;28306:70:0;;;2606:21:1;2663:2;2643:18;;;2636:30;2702:34;2682:18;;;2675:62;-1:-1:-1;;;2753:18:1;;;2746:38;2801:19;;28306:70:0;;;;;;;;;28451:40;;;;;;3016:19:1;;;-1:-1:-1;;3073:2:1;3069:15;;;3065:53;3051:12;;;3044:75;;;;3135:12;;;3128:28;;;28426:12:0;;3172::1;;28451:40:0;;;;;;;;;;;;28441:51;;;;;;28426:66;;28525:49;28544:11;;28525:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28557:10:0;;-1:-1:-1;28569:4:0;;-1:-1:-1;28525:18:0;;-1:-1:-1;28525:49:0:i;:::-;28503:132;;;;-1:-1:-1;;;28503:132:0;;3397:2:1;28503:132:0;;;3379:21:1;3436:2;3416:18;;;3409:30;3475:34;3455:18;;;3448:62;-1:-1:-1;;;3526:18:1;;;3519:31;3567:19;;28503:132:0;3195:397:1;28503:132:0;28696:18;28708:5;28696:11;:18::i;:::-;28725:43;-1:-1:-1;;;;;28732:5:0;28725:26;28752:7;28761:6;28725:26;:43::i;:::-;28786:31;;;3799:25:1;;;-1:-1:-1;;;;;3860:32:1;;3855:2;3840:18;;3833:60;3909:18;;;3902:34;;;28786:31:0;;3787:2:1;3772:18;28786:31:0;;;;;;;28295:530;28139:686;;;;;:::o;11477:308::-;11560:14;;-1:-1:-1;;;;;11560:14:0;11546:10;:28;11524:131;;;;-1:-1:-1;;;11524:131:0;;4149:2:1;11524:131:0;;;4131:21:1;4188:2;4168:18;;;4161:30;4227:34;4207:18;;;4200:62;-1:-1:-1;;;4278:18:1;;;4271:51;4339:19;;11524:131:0;3947:417:1;11524:131:0;11684:5;;;11691:14;11671:35;;;-1:-1:-1;;;;;11684:5:0;;;4581:34:1;;11691:14:0;;;;4646:2:1;4631:18;;4624:43;11671:35:0;;4516:18:1;11671:35:0;;;;;;;11725:14;;;;11717:22;;-1:-1:-1;;;;;;11717:22:0;;;-1:-1:-1;;;;;11725:14:0;;11717:22;;;;11750:27;;;11477:308::o;28868:463::-;11823:12;:10;:12::i;:::-;29032:5:::1;-1:-1:-1::0;;;;;29008:30:0::1;:12;-1:-1:-1::0;;;;;29008:30:0::1;;:108;;29112:4;29008:108;;;29077:15;29058;:34;;29008:108;28986:221;;;::::0;-1:-1:-1;;;28986:221:0;;4880:2:1;28986:221:0::1;::::0;::::1;4862:21:1::0;4919:2;4899:18;;;4892:30;4958:34;4938:18;;;4931:62;5029:33;5009:18;;;5002:61;5080:19;;28986:221:0::1;4678:427:1::0;28986:221:0::1;29252:5;::::0;29218:53:::1;::::0;-1:-1:-1;;;;;29218:33:0;;::::1;::::0;29252:5:::1;29259:11:::0;29218:33:::1;:53::i;:::-;29287:36;::::0;;-1:-1:-1;;;;;5302:32:1;;5284:51;;5366:2;5351:18;;5344:34;;;29287:36:0::1;::::0;5257:18:1;29287:36:0::1;;;;;;;28868:463:::0;;:::o;27516:331::-;27580:4;;27624:11;27632:3;27624:5;:11;:::i;:::-;27597:38;-1:-1:-1;27646:23:0;27672:11;27680:3;27672:5;:11;:::i;:::-;27694:19;27716:31;;;:13;:31;;;;;;;27774:1;:20;;;27813:18;;;:26;;;;27516:331;-1:-1:-1;;;27516:331:0:o;17958:98::-;18016:7;18043:5;18047:1;18043;:5;:::i;:::-;18036:12;17958:98;-1:-1:-1;;;17958:98:0:o;11863:170::-;11945:5;;-1:-1:-1;;;;;11945:5:0;11931:10;:19;11909:116;;;;-1:-1:-1;;;11909:116:0;;6230:2:1;11909:116:0;;;6212:21:1;6269:2;6249:18;;;6242:30;6308:34;6288:18;;;6281:62;-1:-1:-1;;;6359:18:1;;;6352:45;6414:19;;11909:116:0;6028:411:1;11909:116:0;11863:170::o;13912:190::-;14037:4;14090;14061:25;14074:5;14081:4;14061:12;:25::i;:::-;:33;;13912:190;-1:-1:-1;;;;13912:190:0:o;27855:276::-;27910:24;27937:11;27945:3;27937:5;:11;:::i;:::-;27910:38;-1:-1:-1;27959:23:0;27985:11;27993:3;27985:5;:11;:::i;:::-;28054:31;;;;:13;:31;;;;;;;;28102:1;:20;;;28054:69;;;28007:116;;;-1:-1:-1;;27855:276:0:o;22814:211::-;22958:58;;;-1:-1:-1;;;;;5302:32:1;;22958:58:0;;;5284:51:1;5351:18;;;;5344:34;;;22958:58:0;;;;;;;;;;5257:18:1;;;;22958:58:0;;;;;;;;-1:-1:-1;;;;;22958:58:0;-1:-1:-1;;;22958:58:0;;;22931:86;;22951:5;;22931:19;:86::i;:::-;22814:211;;;:::o;14464:701::-;14547:7;14590:4;14547:7;14605:523;14629:5;:12;14625:1;:16;14605:523;;;14663:20;14686:5;14692:1;14686:8;;;;;;;;:::i;:::-;;;;;;;14663:31;;14729:12;14713;:28;14709:408;;14866:44;;;;;;6733:19:1;;;6768:12;;;6761:28;;;6805:12;;14866:44:0;;;;;;;;;;;;14856:55;;;;;;14841:70;;14709:408;;;15056:44;;;;;;6733:19:1;;;6768:12;;;6761:28;;;6805:12;;15056:44:0;;;;;;;;;;;;15046:55;;;;;;15031:70;;14709:408;-1:-1:-1;14643:3:0;;;;:::i;:::-;;;;14605:523;;;-1:-1:-1;15145:12:0;14464:701;-1:-1:-1;;;14464:701:0:o;25387:716::-;25811:23;25837:69;25865:4;25837:69;;;;;;;;;;;;;;;;;25845:5;-1:-1:-1;;;;;25837:27:0;;;:69;;;;;:::i;:::-;25921:17;;25811:95;;-1:-1:-1;25921:21:0;25917:179;;26018:10;26007:30;;;;;;;;;;;;:::i;:::-;25999:85;;;;-1:-1:-1;;;25999:85:0;;7452:2:1;25999:85:0;;;7434:21:1;7491:2;7471:18;;;7464:30;7530:34;7510:18;;;7503:62;-1:-1:-1;;;7581:18:1;;;7574:40;7631:19;;25999:85:0;7250:406:1;3615:229:0;3752:12;3784:52;3806:6;3814:4;3820:1;3823:12;3784:21;:52::i;:::-;3777:59;3615:229;-1:-1:-1;;;;3615:229:0:o;4735:510::-;4905:12;4963:5;4938:21;:30;;4930:81;;;;-1:-1:-1;;;4930:81:0;;7863:2:1;4930:81:0;;;7845:21:1;7902:2;7882:18;;;7875:30;7941:34;7921:18;;;7914:62;-1:-1:-1;;;7992:18:1;;;7985:36;8038:19;;4930:81:0;7661:402:1;4930:81:0;1128:20;;5022:60;;;;-1:-1:-1;;;5022:60:0;;8270:2:1;5022:60:0;;;8252:21:1;8309:2;8289:18;;;8282:30;8348:31;8328:18;;;8321:59;8397:18;;5022:60:0;8068:353:1;5022:60:0;5096:12;5110:23;5137:6;-1:-1:-1;;;;;5137:11:0;5156:5;5163:4;5137:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5095:73;;;;5186:51;5203:7;5212:10;5224:12;5186:16;:51::i;:::-;5179:58;4735:510;-1:-1:-1;;;;;;;4735:510:0:o;7421:712::-;7571:12;7600:7;7596:530;;;-1:-1:-1;7631:10:0;7624:17;;7596:530;7745:17;;:21;7741:374;;7943:10;7937:17;8004:15;7991:10;7987:2;7983:19;7976:44;7741:374;8086:12;8079:20;;-1:-1:-1;;;8079:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;383:826::-;496:6;504;512;520;528;581:3;569:9;560:7;556:23;552:33;549:53;;;598:1;595;588:12;549:53;634:9;621:23;611:33;;663:38;697:2;686:9;682:18;663:38;:::i;:::-;653:48;;748:2;737:9;733:18;720:32;710:42;;803:2;792:9;788:18;775:32;826:18;867:2;859:6;856:14;853:34;;;883:1;880;873:12;853:34;921:6;910:9;906:22;896:32;;966:7;959:4;955:2;951:13;947:27;937:55;;988:1;985;978:12;937:55;1028:2;1015:16;1054:2;1046:6;1043:14;1040:34;;;1070:1;1067;1060:12;1040:34;1123:7;1118:2;1108:6;1105:1;1101:14;1097:2;1093:23;1089:32;1086:45;1083:65;;;1144:1;1141;1134:12;1083:65;383:826;;;;-1:-1:-1;383:826:1;;-1:-1:-1;1175:2:1;1167:11;;1197:6;383:826;-1:-1:-1;;;383:826:1:o;1786:254::-;1854:6;1862;1915:2;1903:9;1894:7;1890:23;1886:32;1883:52;;;1931:1;1928;1921:12;1883:52;1954:29;1973:9;1954:29;:::i;:::-;1944:39;2030:2;2015:18;;;;2002:32;;-1:-1:-1;;;1786:254:1:o;2045:180::-;2104:6;2157:2;2145:9;2136:7;2132:23;2128:32;2125:52;;;2173:1;2170;2163:12;2125:52;-1:-1:-1;2196:23:1;;2045:180;-1:-1:-1;2045:180:1:o;5389:127::-;5450:10;5445:3;5441:20;5438:1;5431:31;5481:4;5478:1;5471:15;5505:4;5502:1;5495:15;5521:127;5582:10;5577:3;5573:20;5570:1;5563:31;5613:4;5610:1;5603:15;5637:4;5634:1;5627:15;5653:120;5693:1;5719;5709:35;;5724:18;;:::i;:::-;-1:-1:-1;5758:9:1;;5653:120::o;5778:112::-;5810:1;5836;5826:35;;5841:18;;:::i;:::-;-1:-1:-1;5875:9:1;;5778:112::o;5895:128::-;5935:3;5966:1;5962:6;5959:1;5956:13;5953:39;;;5972:18;;:::i;:::-;-1:-1:-1;6008:9:1;;5895:128::o;6444:127::-;6505:10;6500:3;6496:20;6493:1;6486:31;6536:4;6533:1;6526:15;6560:4;6557:1;6550:15;6828:135;6867:3;-1:-1:-1;;6888:17:1;;6885:43;;;6908:18;;:::i;:::-;-1:-1:-1;6955:1:1;6944:13;;6828:135::o;6968:277::-;7035:6;7088:2;7076:9;7067:7;7063:23;7059:32;7056:52;;;7104:1;7101;7094:12;7056:52;7136:9;7130:16;7189:5;7182:13;7175:21;7168:5;7165:32;7155:60;;7211:1;7208;7201:12;8426:258;8498:1;8508:113;8522:6;8519:1;8516:13;8508:113;;;8598:11;;;8592:18;8579:11;;;8572:39;8544:2;8537:10;8508:113;;;8639:6;8636:1;8633:13;8630:48;;;8674:1;8665:6;8660:3;8656:16;8649:27;8630:48;;8426:258;;;:::o;8689:274::-;8818:3;8856:6;8850:13;8872:53;8918:6;8913:3;8906:4;8898:6;8894:17;8872:53;:::i;:::-;8941:16;;;;;8689:274;-1:-1:-1;;8689:274:1:o;8968:383::-;9117:2;9106:9;9099:21;9080:4;9149:6;9143:13;9192:6;9187:2;9176:9;9172:18;9165:34;9208:66;9267:6;9262:2;9251:9;9247:18;9242:2;9234:6;9230:15;9208:66;:::i;:::-;9335:2;9314:15;-1:-1:-1;;9310:29:1;9295:45;;;;9342:2;9291:54;;8968:383;-1:-1:-1;;8968:383:1:o

ipfs://bd7313051602332a51a13528da480cd29db855502d109d3b503004987d038e56