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: MIT
pragma solidity ^0.8.18;

import {IERC20} from "@openzeppelin5/contracts/token/ERC20/IERC20.sol";
import {IERC20Permit} from "@openzeppelin5/contracts/token/ERC20/extensions/IERC20Permit.sol";
import {Context} from "@openzeppelin5/contracts/utils/Context.sol";
import {IDelegationRegistry} from "contracts/utils/delegation_registry/IDelegationRegistry.sol";
import {IDelegateRegistry} from "contracts/utils/delegation_registry/IDelegateRegistry.sol";
import {ClaimType, NFTCollectionClaimRequest} from "./lib/Structs.sol";

import {MemecoinDelegatable} from "../delegate/MemecoinDelegatable.sol";

error NoClaimableToken();
error InvalidDelegate();

interface IMemecoinClaim {
    function claimFromMulti(address _requester, ClaimType[] calldata _claimTypes) external;
    function claimInNFTsFromMulti(
        address _requester,
        NFTCollectionClaimRequest[] calldata _nftCollectionClaimRequests,
        bool _withWalletRewards
    ) external;
}

interface IStakeland {
    function stakeFor(address from, uint256 amount, bytes calldata permit) external;
}

contract MemecoinMultiClaim is Context, MemecoinDelegatable {
    event ClaimedToStakeland(address indexed user, uint256 amount, uint256 claimedAt);

    IMemecoinClaim public immutable presaleClaim;
    IMemecoinClaim public immutable airdropClaim;
    IDelegationRegistry public immutable dc;
    IDelegateRegistry public immutable dcV2;
    IERC20 public immutable memecoin;
    IStakeland public immutable stakeland;

    constructor(address _presaleClaim, address _airdropClaim, address _memecoin, address _delegate, address _stakeland)
        MemecoinDelegatable(_delegate)
    {
        presaleClaim = IMemecoinClaim(_presaleClaim);
        airdropClaim = IMemecoinClaim(_airdropClaim);
        dc = IDelegationRegistry(0x00000000000076A84feF008CDAbe6409d2FE638B);
        dcV2 = IDelegateRegistry(0x00000000000000447e69651d841bD8D104Bed493);
        memecoin = IERC20(_memecoin);
        if (!memecoin.approve(_delegate, type(uint256).max)) revert("Memecoin: approve failed");
        stakeland = IStakeland(_stakeland);
    }

    /// @notice Cross contract claim on Presale, OPTIONALLY ON NFTAirdrop/NFTRewards/WalletRewards
    /// @param _vault Vault address of delegate.xyz; pass address(0) if not using delegate wallet
    /// @param _claimTypes Array of ClaimType to claim
    /// @param _nftCollectionClaimRequests Array of NFTCollectionClaimRequest that consists collection ID of the NFT, token ID(s) the owner owns, array of booleans to indicate NFTAirdrop/NFTRewards claim for each token ID
    /// @param _withWalletRewards Boolean to dictate if claimer will claim WalletRewards as well
    function multiClaim(
        address _vault,
        ClaimType[] calldata _claimTypes,
        NFTCollectionClaimRequest[] calldata _nftCollectionClaimRequests,
        bool _withWalletRewards
    ) external {
        address requester = _getRequester(_vault);
        presaleClaim.claimFromMulti(requester, _claimTypes);
        airdropClaim.claimInNFTsFromMulti(requester, _nftCollectionClaimRequests, _withWalletRewards);
    }

    /// @dev Support both v1 and v2 delegate wallet during the v1 to v2 migration
    /// @dev Given _vault (cold wallet) address, verify whether _msgSender() is a permitted delegate to operate on behalf of it
    /// @param _vault Address to verify against _msgSender
    function _getRequester(address _vault) private view returns (address) {
        if (_vault == address(0)) return _msgSender();
        bool isDelegateValid = dcV2.checkDelegateForAll(_msgSender(), _vault, "");
        if (isDelegateValid) return _vault;
        isDelegateValid = dc.checkDelegateForAll(_msgSender(), _vault);
        if (!isDelegateValid) revert InvalidDelegate();
        return _vault;
    }

    /// @notice Cross contract claim to Stakeland
    /// @param _amount Amount to claim to Stakeland
    /// @param _presaleClaims Array of ClaimType to claim
    /// @param _airdropClaims Array of NFTCollectionClaimRequest that consists collection ID of the NFT, token ID(s) the owner owns, array of booleans to indicate NFTAirdrop/NFTRewards claim for each token ID
    /// @param _permit Encoded permit data
    function multiClaimToStakeland(
        uint256 _amount,
        ClaimType[] calldata _presaleClaims,
        NFTCollectionClaimRequest[] calldata _airdropClaims,
        bytes calldata _permit
    ) external {
        address user = _msgSender();
        uint256 balance = memecoin.balanceOf(user);

        if (_presaleClaims.length != 0) presaleClaim.claimFromMulti(user, _presaleClaims);
        if (_airdropClaims.length != 0) airdropClaim.claimInNFTsFromMulti(user, _airdropClaims, false);

        uint256 claimAmount = memecoin.balanceOf(user) - balance;
        if (claimAmount == 0) revert NoClaimableToken();

        if (_permit.length != 0) _delegatePermit(_permit);
        if (claimAmount > _amount) claimAmount = _amount;
        _delegateTransfer(address(this), claimAmount);

        stakeland.stakeFor(user, claimAmount, "");

        emit ClaimedToStakeland(user, claimAmount, block.timestamp);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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

enum ClaimType {
    WalletRewards,
    CommunityPresale,
    PrivatePresale,
    Ecosystem,
    Contributors
}

struct ClaimData {
    uint128 totalClaimable;
    uint128 claimed;
}

struct NFTClaimData {
    uint128 airdropTotalClaimable;
    uint128 rewardsTotalClaimable;
    uint128 airdropClaimed;
    uint128 rewardsClaimed;
}

struct ClaimSchedule {
    uint256 startCycle;
    uint256[] lockUpBPs;
}

struct NFTClaimable {
    uint256 collectionId;
    uint256 tokenId;
    uint128 airdropTotalClaimable;
    uint128 rewardsTotalClaimable;
}

struct NFTCollectionInfo {
    uint256 collectionId;
    uint256[] tokenIds;
}

struct NFTCollectionClaimRequest {
    uint256 collectionId;
    uint256[] tokenIds;
    bool[] withNFTAirdropList;
    bool[] withNFTRewardsList;
}

struct CollectionClaimData {
    uint256 collectionId;
    uint256 tokenId;
    uint128 airdropClaimable;
    uint256 airdropClaimableExpiry;
    uint128 airdropTotalClaimable;
    uint128 airdropClaimed;
    uint128 rewardsClaimable;
    uint256 rewardsClaimableExpiry;
    uint128 rewardsTotalClaimable;
    uint128 rewardsClaimed;
}

struct UnclaimedNFTRewards {
    uint128 lastTokenId;
    uint128 totalUnclaimed;
}

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

interface IMemecoinDelegate {
    function memecoin() external view returns (address);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function allowance(address user) external view returns (uint256);
    function isAuthorized(address addr) external view returns (bool);
}

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

import {IERC20} from "@openzeppelin5/contracts/token/ERC20/IERC20.sol";
import {IERC20Permit} from "@openzeppelin5/contracts/token/ERC20/extensions/IERC20Permit.sol";
import {Context} from "@openzeppelin5/contracts/utils/Context.sol";

import {IMemecoinDelegate} from "./interfaces/IMemecoinDelegate.sol";

abstract contract MemecoinDelegatable is Context {
    error NotDelegatable();

    IMemecoinDelegate private _delegate;

    constructor(address delegate_) {
        _delegate = IMemecoinDelegate(delegate_);
    }

    function delegate() external view returns (address) {
        return address(_delegate);
    }

    function _delegateTransfer(address to, uint256 amount) internal returns (bool) {
        return _delegate.transferFrom(_msgSender(), to, amount);
    }

    function _delegatePermit(bytes calldata _permit) internal {
        (uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) =
            abi.decode(_permit, (uint256, uint256, uint8, bytes32, bytes32));
        try IERC20Permit(_delegate.memecoin()).permit(_msgSender(), address(_delegate), value, deadline, v, r, s) {}
            catch {}
    }

    modifier onlyDelegatable() {
        if (!_delegate.isAuthorized(_msgSender())) revert NotDelegatable();
        _;
    }
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity >=0.8.13;

/**
 * @title IDelegateRegistry
 * @custom:version 2.0
 * @custom:author foobar (0xfoobar)
 * @notice A standalone immutable registry storing delegated permissions from one address to another
 */
interface IDelegateRegistry {
    /// @notice Delegation type, NONE is used when a delegation does not exist or is revoked
    enum DelegationType {
        NONE,
        ALL,
        CONTRACT,
        ERC721,
        ERC20,
        ERC1155
    }

    /// @notice Struct for returning delegations
    struct Delegation {
        DelegationType type_;
        address to;
        address from;
        bytes32 rights;
        address contract_;
        uint256 tokenId;
        uint256 amount;
    }

    /// @notice Emitted when an address delegates or revokes rights for their entire wallet
    event DelegateAll(address indexed from, address indexed to, bytes32 rights, bool enable);

    /// @notice Emitted when an address delegates or revokes rights for a contract address
    event DelegateContract(
        address indexed from, address indexed to, address indexed contract_, bytes32 rights, bool enable
    );

    /// @notice Emitted when an address delegates or revokes rights for an ERC721 tokenId
    event DelegateERC721(
        address indexed from,
        address indexed to,
        address indexed contract_,
        uint256 tokenId,
        bytes32 rights,
        bool enable
    );

    /// @notice Emitted when an address delegates or revokes rights for an amount of ERC20 tokens
    event DelegateERC20(
        address indexed from, address indexed to, address indexed contract_, bytes32 rights, uint256 amount
    );

    /// @notice Emitted when an address delegates or revokes rights for an amount of an ERC1155 tokenId
    event DelegateERC1155(
        address indexed from,
        address indexed to,
        address indexed contract_,
        uint256 tokenId,
        bytes32 rights,
        uint256 amount
    );

    /// @notice Thrown if multicall calldata is malformed
    error MulticallFailed();

    /**
     * -----------  WRITE -----------
     */

    /**
     * @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
     * @param data The encoded function data for each of the calls to make to this contract
     * @return results The results from each of the calls passed in via data
     */
    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for all contracts
     * @param to The address to act as delegate
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateAll(address to, bytes32 rights, bool enable) external payable returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific contract
     * @param to The address to act as delegate
     * @param contract_ The contract whose rights are being delegated
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateContract(address to, address contract_, bytes32 rights, bool enable)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific ERC721 token
     * @param to The address to act as delegate
     * @param contract_ The contract whose rights are being delegated
     * @param tokenId The token id to delegate
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateERC721(address to, address contract_, uint256 tokenId, bytes32 rights, bool enable)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific amount of ERC20 tokens
     * @dev The actual amount is not encoded in the hash, just the existence of a amount (since it is an upper bound)
     * @param to The address to act as delegate
     * @param contract_ The address for the fungible token contract
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param amount The amount to delegate, > 0 delegates and 0 revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateERC20(address to, address contract_, bytes32 rights, uint256 amount)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific amount of ERC1155 tokens
     * @dev The actual amount is not encoded in the hash, just the existence of a amount (since it is an upper bound)
     * @param to The address to act as delegate
     * @param contract_ The address of the contract that holds the token
     * @param tokenId The token id to delegate
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param amount The amount of that token id to delegate, > 0 delegates and 0 revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateERC1155(address to, address contract_, uint256 tokenId, bytes32 rights, uint256 amount)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * ----------- CHECKS -----------
     */

    /**
     * @notice Check if `to` is a delegate of `from` for the entire wallet
     * @param to The potential delegate address
     * @param from The potential address who delegated rights
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return valid Whether delegate is granted to act on the from's behalf
     */
    function checkDelegateForAll(address to, address from, bytes32 rights) external view returns (bool);

    /**
     * @notice Check if `to` is a delegate of `from` for the specified `contract_` or the entire wallet
     * @param to The delegated address to check
     * @param contract_ The specific contract address being checked
     * @param from The cold wallet who issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return valid Whether delegate is granted to act on from's behalf for entire wallet or that specific contract
     */
    function checkDelegateForContract(address to, address from, address contract_, bytes32 rights)
        external
        view
        returns (bool);

    /**
     * @notice Check if `to` is a delegate of `from` for the specific `contract` and `tokenId`, the entire `contract_`, or the entire wallet
     * @param to The delegated address to check
     * @param contract_ The specific contract address being checked
     * @param tokenId The token id for the token to delegating
     * @param from The wallet that issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return valid Whether delegate is granted to act on from's behalf for entire wallet, that contract, or that specific tokenId
     */
    function checkDelegateForERC721(address to, address from, address contract_, uint256 tokenId, bytes32 rights)
        external
        view
        returns (bool);

    /**
     * @notice Returns the amount of ERC20 tokens the delegate is granted rights to act on the behalf of
     * @param to The delegated address to check
     * @param contract_ The address of the token contract
     * @param from The cold wallet who issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return balance The delegated balance, which will be 0 if the delegation does not exist
     */
    function checkDelegateForERC20(address to, address from, address contract_, bytes32 rights)
        external
        view
        returns (uint256);

    /**
     * @notice Returns the amount of a ERC1155 tokens the delegate is granted rights to act on the behalf of
     * @param to The delegated address to check
     * @param contract_ The address of the token contract
     * @param tokenId The token id to check the delegated amount of
     * @param from The cold wallet who issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return balance The delegated balance, which will be 0 if the delegation does not exist
     */
    function checkDelegateForERC1155(address to, address from, address contract_, uint256 tokenId, bytes32 rights)
        external
        view
        returns (uint256);

    /**
     * ----------- ENUMERATIONS -----------
     */

    /**
     * @notice Returns all enabled delegations a given delegate has received
     * @param to The address to retrieve delegations for
     * @return delegations Array of Delegation structs
     */
    function getIncomingDelegations(address to) external view returns (Delegation[] memory delegations);

    /**
     * @notice Returns all enabled delegations an address has given out
     * @param from The address to retrieve delegations for
     * @return delegations Array of Delegation structs
     */
    function getOutgoingDelegations(address from) external view returns (Delegation[] memory delegations);

    /**
     * @notice Returns all hashes associated with enabled delegations an address has received
     * @param to The address to retrieve incoming delegation hashes for
     * @return delegationHashes Array of delegation hashes
     */
    function getIncomingDelegationHashes(address to) external view returns (bytes32[] memory delegationHashes);

    /**
     * @notice Returns all hashes associated with enabled delegations an address has given out
     * @param from The address to retrieve outgoing delegation hashes for
     * @return delegationHashes Array of delegation hashes
     */
    function getOutgoingDelegationHashes(address from) external view returns (bytes32[] memory delegationHashes);

    /**
     * @notice Returns the delegations for a given array of delegation hashes
     * @param delegationHashes is an array of hashes that correspond to delegations
     * @return delegations Array of Delegation structs, return empty structs for nonexistent or revoked delegations
     */
    function getDelegationsFromHashes(bytes32[] calldata delegationHashes)
        external
        view
        returns (Delegation[] memory delegations);

    /**
     * ----------- STORAGE ACCESS -----------
     */

    /**
     * @notice Allows external contracts to read arbitrary storage slots
     */
    function readSlot(bytes32 location) external view returns (bytes32);

    /**
     * @notice Allows external contracts to read an arbitrary array of storage slots
     */
    function readSlots(bytes32[] calldata locations) external view returns (bytes32[] memory);
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.17;

/**
 * @title An immutable registry contract to be deployed as a standalone primitive
 * @dev See EIP-5639, new project launches can read previous cold wallet -> hot wallet delegations
 * from here and integrate those permissions into their flow
 */
interface IDelegationRegistry {
    /// @notice Delegation type
    enum DelegationType {
        NONE,
        ALL,
        CONTRACT,
        TOKEN
    }

    /// @notice Info about a single delegation, used for onchain enumeration
    struct DelegationInfo {
        DelegationType type_;
        address vault;
        address delegate;
        address contract_;
        uint256 tokenId;
    }

    /// @notice Info about a single contract-level delegation
    struct ContractDelegation {
        address contract_;
        address delegate;
    }

    /// @notice Info about a single token-level delegation
    struct TokenDelegation {
        address contract_;
        uint256 tokenId;
        address delegate;
    }

    /// @notice Emitted when a user delegates their entire wallet
    event DelegateForAll(address vault, address delegate, bool value);

    /// @notice Emitted when a user delegates a specific contract
    event DelegateForContract(address vault, address delegate, address contract_, bool value);

    /// @notice Emitted when a user delegates a specific token
    event DelegateForToken(address vault, address delegate, address contract_, uint256 tokenId, bool value);

    /// @notice Emitted when a user revokes all delegations
    event RevokeAllDelegates(address vault);

    /// @notice Emitted when a user revoes all delegations for a given delegate
    event RevokeDelegate(address vault, address delegate);

    /**
     * -----------  WRITE -----------
     */

    /**
     * @notice Allow the delegate to act on your behalf for all contracts
     * @param delegate The hotwallet to act on your behalf
     * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking
     */
    function delegateForAll(address delegate, bool value) external;

    /**
     * @notice Allow the delegate to act on your behalf for a specific contract
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking
     */
    function delegateForContract(address delegate, address contract_, bool value) external;

    /**
     * @notice Allow the delegate to act on your behalf for a specific token
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param tokenId The token id for the token you're delegating
     * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking
     */
    function delegateForToken(address delegate, address contract_, uint256 tokenId, bool value) external;

    /**
     * @notice Revoke all delegates
     */
    function revokeAllDelegates() external;

    /**
     * @notice Revoke a specific delegate for all their permissions
     * @param delegate The hotwallet to revoke
     */
    function revokeDelegate(address delegate) external;

    /**
     * @notice Remove yourself as a delegate for a specific vault
     * @param vault The vault which delegated to the msg.sender, and should be removed
     */
    function revokeSelf(address vault) external;

    /**
     * -----------  READ -----------
     */

    /**
     * @notice Returns all active delegations a given delegate is able to claim on behalf of
     * @param delegate The delegate that you would like to retrieve delegations for
     * @return info Array of DelegationInfo structs
     */
    function getDelegationsByDelegate(address delegate) external view returns (DelegationInfo[] memory);

    /**
     * @notice Returns an array of wallet-level delegates for a given vault
     * @param vault The cold wallet who issued the delegation
     * @return addresses Array of wallet-level delegates for a given vault
     */
    function getDelegatesForAll(address vault) external view returns (address[] memory);

    /**
     * @notice Returns an array of contract-level delegates for a given vault and contract
     * @param vault The cold wallet who issued the delegation
     * @param contract_ The address for the contract you're delegating
     * @return addresses Array of contract-level delegates for a given vault and contract
     */
    function getDelegatesForContract(address vault, address contract_) external view returns (address[] memory);

    /**
     * @notice Returns an array of contract-level delegates for a given vault's token
     * @param vault The cold wallet who issued the delegation
     * @param contract_ The address for the contract holding the token
     * @param tokenId The token id for the token you're delegating
     * @return addresses Array of contract-level delegates for a given vault's token
     */
    function getDelegatesForToken(address vault, address contract_, uint256 tokenId)
        external
        view
        returns (address[] memory);

    /**
     * @notice Returns all contract-level delegations for a given vault
     * @param vault The cold wallet who issued the delegations
     * @return delegations Array of ContractDelegation structs
     */
    function getContractLevelDelegations(address vault)
        external
        view
        returns (ContractDelegation[] memory delegations);

    /**
     * @notice Returns all token-level delegations for a given vault
     * @param vault The cold wallet who issued the delegations
     * @return delegations Array of TokenDelegation structs
     */
    function getTokenLevelDelegations(address vault) external view returns (TokenDelegation[] memory delegations);

    /**
     * @notice Returns true if the address is delegated to act on the entire vault
     * @param delegate The hotwallet to act on your behalf
     * @param vault The cold wallet who issued the delegation
     */
    function checkDelegateForAll(address delegate, address vault) external view returns (bool);

    /**
     * @notice Returns true if the address is delegated to act on your behalf for a token contract or an entire vault
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param vault The cold wallet who issued the delegation
     */
    function checkDelegateForContract(address delegate, address vault, address contract_)
        external
        view
        returns (bool);

    /**
     * @notice Returns true if the address is delegated to act on your behalf for a specific token, the token's contract or an entire vault
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param tokenId The token id for the token you're delegating
     * @param vault The cold wallet who issued the delegation
     */
    function checkDelegateForToken(address delegate, address vault, address contract_, uint256 tokenId)
        external
        view
        returns (bool);
}

{
  "evmVersion": "shanghai",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_presaleClaim","type":"address"},{"internalType":"address","name":"_airdropClaim","type":"address"},{"internalType":"address","name":"_memecoin","type":"address"},{"internalType":"address","name":"_delegate","type":"address"},{"internalType":"address","name":"_stakeland","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidDelegate","type":"error"},{"inputs":[],"name":"NoClaimableToken","type":"error"},{"inputs":[],"name":"NotDelegatable","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimedAt","type":"uint256"}],"name":"ClaimedToStakeland","type":"event"},{"inputs":[],"name":"airdropClaim","outputs":[{"internalType":"contract IMemecoinClaim","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dc","outputs":[{"internalType":"contract IDelegationRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dcV2","outputs":[{"internalType":"contract IDelegateRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"delegate","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"memecoin","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"},{"internalType":"enum ClaimType[]","name":"_claimTypes","type":"uint8[]"},{"components":[{"internalType":"uint256","name":"collectionId","type":"uint256"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bool[]","name":"withNFTAirdropList","type":"bool[]"},{"internalType":"bool[]","name":"withNFTRewardsList","type":"bool[]"}],"internalType":"struct NFTCollectionClaimRequest[]","name":"_nftCollectionClaimRequests","type":"tuple[]"},{"internalType":"bool","name":"_withWalletRewards","type":"bool"}],"name":"multiClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"enum ClaimType[]","name":"_presaleClaims","type":"uint8[]"},{"components":[{"internalType":"uint256","name":"collectionId","type":"uint256"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bool[]","name":"withNFTAirdropList","type":"bool[]"},{"internalType":"bool[]","name":"withNFTRewardsList","type":"bool[]"}],"internalType":"struct NFTCollectionClaimRequest[]","name":"_airdropClaims","type":"tuple[]"},{"internalType":"bytes","name":"_permit","type":"bytes"}],"name":"multiClaimToStakeland","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"presaleClaim","outputs":[{"internalType":"contract IMemecoinClaim","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakeland","outputs":[{"internalType":"contract IStakeland","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000e6f3494e839f3d3fb36c407eb35cd85d90dc3704000000000000000000000000b1911d8ffcc2d8ca6c5ea4f4f18be6ea675c1ce7000000000000000000000000b131f4a55907b10d1f0a50d8ab8fa09ec342cd7400000000000000000000000032c1f663919102dc032dc3c22fe434af686f3b15000000000000000000000000c059a531b4234d05e9ef4ac51028f7e6156e2cce

-----Decoded View---------------
Arg [0] : _presaleClaim (address): 0xE6f3494E839F3D3Fb36c407eB35cd85D90Dc3704
Arg [1] : _airdropClaim (address): 0xb1911D8FFcC2d8cA6c5EA4F4f18bE6ea675c1Ce7
Arg [2] : _memecoin (address): 0xb131f4A55907B10d1F0A50d8ab8FA09EC342cd74
Arg [3] : _delegate (address): 0x32C1F663919102Dc032Dc3C22FE434Af686f3b15
Arg [4] : _stakeland (address): 0xC059A531B4234D05E9ef4ac51028F7E6156E2CCe

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000e6f3494e839f3d3fb36c407eb35cd85d90dc3704
Arg [1] : 000000000000000000000000b1911d8ffcc2d8ca6c5ea4f4f18be6ea675c1ce7
Arg [2] : 000000000000000000000000b131f4a55907b10d1f0a50d8ab8fa09ec342cd74
Arg [3] : 00000000000000000000000032c1f663919102dc032dc3c22fe434af686f3b15
Arg [4] : 000000000000000000000000c059a531b4234d05e9ef4ac51028f7e6156e2cce