Contract 0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x105bbc568d994e6e74ee0bd94b42810367f45709fa1df91d2bef0b35d6b76835Claim185582512022-08-12 18:56:50179 days 2 hrs ago0x595378252d8156cd66d6d318cd0cea545eb3ec7f IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.0024707275 26.5
0x85337fb64a33c79e1f6e24f7c6939b8d4a1ae9eb6f6d88db353bb26ee941077eClaim141433542022-05-01 17:19:32282 days 4 hrs ago0xa522a79b8db481ebb9d3ebdd0ad23709deebc8a1 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.005996845239 64.316919311
0x0a6657026a46fd863f67be9c535e11669ed6279ad0811fbe08fc882a3fd38ff8Claim140309762022-04-29 0:59:07284 days 20 hrs ago0x1e873b138fbe61df1746abbbad51a02696be662c IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.002643565269 28.339196523
0x3ca689577a46b3320da09f3e7b9f51bf6dd3d4ec488b5a3266ff32d6bf82f3d1Claim140240272022-04-28 20:59:57285 days 31 mins ago0x93c4c1e86434ea4e831d8a13e64ac288c49b7b76 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.003863956213 41.428975026
0x45ea9e88e870bc15c17dfd9cb3bf49f714e06acae62620ac2dd0a9a47c6f0887Claim139676612022-04-27 13:06:53286 days 8 hrs ago0x15311794c696dadd96c45c4151930ea2f4a9f517 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.006678436635 87.706830856
0x3f83b5ae0e16e91054229a78f7f441a3741bef532f06e99b3c7c502131d3965eClaim138337022022-04-24 10:14:53289 days 11 hrs ago0xb47ecbc03615c39eb4e211f720a172b9ce0c66ac IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.004391939153 57.689235051
0x5e6788fdf8b6d82bc68bac83e522808cba3e15681fb74bed234fed9c90a0c08bClaim137930272022-04-23 11:30:05290 days 10 hrs ago0x7a39300450a2a165febd62fb31b45f8ab1fd6a39 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.005503862022 60.16530594
0x5051eb7a75148d2219583e44b9a5e5ad225f464abc7afd4dd7352cbc3a6b5a74Claim137926672022-04-23 11:18:01290 days 10 hrs ago0xff2c72f3368a65bf4c71680fea1c3d27202d27ed IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.005725918141 61.399338831
0x755431a2c192a4df62f6cbf75654c23b0438aebf4d9a7f0cb2c1d7fe18bcd109Claim137469182022-04-22 9:41:43291 days 11 hrs ago0x78f5f654dbf5a638967ed922f8ee3c4dd272dec1 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.00324235003234.769391142
0x7784e83ad7cdf910ccd2dacdbaa0531d1e36f6afce3964cd8e587c4c08a4bf91Claim137202042022-04-21 18:41:43292 days 2 hrs ago0x97f9ddbf1204de1721bd133da9f82135975dbc02 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.006785870982 89.092008114
0x5dd1517161b0a9bc30f77862be2a2997c987a24af23aedbb49296175e1f2fd9cClaim134949112022-04-16 13:02:00297 days 8 hrs ago0x211d895223d4129cf8cad1a7f7f64a2f572743e6 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.00425945063 55.929863703
0x56b7aef446f3a020f5c499a82151224d361e20e955b74d4ce55a0e17baf9b37aClaim134749672022-04-16 1:53:17297 days 19 hrs ago0x310cb8e87ae277133e6d5c17670bbd60ffa19e35 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.00499218238 53.550973262
0xc44d8f6bd2b14bfdf2a898f1436822fdc07ebcc6049fea88b0776ac093256c0cClaim134235932022-04-14 21:03:41299 days 28 mins ago0x29072922508337172f7935b78e6a83024844c084 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.006765522064 73.957105615
0x3ceb2dddf51ba3205078e9e90da84e2d8745470ec6732703c9b3ee07f40e3bfbClaim134232822022-04-14 20:53:18299 days 38 mins ago0x9bce8a6b17bf801ef624671b62307d8e3c0fcc8b IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.006702387337 71.863907551
0xccb9bc9fc5edd57d9c073a61966c43e01424c1141f845d72d861f311d95240aeClaim134131502022-04-14 15:12:33299 days 6 hrs ago0x066fc9bae8f2c944ec9fcccbe92b95d73f3de46d IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.007068956395 75.826831807
0x6e69a3735d565d335a1eac653ea12ab8009089332dd744eb45f8780eccbeaf66Claim133964572022-04-14 6:02:37299 days 15 hrs ago0xff3bceb0672287f8e807e5f034bd6ba34bfa1673 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.00568213824 60.973036462
0x0d03cc619cbd97af49c7f385439501c5160cb5560bd39acea4154ebc6f1712b0Claim133827732022-04-13 22:23:26299 days 23 hrs ago0x7a039b59df9c9fe981290a9147fd49de892ba476 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.005315347567 69.776278499
0x7e3152b555a9d4fb9f7a62b67ce03796ad7d50c85fcc024b463d3c85568aa09cClaim131799172022-04-09 4:25:07304 days 17 hrs ago0x63c7758b14545ff35186418729bfea18984e0d7d IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.003801295845 40.780747809
0xb35d9d7c8040493948057c2adba2a1ffc569b4099a7e471c57b72614c1070727Claim131474242022-04-08 10:09:53305 days 11 hrs ago0xa6b49397ce21bb62200e914f41bf371e5940bb41 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.004461734052 58.58907794
0x08389c924e013d08c535033d4ea675cbf903de3c1cc6df32f3f8d4e3ffae50b5Claim131222122022-04-07 19:58:58306 days 1 hr ago0x42891b9297fc1beac3e6dfef9fefbb8af55f5512 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.009794774355 105.043427053
0xc612bd3e442e1047b3c1cebee45c7ef4676db8d5843e61291cfe7a26a4121791Claim131129682022-04-07 14:46:54306 days 6 hrs ago0xb7be3631d8de49e12dedaa26bf8a05daf54297a6 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.010502868057 112.646996984
0x33414d1724284b80537bdcf3cc53d9c94c837c5b8ddc606e45c7db6a944e80fcClaim130292482022-04-05 15:36:09308 days 5 hrs ago0xe1a1139649ec6b928b9d0b4be6ad094c85e97ef6 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.008584004907 92.068481876
0xde67743b19d02975f8219c09b7ab3662ef0a404de9d6a6424902c57ea8c5fda5Claim130250812022-04-05 13:05:17308 days 8 hrs ago0xa81ace214b97d4b9c2072a934d0c4de486757538 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.008380762491 89.826927311
0x0a2c0f497ffc2ac83296cf8f2c1f469b14acfaa3b0c2b66c313b00f3dc27737fClaim130051742022-04-05 1:22:30308 days 20 hrs ago0xa2fb59f1331428351867e6e262eeb5dfad725ef2 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.004995702892 53.582989844
0xa55a256ec70fec9406c620fecd7332e1d9ff938e9d3b666a7eecf97f160877d3Claim129177532022-04-02 23:13:49310 days 22 hrs ago0x048991621523fd86eebffbf091086b65748efad5 IN  0xee025a9deaca0fbe0ea30d7d9b1aed833a8020ad0 AVAX0.003209849137 42.142255012
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MerkleDistributor

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity Multiple files format)

