Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.21;

import {MerkleProofLib} from "solady/src/utils/MerkleProofLib.sol";
import {Ownable} from "solady/src/auth/Ownable.sol";
import {IERC20} from "forge-std/interfaces/IERC20.sol";

contract Distribution is Ownable {
    error InvalidProof();
    error ZeroClaimable();
    error ClaimStillActive();

    bytes32 private _root;
    mapping(address => uint256) public previouslyClaimedAmount;

    uint256 private immutable _CLAIM_START;
    uint256 private immutable _VESTING_START;
    uint256 private constant _CLIFF = 60 days;
    uint256 private constant _VESTING_DURATION = 547.92 days; // ~18 months
    uint256 private constant _GRACE_PERIOD = 365 days; // 1 year

    address public constant INSPECT_TOKEN = 0x186eF81fd8E77EEC8BfFC3039e7eC41D5FC0b457;

    constructor(bytes32 root, uint256 claimStart) {
        _initializeOwner(tx.origin);
        _root = root;
        _CLAIM_START = claimStart;
        unchecked { _VESTING_START = claimStart + _CLIFF; }
    }

    function setRoot(bytes32 _newRoot) external onlyOwner {
        _root = _newRoot;
    }

    function withdrawUnclaimedTokens() external onlyOwner {
        uint256 claimExpiry;

        unchecked {
            claimExpiry = _VESTING_START + _VESTING_DURATION + _GRACE_PERIOD;
        }

        if (block.timestamp < claimExpiry) revert ClaimStillActive();

        uint256 balance = IERC20(INSPECT_TOKEN).balanceOf(address(this));
        IERC20(INSPECT_TOKEN).transfer(msg.sender, balance);
    }

    function claim(address _recipient, uint256 _totalAllocation, bytes32[] calldata _proof) external {
        bytes32 leaf = keccak256(abi.encode(_recipient, _totalAllocation));
        if (!MerkleProofLib.verifyCalldata(_proof, _root, leaf)) revert InvalidProof();

        uint256 _previouslyClaimed = previouslyClaimedAmount[_recipient];
        uint256 _claimableAmount = _totalClaimable(_totalAllocation, _previouslyClaimed);

        if (_claimableAmount == 0) revert ZeroClaimable();
        unchecked { previouslyClaimedAmount[_recipient] += _claimableAmount; }

        IERC20(INSPECT_TOKEN).transfer(_recipient, _claimableAmount);
    }

    function claimableAmount(address _recipient, uint256 _totalAllocation) external view returns (uint256) {
        uint256 _previouslyClaimed = previouslyClaimedAmount[_recipient];

        return _totalClaimable(_totalAllocation, _previouslyClaimed);
    }

    function _totalClaimable(uint256 _totalAllocation, uint256 _previouslyClaimed) internal view returns (uint256) {
        if (block.timestamp < _CLAIM_START) return 0;
        if (block.timestamp <= _VESTING_START) return _totalAllocation / 10 - _previouslyClaimed;
        if (block.timestamp > _VESTING_START + _VESTING_DURATION) return _totalAllocation - _previouslyClaimed;

        uint256 _initialClaimableAmount;
        uint256 _vestingBalance;
        uint256 _timeElapsed;

        unchecked {
            _initialClaimableAmount = _totalAllocation / 10;
            _vestingBalance = _totalAllocation - _initialClaimableAmount;
            _timeElapsed = block.timestamp - _VESTING_START;
        }

        return _initialClaimableAmount + (_timeElapsed * _vestingBalance / _VESTING_DURATION) - _previouslyClaimed;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
library MerkleProofLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            MERKLE PROOF VERIFICATION OPERATIONS            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(proof) {
                // Initialize `offset` to the offset of `proof` elements in memory.
                let offset := add(proof, 0x20)
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(offset, shl(5, mload(proof)))
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, mload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), mload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if proof.length {
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(proof.offset, shl(5, proof.length))
                // Initialize `offset` to the offset of `proof` in the calldata.
                let offset := proof.offset
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, calldataload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), calldataload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    ///
    /// Note:
    /// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`
    ///   will always return false.
    /// - The sum of the lengths of `proof` and `leaves` must never overflow.
    /// - Any non-zero word in the `flags` array is treated as true.
    /// - The memory offset of `proof` must be non-zero
    ///   (i.e. `proof` is not pointing to the scratch space).
    function verifyMultiProof(
        bytes32[] memory proof,
        bytes32 root,
        bytes32[] memory leaves,
        bool[] memory flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // Cache the lengths of the arrays.
            let leavesLength := mload(leaves)
            let proofLength := mload(proof)
            let flagsLength := mload(flags)

            // Advance the pointers of the arrays to point to the data.
            leaves := add(0x20, leaves)
            proof := add(0x20, proof)
            flags := add(0x20, flags)

            // If the number of flags is correct.
            for {} eq(add(leavesLength, proofLength), add(flagsLength, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flagsLength) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    isValid := eq(mload(xor(leaves, mul(xor(proof, leaves), proofLength))), root)
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := add(proof, shl(5, proofLength))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                leavesLength := shl(5, leavesLength)
                for { let i := 0 } iszero(eq(i, leavesLength)) { i := add(i, 0x20) } {
                    mstore(add(hashesFront, i), mload(add(leaves, i)))
                }
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, leavesLength)
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flagsLength := add(hashesBack, shl(5, flagsLength))

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(mload(flags)) {
                        // Loads the next proof.
                        b := mload(proof)
                        proof := add(proof, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag.
                    flags := add(flags, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flagsLength)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required.
                        eq(proofEnd, proof)
                    )
                break
            }
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    ///
    /// Note:
    /// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`
    ///   will always return false.
    /// - Any non-zero word in the `flags` array is treated as true.
    /// - The calldata offset of `proof` must be non-zero
    ///   (i.e. `proof` is from a regular Solidity function with a 4-byte selector).
    function verifyMultiProofCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32[] calldata leaves,
        bool[] calldata flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // If the number of flags is correct.
            for {} eq(add(leaves.length, proof.length), add(flags.length, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flags.length) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    // forgefmt: disable-next-item
                    isValid := eq(
                        calldataload(
                            xor(leaves.offset, mul(xor(proof.offset, leaves.offset), proof.length))
                        ),
                        root
                    )
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := add(proof.offset, shl(5, proof.length))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                calldatacopy(hashesFront, leaves.offset, shl(5, leaves.length))
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, shl(5, leaves.length))
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flags.length := add(hashesBack, shl(5, flags.length))

                // We don't need to make a copy of `proof.offset` or `flags.offset`,
                // as they are pass-by-value (this trick may not always save gas).

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(calldataload(flags.offset)) {
                        // Loads the next proof.
                        b := calldataload(proof.offset)
                        proof.offset := add(proof.offset, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag offset.
                    flags.offset := add(flags.offset, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flags.length)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required.
                        eq(proofEnd, proof.offset)
                    )
                break
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   EMPTY CALLDATA HELPERS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns an empty calldata bytes32 array.
    function emptyProof() internal pure returns (bytes32[] calldata proof) {
        /// @solidity memory-safe-assembly
        assembly {
            proof.length := 0
        }
    }

    /// @dev Returns an empty calldata bytes32 array.
    function emptyLeaves() internal pure returns (bytes32[] calldata leaves) {
        /// @solidity memory-safe-assembly
        assembly {
            leaves.length := 0
        }
    }

    /// @dev Returns an empty calldata bool array.
    function emptyFlags() internal pure returns (bool[] calldata flags) {
        /// @solidity memory-safe-assembly
        assembly {
            flags.length := 0
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2;

/// @dev Interface of the ERC20 standard as defined in the EIP.
/// @dev This includes the optional name, symbol, and decimals metadata.
interface IERC20 {
    /// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`).
    event Transfer(address indexed from, address indexed to, uint256 value);

    /// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value`
    /// is the new allowance.
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /// @notice Returns the amount of tokens in existence.
    function totalSupply() external view returns (uint256);

    /// @notice Returns the amount of tokens owned by `account`.
    function balanceOf(address account) external view returns (uint256);

    /// @notice Moves `amount` tokens from the caller's account to `to`.
    function transfer(address to, uint256 amount) external returns (bool);

    /// @notice Returns the remaining number of tokens that `spender` is allowed
    /// to spend on behalf of `owner`
    function allowance(address owner, address spender) external view returns (uint256);

    /// @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
    /// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    function approve(address spender, uint256 amount) external returns (bool);

    /// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism.
    /// `amount` is then deducted from the caller's allowance.
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    /// @notice Returns the name of the token.
    function name() external view returns (string memory);

    /// @notice Returns the symbol of the token.
    function symbol() external view returns (string memory);

    /// @notice Returns the decimals places of the token.
    function decimals() external view returns (uint8);
}

{
  "remappings": [
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "solady/=lib/solady/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint256","name":"claimStart","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ClaimStillActive","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"ZeroClaimable","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"INSPECT_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_totalAllocation","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_totalAllocation","type":"uint256"}],"name":"claimableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"previouslyClaimedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_newRoot","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawUnclaimedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

8f14404d41c6f1539d9d4fa05f1ced65691064736378a56944eab6c7897eb0280000000000000000000000000000000000000000000000000000000065704878

-----Decoded View---------------
Arg [0] : root (bytes32): 0x8f14404d41c6f1539d9d4fa05f1ced65691064736378a56944eab6c7897eb028
Arg [1] : claimStart (uint256): 1701857400

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 8f14404d41c6f1539d9d4fa05f1ced65691064736378a56944eab6c7897eb028
Arg [1] : 0000000000000000000000000000000000000000000000000000000065704878

242:3044:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9021:617:1;;;:::i;:::-;;1543:643:3;;;;;;;;;;-1:-1:-1;1543:643:3;;;;;:::i;:::-;;:::i;1131:406::-;;;;;;;;;;;;;:::i;9720:456:1:-;;;:::i;8762:100::-;;;:::i;2192:255:3:-;;;;;;;;;;-1:-1:-1;2192:255:3;;;;;:::i;:::-;;:::i;:::-;;;1359:25:4;;;1347:2;1332:18;2192:255:3;;;;;;;;11408:182:1;;;;;;;;;;-1:-1:-1;;;11556:18:1;11408:182;;;-1:-1:-1;;;;;1559:32:4;;;1541:51;;1529:2;1514:18;11408:182:1;1395:203:4;392:58:3;;;;;;;;;;-1:-1:-1;392:58:3;;;;;:::i;:::-;;;;;;;;;;;;;;1038:87;;;;;;;;;;-1:-1:-1;1038:87:3;;;;;:::i;:::-;;:::i;736:82::-;;;;;;;;;;;;776:42;736:82;;10363:708:1;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:1;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;9021:617;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;1543:643:3:-;1675:40;;;-1:-1:-1;;;;;2171:32:4;;1675:40:3;;;2153:51:4;2220:18;;;2213:34;;;1650:12:3;;2126:18:4;;1675:40:3;;;;;;;;;;;;1665:51;;;;;;1650:66;;1731:50;1761:6;;1769:5;;1776:4;1731:29;:50::i;:::-;1726:78;;1790:14;;-1:-1:-1;;;1790:14:3;;;;;;;;;;;1726:78;-1:-1:-1;;;;;1844:35:3;;1815:26;1844:35;;;:23;:35;;;;;;;1916:53;1932:16;1844:35;1916:15;:53::i;:::-;1889:80;;1984:16;2004:1;1984:21;1980:49;;2014:15;;-1:-1:-1;;;2014:15:3;;;;;;;;;;;1980:49;-1:-1:-1;;;;;2051:35:3;;;;;;:23;:35;;;;;;;:55;;;;;;2119:60;-1:-1:-1;;;2119:60:3;;;;;2153:51:4;;;;2220:18;;;2213:34;;;776:42:3;;2119:30;;2126:18:4;;2119:60:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1640:546;;;1543:643;;;;:::o;1131:406::-;12517:13:1;:11;:13::i;:::-;1263:50:3;:14:::1;:50:::0;1338:15:::1;:29:::0;-1:-1:-1;1334:60:3::1;;;1376:18;;-1:-1:-1::0;;;1376:18:3::1;;;;;;;;;;;1334:60;1423:46;::::0;-1:-1:-1;;;1423:46:3;;1463:4:::1;1423:46;::::0;::::1;1541:51:4::0;1405:15:3::1;::::0;776:42:::1;::::0;1423:31:::1;::::0;1514:18:4;;1423:46:3::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1479:51;::::0;-1:-1:-1;;;1479:51:3;;1510:10:::1;1479:51;::::0;::::1;2153::4::0;2220:18;;;2213:34;;;1405:64:3;;-1:-1:-1;776:42:3::1;::::0;1479:30:::1;::::0;2126:18:4;;1479:51:3::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1185:352;;1131:406::o:0;9720:456:1:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;8762:100::-;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;2192:255:3:-;-1:-1:-1;;;;;2334:35:3;;2286:7;2334:35;;;:23;:35;;;;;;2387:53;2403:16;2334:35;2387:15;:53::i;:::-;2380:60;;;2192:255;;;;;:::o;1038:87::-;12517:13:1;:11;:13::i;:::-;1102:5:3::1;:16:::0;1038:87::o;10363:708:1:-;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;:::-;10363:708:::0;:::o;8348:349::-;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;2397:1407:2:-:0;2522:12;2619;2616:1134;;;2759:12;2756:1;2752:20;2738:12;2734:39;2885:12;2983:753;3176:20;;3167:30;;;3164:1;3160:38;3391:21;;;3453:4;3440:18;;;3433:48;3608:4;3602;3592:21;;3644:17;3692:15;;;2983:753;3682:36;2987:2;;2616:1134;-1:-1:-1;3774:14:2;;2397:1407;-1:-1:-1;;2397:1407:2:o;2453:831:3:-;2555:7;2596:12;2578:15;:30;2574:44;;;-1:-1:-1;2617:1:3;2610:8;;2574:44;2651:14;2632:15;:33;2628:88;;2698:18;2674:21;2693:2;2674:16;:21;:::i;:::-;:42;;;;:::i;:::-;2667:49;;;;2628:88;2748:34;639:11;2748:14;:34;:::i;:::-;2730:15;:52;2726:102;;;2791:37;2810:18;2791:16;:37;:::i;2726:102::-;3013:2;2994:21;;3047:42;;;3136:14;3118:15;:32;3259:18;639:11;3205:30;3047:42;3118:32;3205:30;:::i;:::-;:50;;;;:::i;:::-;3178:78;;:23;:78;:::i;:::-;:99;;;;:::i;:::-;3171:106;2453:831;-1:-1:-1;;;;;;2453:831:3:o;7292:355:1:-;-1:-1:-1;;7498:18:1;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;6145:1089;-1:-1:-1;;7093:16:1;;-1:-1:-1;;;;;6941:26:1;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;14:173:4:-;82:20;;-1:-1:-1;;;;;131:31:4;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:757::-;296:6;304;312;320;373:2;361:9;352:7;348:23;344:32;341:52;;;389:1;386;379:12;341:52;412:29;431:9;412:29;:::i;:::-;402:39;;488:2;477:9;473:18;460:32;450:42;;543:2;532:9;528:18;515:32;566:18;607:2;599:6;596:14;593:34;;;623:1;620;613:12;593:34;661:6;650:9;646:22;636:32;;706:7;699:4;695:2;691:13;687:27;677:55;;728:1;725;718:12;677:55;768:2;755:16;794:2;786:6;783:14;780:34;;;810:1;807;800:12;780:34;863:7;858:2;848:6;845:1;841:14;837:2;833:23;829:32;826:45;823:65;;;884:1;881;874:12;823:65;192:757;;;;-1:-1:-1;;915:2:4;907:11;;-1:-1:-1;;;192:757:4:o;954:254::-;1022:6;1030;1083:2;1071:9;1062:7;1058:23;1054:32;1051:52;;;1099:1;1096;1089:12;1051:52;1122:29;1141:9;1122:29;:::i;:::-;1112:39;1198:2;1183:18;;;;1170:32;;-1:-1:-1;;;954:254:4:o;1603:186::-;1662:6;1715:2;1703:9;1694:7;1690:23;1686:32;1683:52;;;1731:1;1728;1721:12;1683:52;1754:29;1773:9;1754:29;:::i;:::-;1744:39;1603:186;-1:-1:-1;;;1603:186:4:o;1794:180::-;1853:6;1906:2;1894:9;1885:7;1881:23;1877:32;1874:52;;;1922:1;1919;1912:12;1874:52;-1:-1:-1;1945:23:4;;1794:180;-1:-1:-1;1794:180:4:o;2258:277::-;2325:6;2378:2;2366:9;2357:7;2353:23;2349:32;2346:52;;;2394:1;2391;2384:12;2346:52;2426:9;2420:16;2479:5;2472:13;2465:21;2458:5;2455:32;2445:60;;2501:1;2498;2491:12;2540:184;2610:6;2663:2;2651:9;2642:7;2638:23;2634:32;2631:52;;;2679:1;2676;2669:12;2631:52;-1:-1:-1;2702:16:4;;2540:184;-1:-1:-1;2540:184:4:o;2861:127::-;2922:10;2917:3;2913:20;2910:1;2903:31;2953:4;2950:1;2943:15;2977:4;2974:1;2967:15;2993:217;3033:1;3059;3049:132;;3103:10;3098:3;3094:20;3091:1;3084:31;3138:4;3135:1;3128:15;3166:4;3163:1;3156:15;3049:132;-1:-1:-1;3195:9:4;;2993:217::o;3215:128::-;3282:9;;;3303:11;;;3300:37;;;3317:18;;:::i;3348:125::-;3413:9;;;3434:10;;;3431:36;;;3447:18;;:::i;3478:168::-;3551:9;;;3582;;3599:15;;;3593:22;;3579:37;3569:71;;3620:18;;:::i

ipfs://09df813b107478932960553ca2d669819a6c90bd99fd3694ca563cb9104f9258