Contract 0xf233963521b8e0f581f0e75bba237598c12bc14f

Contract Overview

Balance:
0 AVAX

AVAX Value:
$0.00

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x6f9786a5f1a5219ac8fbd512939858c0968c5259ceaaa51fe92b456032905eecClaim141734132022-05-02 10:25:09281 days 10 hrs ago0xc4db5d900ab1dc0054f845c73cbbe4c1327d826f IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.006432487394 68.202890288
0xec4c2ada011aed9f770dd7fe38c6bc1997d4b9a2ca3ad84e3b2c01c95256c904Claim141721662022-05-02 9:42:48281 days 11 hrs ago0xa2c1ec02bb253474bdd441cce6ab2146a62cf063 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.004829172216 51.185765341
0xbd9b2da2a17b3f5296d4a4981c5bd70cc2ab83fa8a4703fe3a009ff9f91a87c0Claim141352982022-05-01 12:43:35282 days 8 hrs ago0xc7b01fc36164e53a67560b68929d1277e6a3b3f4 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.00470218997 50.837783751
0x01cf2a7c56e7056461d89b5d9d760968e4a5324919f48b322375a8e84a34a497Claim140888772022-04-30 10:11:41283 days 10 hrs ago0x1f2b92fe1928e820aa100dba1a63dd37decd08f1 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.002629979866 27.882995132
0x046c77157217a8e5bf284e59f3c16ff8bcaed1a227eff456c5d4b3aa786b4601Claim140240412022-04-28 21:00:24285 days 8 mins ago0x93c4c1e86434ea4e831d8a13e64ac288c49b7b76 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.003095011076 40.091855706
0xe0af26c75aec7e74661a3214219e9fd3c5b6e00c1107419cdc11e698dc068bb6Claim140233412022-04-28 20:36:22285 days 32 mins ago0xcc8703e26550862e0dfcb9adb27ed7a62cd7162d IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.004216229834 44.732635586
0x81d0c33105c12d689624265ccec7b3cd8b102ffe8e31f73135c11cf3049fbad1Claim140210882022-04-28 19:18:43285 days 1 hr ago0x2ee69384d2f50e4c4bfb4172bdc78c64288d0058 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.002959948387 38.334348528
0x66e0c05f7427e825829ad030f8cb249da311a626482559f8e3da4eec530fec6cClaim139976252022-04-28 6:00:13285 days 15 hrs ago0x1171114ded1ce0f57637c2cc31acf6fec8e948ae IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.003710581405 48.03963497
0xb809ca34e5a935c85d121e83df35f0c4abad2f398350e8550226dcae11abf9e4Claim139923352022-04-28 3:01:10285 days 18 hrs ago0x4c99cf1c903d4d47983eea61fbc720890bc7bc04 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.004087376486 43.761592345
0x703677ea53fe98067491cc91cdc8a9027a5a08f29be7c4a276214eb2093995b0Claim139696172022-04-27 14:12:27286 days 6 hrs ago0xe3b573f2308d25f3382fcb184b715a1d95a4cb91 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.009126759313 96.786350861
0xe6805e691a9fe68a5b94711ad1e53ffff3dc5af73cb88a5ad3e90018283951e1Claim139627552022-04-27 10:22:19286 days 10 hrs ago0xfb4334a5704e29df37efc9f16255759670018d9a IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.006289567469 66.679043631
0x44fcab0c70d49a97c45d947cf9aa1e19394ecce3122ea158edd9892353e7b503Claim139540162022-04-27 5:28:50286 days 15 hrs ago0xec113c0cd9a534e43c60eb930822f0c592b5e401 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.004897122728 63.422730701
0xb799c71ae799cefe4c6e72a58c694591290fbd074f3f79d96027e56f0fb06ef0Claim138824892022-04-25 13:33:41288 days 7 hrs ago0x8b000f9910565a4561d75795d5280280e0ecaa30 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.00774053506582.065001433
0xbd155839049b74909a54f9428d5f013597b60ec9d6eebe98a221c9d1b6891233Claim138320052022-04-24 9:17:50289 days 11 hrs ago0x8fd641ed1fc00781cd0cd6d582c68316067b158d IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.004568282395 59.196112524
0xa83cdcc7367d0381d6c81cc01f7619ba1f56608940cd35f9d5c65fa05ae851eeClaim138309862022-04-24 8:43:42289 days 12 hrs ago0xe12a20eaf5b10ebce026e67ce48610eebd0f2ac2 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.005801047394 61.501286993
0xda99bb66ee76ebc3aec2dcdd82db137033664d978ce1edd31a26a457a5e6398aClaim137667632022-04-22 20:48:52291 days 19 mins ago0x1b099c50d898c79fe9a654bfb621c532449029e8 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.006852366203 88.758920793
0x617d1d84d6d396b33494de58c9489bfe76348b570860a9a8b1791f6799627598Claim137469532022-04-22 9:42:54291 days 11 hrs ago0x78f5f654dbf5a638967ed922f8ee3c4dd272dec1 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.00332118428135.21038422
0x9040153e3428b26e6bcac6b841f0d969ec581ca7782a2cd706521e1dc084bfb6Claim137408862022-04-22 6:19:08291 days 14 hrs ago0x314a14ce45f4e14caacff03f17160b065b4ca7d4 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.006980715465 73.992150695
0xcf5935e5ed544c0eaed021861ea59f320b20f33c4e77c21f0e5b0b1e47c26f98Claim137127212022-04-21 14:29:51292 days 6 hrs ago0x9bb682e843f0af37dea873c60db9549545dc5741 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.006151991971 79.653934433
0xd478bc4c1bac03b5cda617a092eba74e4aa433145a66ce6c5ba15b1cb1c7d9b3Claim137087842022-04-21 12:17:39292 days 8 hrs ago0xac6f0e341fbdf43db17c7d670bf80e074d1a0efa IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.007431726204 79.525379123
0x545d66dc0e0ea0196d4dff1530a70b29b4fef99b9189b7b3ddd9a337d94e0ad6Claim136833532022-04-20 22:02:30292 days 23 hrs ago0x2eca0bbd9ea9ea5998c9803f5d56ac0088462b65 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.007352626516 78.761545063
0x8e59a810381c8ab8d6a29379c520b955dcee286b2a2adbb7f499aa32d89b4a3cClaim136444532022-04-20 0:18:57293 days 20 hrs ago0x4b79a7d682ad34d76509c35de32d34f9aec4a3ec IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.007582089069 80.356194304
0x5eab40d367af3c864e996b6d4337e0beb2e154bd26138fdd379399c58462a9f4Claim136306642022-04-19 16:35:58294 days 4 hrs ago0x963283c301520a6904bdf4f259915a9954ba8fc1 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.007290680834 94.414411215
0x166be23c76f78a69290a14e87da930f54b5806c50b70267bdabb4e846b0d37b4Claim136278482022-04-19 15:01:15294 days 6 hrs ago0x6eaf6f5ccdf20a7a8147daaccc9054ef7c421f00 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.008745866922 113.285496784
0xb02a1277136aceec59baf38437db4b3746fa40da6b4a78dd38fd585cad98418aClaim136249182022-04-19 13:22:38294 days 7 hrs ago0xb424ea10bb2b644c611d5f4c0a0540ac776cbf97 IN  0xf233963521b8e0f581f0e75bba237598c12bc14f0 AVAX0.007654952379 81.957927425
[ 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)

9aea001f426d4c7376b9a5c4aa91b437fa1aa68b74f780dba28e37b4cd12fbd900000000000000000000000022d4002028f537599be9f666d1c4fa138522f9c80000000000000000000000000000000000000000000000000000000061e173d00000000000000000000000000000000000000000000000000000000000015180

-----Decoded View---------------
Arg [0] : _merkleRoot (bytes32): 0x9aea001f426d4c7376b9a5c4aa91b437fa1aa68b74f780dba28e37b4cd12fbd9
Arg [1] : _tokenAddress (address): 0x22d4002028f537599be9f666d1c4fa138522f9c8
Arg [2] : _startTimestamp (uint256): 1642165200
Arg [3] : _rescueDelay (uint256): 86400

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 9aea001f426d4c7376b9a5c4aa91b437fa1aa68b74f780dba28e37b4cd12fbd9
Arg [1] : 00000000000000000000000022d4002028f537599be9f666d1c4fa138522f9c8
Arg [2] : 0000000000000000000000000000000000000000000000000000000061e173d0
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.