File 1 of 7: MerkleDistributor.sol
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import {Ownable} from "./Ownable.sol";
import {MerkleProof} from "./MerkleProof.sol";
import {IERC20} from "./IERC20.sol";
import {SafeERC20} from "./SafeERC20.sol";

contract MerkleDistributor is Ownable {
    using SafeERC20 for IERC20;

    uint256 public immutable startTimestamp;
    uint256 public immutable rescueTimestamp;
    bytes32 public immutable merkleRoot;
    IERC20  public immutable token;
    mapping(address => bool) public claimed;

    event Claimed(address indexed account, uint256 amount);

    constructor(bytes32 _merkleRoot, address _tokenAddress, uint256 _startTimestamp, uint256 _rescueDelay) {
        merkleRoot = _merkleRoot;
        token = IERC20(_tokenAddress);
        rescueTimestamp = block.timestamp + _rescueDelay;
        startTimestamp = _startTimestamp;
    }

    function claim(
        address account,
        uint256 amount,
        bytes32[] calldata merkleProof
    ) public {
        require(startTimestamp == 0 || block.timestamp >= startTimestamp, "Claim not avaliable yet");
        require(claimed[account] == false, "Already claimed");

        bytes32 node = keccak256(abi.encodePacked(account, amount));
        require(
            MerkleProof.verify(merkleProof, merkleRoot, node),
            "Invalid proof"
        );

        claimed[account] = true;
        token.safeTransfer(account, amount);

        emit Claimed(account, amount);
    }

    function rescue(address _destination) public onlyOwner {
        require(block.timestamp >= rescueTimestamp, "Rescue not avaliable yet");
        token.safeTransfer(_destination, token.balanceOf(address(this)));
    }
}

File 2 of 7: Address.sol
// SPDX-License-Identifier: MIT

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

File 3 of 7: Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

