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 {Context} from "@openzeppelin/contracts/utils/Context.sol";
import {IDelegationRegistry} from "contracts/delegation_registry/IDelegationRegistry.sol";
import {IDelegateRegistry} from "contracts/delegation_registry/IDelegateRegistry.sol";
import {ClaimType, NFTCollectionClaimRequest} from "./lib/Structs.sol";

error InvalidDelegate();

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

contract MemecoinMultiClaim is Context {
    IMemecoinClaim public immutable presaleClaim;
    IMemecoinClaim public immutable airdropClaim;
    IDelegationRegistry public immutable dc;
    IDelegateRegistry public immutable dcV2;

    constructor(address _presaleClaim, address _airdropClaim) {
        presaleClaim = IMemecoinClaim(_presaleClaim);
        airdropClaim = IMemecoinClaim(_airdropClaim);
        dc = IDelegationRegistry(0x00000000000076A84feF008CDAbe6409d2FE638B);
        dcV2 = IDelegateRegistry(0x00000000000000447e69651d841bD8D104Bed493);
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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

// 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: 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"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidDelegate","type":"error"},{"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":[{"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":[],"name":"presaleClaim","outputs":[{"internalType":"contract IMemecoinClaim","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000e6f3494e839f3d3fb36c407eb35cd85d90dc3704000000000000000000000000b1911d8ffcc2d8ca6c5ea4f4f18be6ea675c1ce7

-----Decoded View---------------
Arg [0] : _presaleClaim (address): 0xE6f3494E839F3D3Fb36c407eB35cd85D90Dc3704
Arg [1] : _airdropClaim (address): 0xb1911D8FFcC2d8cA6c5EA4F4f18bE6ea675c1Ce7

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e6f3494e839f3d3fb36c407eb35cd85d90dc3704
Arg [1] : 000000000000000000000000b1911d8ffcc2d8ca6c5ea4f4f18be6ea675c1ce7