File 4 of 7: IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^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 5 of 7: MerkleProof.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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) {
        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 6 of 7: Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 7 of 7: SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./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");
        }
    }
}

Contract ABI

[{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"},{"internalType":"uint256","name":"_rescueDelay","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimed","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_destination","type":"address"}],"name":"rescue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rescueTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

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

890e89594534f07c4e3fececaf7a34628411ee875cf5437347a167d67717f3aa0000000000000000000000008ae8be25c23833e0a01aa200403e826f611f9cd20000000000000000000000000000000000000000000000000000000061cef0c00000000000000000000000000000000000000000000000000000000000015180

-----Decoded View---------------
Arg [0] : _merkleRoot (bytes32): 0x890e89594534f07c4e3fececaf7a34628411ee875cf5437347a167d67717f3aa
Arg [1] : _tokenAddress (address): 0x8ae8be25c23833e0a01aa200403e826f611f9cd2
Arg [2] : _startTimestamp (uint256): 1640952000
Arg [3] : _rescueDelay (uint256): 86400

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 890e89594534f07c4e3fececaf7a34628411ee875cf5437347a167d67717f3aa
Arg [1] : 0000000000000000000000008ae8be25c23833e0a01aa200403e826f611f9cd2
Arg [2] : 0000000000000000000000000000000000000000000000000000000061cef0c0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000015180


Deployed ByteCode Sourcemap

223:1463:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;391:35;;;;;;;;160:25:7;;;148:2;133:18;391:35:3;;;;;;;;864:597;;;;;;:::i;:::-;;:::i;:::-;;1598:92:5;;;:::i;1467:217:3:-;;;;;;:::i;:::-;;:::i;966:85:5:-;1012:7;1038:6;-1:-1:-1;;;;;1038:6:5;966:85;;;-1:-1:-1;;;;;1491:32:7;;;1473:51;;1461:2;1446:18;966:85:5;1327:203:7;345:40:3;;;;;468:39;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1882:14:7;;1875:22;1857:41;;1845:2;1830:18;468:39:3;1717:187:7;300:39:3;;;;;1839:189:5;;;;;;:::i;:::-;;:::i;432:30:3:-;;;;;864:597;999:14;:19;;:56;;;1041:14;1022:15;:33;;999:56;991:92;;;;-1:-1:-1;;;991:92:3;;2333:2:7;991:92:3;;;2315:21:7;2372:2;2352:18;;;2345:30;2411:25;2391:18;;;2384:53;2454:18;;991:92:3;;;;;;;;;-1:-1:-1;;;;;1101:16:3;;;;;;:7;:16;;;;;;;;:25;1093:53;;;;-1:-1:-1;;;1093:53:3;;2685:2:7;1093:53:3;;;2667:21:7;2724:2;2704:18;;;2697:30;-1:-1:-1;;;2743:18:7;;;2736:45;2798:18;;1093:53:3;2483:339:7;1093:53:3;1182:33;;-1:-1:-1;;3004:2:7;3000:15;;;2996:53;1182:33:3;;;2984:66:7;3066:12;;;3059:28;;;1157:12:3;;3103::7;;1182:33:3;;;;;;;;;;;;1172:44;;;;;;1157:59;;1247:49;1266:11;;1247:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1279:10:3;;-1:-1:-1;1291:4:3;;-1:-1:-1;1247:18:3;;-1:-1:-1;1247:49:3:i;:::-;1226:109;;;;-1:-1:-1;;;1226:109:3;;3328:2:7;1226:109:3;;;3310:21:7;3367:2;3347:18;;;3340:30;-1:-1:-1;;;3386:18:7;;;3379:43;3439:18;;1226:109:3;3126:337:7;1226:109:3;-1:-1:-1;;;;;1346:16:3;;;;;;;1365:4;1346:16;;;;;;;;:23;;-1:-1:-1;;1346:23:3;;;;;;1379:35;;:5;:18;1354:7;1407:6;1379:18;:35::i;:::-;1438:7;-1:-1:-1;;;;;1430:24:3;;1447:6;1430:24;;;;160:25:7;;148:2;133:18;;14:177;1430:24:3;;;;;;;;981:480;864:597;;;;:::o;1598:92:5:-;1012:7;1038:6;-1:-1:-1;;;;;1038:6:5;666:10:1;1178:23:5;1170:68;;;;-1:-1:-1;;;1170:68:5;;;;;;;:::i;:::-;1662:21:::1;1680:1;1662:9;:21::i;:::-;1598:92::o:0;1467:217:3:-;1012:7:5;1038:6;-1:-1:-1;;;;;1038:6:5;666:10:1;1178:23:5;1170:68;;;;-1:-1:-1;;;1170:68:5;;;;;;;:::i;:::-;1559:15:3::1;1540;:34;;1532:71;;;::::0;-1:-1:-1;;;1532:71:3;;4031:2:7;1532:71:3::1;::::0;::::1;4013:21:7::0;4070:2;4050:18;;;4043:30;4109:26;4089:18;;;4082:54;4153:18;;1532:71:3::1;3829:348:7::0;1532:71:3::1;1646:30;::::0;-1:-1:-1;;;1646:30:3;;1670:4:::1;1646:30;::::0;::::1;1473:51:7::0;1613:64:3::1;::::0;1632:12;;-1:-1:-1;;;;;1646:5:3::1;:15;::::0;::::1;::::0;1446:18:7;;1646:30:3::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;1613:5:3::1;:18;::::0;:64;:18:::1;:64::i;:::-;1467:217:::0;:::o;1839:189:5:-;1012:7;1038:6;-1:-1:-1;;;;;1038:6:5;666:10:1;1178:23:5;1170:68;;;;-1:-1:-1;;;1170:68:5;;;;;;;:::i;:::-;-1:-1:-1;;;;;1927:22:5;::::1;1919:73;;;::::0;-1:-1:-1;;;1919:73:5;;4573:2:7;1919:73:5::1;::::0;::::1;4555:21:7::0;4612:2;4592:18;;;4585:30;4651:34;4631:18;;;4624:62;-1:-1:-1;;;4702:18:7;;;4695:36;4748:19;;1919:73:5::1;4371:402:7::0;1919:73:5::1;2002:19;2012:8;2002:9;:19::i;777:809:4:-:0;898:4;937;898;952:515;976:5;:12;972:1;:16;952:515;;;1009:20;1032:5;1038:1;1032:8;;;;;;;;:::i;:::-;;;;;;;1009:31;;1075:12;1059;:28;1055:402;;1210:44;;;;;;5067:19:7;;;5102:12;;;5095:28;;;5139:12;;1210:44:4;;;;;;;;;;;;1200:55;;;;;;1185:70;;1055:402;;;1397:44;;;;;;5067:19:7;;;5102:12;;;5095:28;;;5139:12;;1397:44:4;;;;;;;;;;;;1387:55;;;;;;1372:70;;1055:402;-1:-1:-1;990:3:4;;;;:::i;:::-;;;;952:515;;;-1:-1:-1;1559:20:4;;;-1:-1:-1;777:809:4;;;;;;:::o;620:205:6:-;759:58;;;-1:-1:-1;;;;;5591:32:7;;759:58:6;;;5573:51:7;5640:18;;;;5633:34;;;759:58:6;;;;;;;;;;5546:18:7;;;;759:58:6;;;;;;;;-1:-1:-1;;;;;759:58:6;-1:-1:-1;;;759:58:6;;;732:86;;752:5;;732:19;:86::i;:::-;620:205;;;:::o;2034:169:5:-;2089:16;2108:6;;-1:-1:-1;;;;;2124:17:5;;;-1:-1:-1;;;;;;2124:17:5;;;;;;2156:40;;2108:6;;;;;;;2156:40;;2089:16;2156:40;2079:124;2034:169;:::o;3126:706:6:-;3545:23;3571:69;3599:4;3571:69;;;;;;;;;;;;;;;;;3579:5;-1:-1:-1;;;;;3571:27:6;;;:69;;;;;:::i;:::-;3654:17;;3545:95;;-1:-1:-1;3654:21:6;3650:176;;3749:10;3738:30;;;;;;;;;;;;:::i;:::-;3730:85;;;;-1:-1:-1;;;3730:85:6;;6162:2:7;3730:85:6;;;6144:21:7;6201:2;6181:18;;;6174:30;6240:34;6220:18;;;6213:62;-1:-1:-1;;;6291:18:7;;;6284:40;6341:19;;3730:85:6;5960:406:7;3461:223:0;3594:12;3625:52;3647:6;3655:4;3661:1;3664:12;3625:21;:52::i;:::-;3618:59;3461:223;-1:-1:-1;;;;3461:223:0:o;4548:499::-;4713:12;4770:5;4745:21;:30;;4737:81;;;;-1:-1:-1;;;4737:81:0;;6573:2:7;4737:81:0;;;6555:21:7;6612:2;6592:18;;;6585:30;6651:34;6631:18;;;6624:62;-1:-1:-1;;;6702:18:7;;;6695:36;6748:19;;4737:81:0;6371:402:7;4737:81:0;1034:20;;4828:60;;;;-1:-1:-1;;;4828:60:0;;6980:2:7;4828:60:0;;;6962:21:7;7019:2;6999:18;;;6992:30;7058:31;7038:18;;;7031:59;7107:18;;4828:60:0;6778:353:7;4828:60:0;4900:12;4914:23;4941:6;-1:-1:-1;;;;;4941:11:0;4960:5;4967:4;4941:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4899:73;;;;4989:51;5006:7;5015:10;5027:12;4989:16;:51::i;:::-;4982:58;4548:499;-1:-1:-1;;;;;;;4548:499:0:o;7161:692::-;7307:12;7335:7;7331:516;;;-1:-1:-1;7365:10:0;7358:17;;7331:516;7476:17;;:21;7472:365;;7670:10;7664:17;7730:15;7717:10;7713:2;7709:19;7702:44;7472:365;7809:12;7802:20;;-1:-1:-1;;;7802:20:0;;;;;;;;:::i;196:173:7:-;264:20;;-1:-1:-1;;;;;313:31:7;;303:42;;293:70;;359:1;356;349:12;293:70;196:173;;;:::o;374:757::-;478:6;486;494;502;555:2;543:9;534:7;530:23;526:32;523:52;;;571:1;568;561:12;523:52;594:29;613:9;594:29;:::i;:::-;584:39;;670:2;659:9;655:18;642:32;632:42;;725:2;714:9;710:18;697:32;748:18;789:2;781:6;778:14;775:34;;;805:1;802;795:12;775:34;843:6;832:9;828:22;818:32;;888:7;881:4;877:2;873:13;869:27;859:55;;910:1;907;900:12;859:55;950:2;937:16;976:2;968:6;965:14;962:34;;;992:1;989;982:12;962:34;1045:7;1040:2;1030:6;1027:1;1023:14;1019:2;1015:23;1011:32;1008:45;1005:65;;;1066:1;1063;1056:12;1005:65;374:757;;;;-1:-1:-1;;1097:2:7;1089:11;;-1:-1:-1;;;374:757:7:o;1136:186::-;1195:6;1248:2;1236:9;1227:7;1223:23;1219:32;1216:52;;;1264:1;1261;1254:12;1216:52;1287:29;1306:9;1287:29;:::i;3468:356::-;3670:2;3652:21;;;3689:18;;;3682:30;3748:34;3743:2;3728:18;;3721:62;3815:2;3800:18;;3468:356::o;4182:184::-;4252:6;4305:2;4293:9;4284:7;4280:23;4276:32;4273:52;;;4321:1;4318;4311:12;4273:52;-1:-1:-1;4344:16:7;;4182:184;-1:-1:-1;4182:184:7:o;4778:127::-;4839:10;4834:3;4830:20;4827:1;4820:31;4870:4;4867:1;4860:15;4894:4;4891:1;4884:15;5162:232;5201:3;-1:-1:-1;;5222:17:7;;5219:140;;;5281:10;5276:3;5272:20;5269:1;5262:31;5316:4;5313:1;5306:15;5344:4;5341:1;5334:15;5219:140;-1:-1:-1;5386:1:7;5375:13;;5162:232::o;5678:277::-;5745:6;5798:2;5786:9;5777:7;5773:23;5769:32;5766:52;;;5814:1;5811;5804:12;5766:52;5846:9;5840:16;5899:5;5892:13;5885:21;5878:5;5875:32;5865:60;;5921:1;5918;5911:12;7136:258;7208:1;7218:113;7232:6;7229:1;7226:13;7218:113;;;7308:11;;;7302:18;7289:11;;;7282:39;7254:2;7247:10;7218:113;;;7349:6;7346:1;7343:13;7340:48;;;7384:1;7375:6;7370:3;7366:16;7359:27;7340:48;;7136:258;;;:::o;7399:274::-;7528:3;7566:6;7560:13;7582:53;7628:6;7623:3;7616:4;7608:6;7604:17;7582:53;:::i;:::-;7651:16;;;;;7399:274;-1:-1:-1;;7399:274:7:o;7678:383::-;7827:2;7816:9;7809:21;7790:4;7859:6;7853:13;7902:6;7897:2;7886:9;7882:18;7875:34;7918:66;7977:6;7972:2;7961:9;7957:18;7952:2;7944:6;7940:15;7918:66;:::i;:::-;8045:2;8024:15;-1:-1:-1;;8020:29:7;8005:45;;;;8052:2;8001:54;;7678:383;-1:-1:-1;;7678:383:7:o

Swarm Source

ipfs://3c8378795d9b1f689d8652cb11486e40ae8ace4744028b41aa3a689155617f02
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.