Cryo Explorer Ethereum Mainnet

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

/**
 * @title StrategicDrop
 * @notice Strategic Reserve airdrop contract for any collection
 * @dev Allows NFT holder to claim an a share of deposited tokens once per NFT
 */

interface IERC20 {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

interface IERC721 {
    function ownerOf(uint256 tokenId) external view returns (address);
}

interface IDelegateRegistry {
    function checkDelegateForERC721(
        address to,        // The delegate wallet
        address from,      // The NFT owner's wallet
        address contract_, // The NFT collection address
        uint256 tokenId,   // Specific NFT ID being checked
        bytes32 rights     // Subdelegation rights (use "" for all)
    ) external view returns (bool);
}

/* ═══════════════════════════════════════════════════ */
/*                    CUSTOM ERRORS                    */
/* ═══════════════════════════════════════════════════ */
/// @notice Invalid address (zero address)
error InvalidAddress();
/// @notice Zero amount provided
error ZeroAmount();
/// @notice Contract already initialized
error AlreadyInitialized();
/// @notice Contract not initialized yet
error NotInitialized();
/// @notice Caller not authorized
error NotAuthorized();
/// @notice Token ID ranges not set
error RangesNotSet();
/// @notice Invalid token ID range
error InvalidRange();
/// @notice Invalid NFT ID for claim
error InvalidNFTId();
/// @notice Claim amount rounds to zero
error ClaimAmountRoundsToZero();
/// @notice NFT already claimed airdrop
error AlreadyClaimed();
/// @notice Caller not NFT owner
error NotNFTOwner();
/// @notice Insufficient contract balance
error InsufficientBalance();
/// @notice Token transfer failed
error TransferFailed();
/// @notice Empty NFT ID array provided
error EmptyBatch();

contract StrategicDrop {
    //
    //    _____ __             __             _
    //   / ___// /__________ _/ /____  ____ _(_)____
    //   \__ \/ __/ ___/ __ `/ __/ _ \/ __ `/ / ___/
    //  ___/ / /_/ /  / /_/ / /_/  __/ /_/ / / /__
    // /____/\__/_/   \__,_/\__/\___/\__, /_/\___/
    //    / __ \___  ________  _____/____/___
    //   / /_/ / _ \/ ___/ _ \/ ___/ | / / _ \
    //  / _, _/  __(__  )  __/ /   | |/ /  __/
    // /_/ |_|\___/____/\___/_/    |___/\___/

    address constant DELEGATE_REGISTRY = 0x00000000000000447e69651d841bD8D104Bed493;

    IERC20 public immutable token;           // The ERC20 token being airdropped
    IERC721 public immutable nftCollection;  // The NFT collection eligible for claims
    uint256 public immutable totalAirdrop;   // Total tokens allocated for airdrop
    address public immutable authorizedInitializer; // Address authorized to initialize ranges

    uint256 public startTokenId;   // First valid token ID (set during initialization)
    uint256 public endTokenId;     // Last valid token ID + 1 (set during initialization)
    uint256 public totalNFTs;      // Total count of NFTs (calculated during initialization)
    uint256 public claimAmount;    // Amount each NFT can claim (calculated during initialization)
    bool public initialized;       // Whether the airdrop has been initialized
    uint256 public totalClaimed;   // Total number of claims made

    // Track which NFT IDs have claimed
    mapping(uint256 => bool) public hasClaimed;

    // Events
    event Claimed(address indexed claimer, uint256 indexed nftId, uint256 amount, address indexed nftOwner);
    event BatchClaimed(address indexed claimer, uint256 successCount, uint256 failCount, address indexed nftOwner);

    /// @notice Constructor - sets immutable values (ranges set later via initialize)
    /// @param _token Address of the ERC20 token to distribute
    /// @param _nftCollection Address of the NFT collection
    /// @param _totalAirdrop Total amount of tokens to distribute across all NFTs
    /// @param _authorizedInitializer Address authorized to call initialize()
    constructor(
        address _token,
        address _nftCollection,
        uint256 _totalAirdrop,
        address _authorizedInitializer
    ) {
        if (_token == address(0)) revert InvalidAddress();
        if (_nftCollection == address(0)) revert InvalidAddress();
        if (_totalAirdrop == 0) revert ZeroAmount();
        if (_authorizedInitializer == address(0)) revert InvalidAddress();

        token = IERC20(_token);
        nftCollection = IERC721(_nftCollection);
        totalAirdrop = _totalAirdrop;
        authorizedInitializer = _authorizedInitializer;
    }

    /// @notice Finalize and enable claims
    /// @dev Locks token ID ranges and enables claiming
    function initialize() external {
        if (initialized) revert AlreadyInitialized();
        if (msg.sender != authorizedInitializer) revert NotAuthorized();
        if (totalNFTs == 0) revert RangesNotSet();

        initialized = true;
    }

    /// @notice Set or update the token ID ranges for the airdrop
    /// @param _startTokenId First valid token ID in the collection
    /// @param _endTokenId Last valid token ID + 1 (exclusive)
    /// @dev Can be called multiple times before initialization
    function setTokenIdRange(uint256 _startTokenId, uint256 _endTokenId) external {
        if (initialized) revert AlreadyInitialized();
        if (msg.sender != authorizedInitializer) revert NotAuthorized();
        if (_endTokenId <= _startTokenId) revert InvalidRange();

        startTokenId = _startTokenId;
        endTokenId = _endTokenId;
        totalNFTs = _endTokenId - _startTokenId;
        claimAmount = totalAirdrop / totalNFTs;

        if (claimAmount == 0) revert ClaimAmountRoundsToZero();
    }

    /// @notice Internal claim logic - validates and processes a single claim
    /// @param _nftId The ID of the NFT to claim for
    /// @param _nftOwner The address that owns the NFT (use address(0) if caller is owner)
    function _claim(uint256 _nftId, address _nftOwner) internal {
        // Check 0: Airdrop must be initialized
        if (!initialized) revert NotInitialized();

        // Check 1: NFT ID must be within valid range
        if (_nftId < startTokenId || _nftId >= endTokenId) revert InvalidNFTId();

        // Check 2: NFT must not have already claimed
        if (hasClaimed[_nftId]) revert AlreadyClaimed();

        // Resolve actual NFT owner (supports delegation)
        address requester = msg.sender;
        if (_nftOwner != address(0) && _nftOwner != msg.sender) {
            bool isDelegateValid = IDelegateRegistry(DELEGATE_REGISTRY)
                .checkDelegateForERC721(
                    msg.sender,              // The delegate calling this function
                    _nftOwner,               // The actual NFT owner
                    address(nftCollection),  // The NFT collection being checked
                    _nftId,                  // Specific NFT ID being claimed
                    ""                       // Empty string = accept any delegation rights
                );
            if (!isDelegateValid) revert NotAuthorized();
            requester = _nftOwner;  // Use NFT owner as the actual owner for all checks
        }

        // Check 3: Requester must own the NFT
        if (nftCollection.ownerOf(_nftId) != requester) revert NotNFTOwner();

        // Check 4: Contract must have sufficient balance
        if (token.balanceOf(address(this)) < claimAmount) revert InsufficientBalance();

        // Effects: Mark as claimed BEFORE transfer (reentrancy protection)
        hasClaimed[_nftId] = true;
        totalClaimed++;

        // Interaction: Transfer tokens to claimer (delegate)
        if (!token.transfer(msg.sender, claimAmount)) revert TransferFailed();

        // Emit event
        emit Claimed(msg.sender, _nftId, claimAmount, _nftOwner);
    }

    /// @notice Allows the owner of an NFT (or their delegate) to claim airdrop allocation
    /// @param _nftId The ID of the NFT to claim for
    /// @param _nftOwner The address that owns the NFT (use address(0) if caller is owner)
    function claim(uint256 _nftId, address _nftOwner) external {
        _claim(_nftId, _nftOwner);
    }

    /// @notice Claim airdrop for multiple NFTs in a single transaction
    /// @param _nftIds Array of NFT IDs to claim for
    /// @param _nftOwner The address that owns the NFTs (use address(0) if caller is owner)
    /// @return successCount Number of successful claims
    /// @return failedIds Array of NFT IDs that failed to claim
    /// @dev Validates each NFT before claiming. Skips invalid NFTs. Critical errors revert entire batch.
    function claimBatch(uint256[] calldata _nftIds, address _nftOwner)
        external
        returns (uint256 successCount, uint256[] memory failedIds)
    {
        // Validate batch input
        if (!initialized) revert NotInitialized();
        if (_nftIds.length == 0) revert EmptyBatch();

        // Track failures
        uint256 failCount = 0;
        uint256[] memory tempFailedIds = new uint256[](_nftIds.length);

        // Process each NFT with explicit pre-validation
        for (uint256 i = 0; i < _nftIds.length; i++) {
            uint256 nftId = _nftIds[i];

            // Skip if out of valid range
            if (nftId < startTokenId || nftId >= endTokenId) {
                tempFailedIds[failCount++] = nftId;
                continue;
            }

            // Skip if already claimed
            if (hasClaimed[nftId]) {
                tempFailedIds[failCount++] = nftId;
                continue;
            }

            // Resolve delegation and validate authorization
            address requester = msg.sender;
            if (_nftOwner != address(0) && _nftOwner != msg.sender) {
                bool isDelegateValid = IDelegateRegistry(DELEGATE_REGISTRY)
                    .checkDelegateForERC721(
                        msg.sender,              // The delegate calling this function
                        _nftOwner,               // The actual NFT owner
                        address(nftCollection),  // The NFT collection being checked
                        nftId,                   // Specific NFT ID being claimed
                        ""                       // Empty string = accept any delegation rights
                    );
                if (!isDelegateValid) {
                    tempFailedIds[failCount++] = nftId;
                    continue;
                }
                requester = _nftOwner;
            }

            // Skip if requester doesn't own the NFT
            if (nftCollection.ownerOf(nftId) != requester) {
                tempFailedIds[failCount++] = nftId;
                continue;
            }

            // All pre-checks passed - call internal claim logic
            // Critical errors (InsufficientBalance, TransferFailed) will revert entire batch
            _claim(nftId, _nftOwner);
            successCount++;
        }

        // Build right-sized result array
        failedIds = new uint256[](failCount);
        for (uint256 i = 0; i < failCount; i++) {
            failedIds[i] = tempFailedIds[i];
        }

        // Emit batch summary event
        emit BatchClaimed(msg.sender, successCount, failCount, _nftOwner);
    }

    /// @notice Check if an NFT has claimed its allocation
    /// @param _nftId The NFT ID to check
    /// @return bool True if claimed, false otherwise
    function isClaimed(uint256 _nftId) external view returns (bool) {
        return hasClaimed[_nftId];
    }

    /// @notice Get the current balance of airdrop tokens in the contract
    /// @return uint256 The token balance
    function remainingBalance() external view returns (uint256) {
        return token.balanceOf(address(this));
    }

    /// @notice Calculate how many claims have been made
    /// @param _startId Starting NFT ID to check (inclusive)
    /// @param _endId Ending NFT ID to check (exclusive)
    /// @return count Number of claims in the range
    /// @dev Use this to count claims in batches to avoid gas limits
    function countClaims(uint256 _startId, uint256 _endId) external view returns (uint256 count) {
        if (_startId < startTokenId) revert InvalidRange();
        if (_endId > endTokenId) revert InvalidRange();
        if (_startId >= _endId) revert InvalidRange();

        for (uint256 i = _startId; i < _endId; i++) {
            if (hasClaimed[i]) {
                count++;
            }
        }
    }

    /// @notice Check if a wallet can claim for a specific NFT (direct ownership or delegation)
    /// @param _nftId The NFT ID to check
    /// @param _claimer The wallet attempting to claim
    /// @param _nftOwner The address that owns the NFT (use address(0) if claimer is owner)
    /// @return canClaimNow True if claim is possible, false otherwise
    function canClaim(uint256 _nftId, address _claimer, address _nftOwner) external view returns (bool canClaimNow) {
        // Must be initialized
        if (!initialized) return false;

        // Must be in valid range
        if (_nftId < startTokenId || _nftId >= endTokenId) return false;

        // Must not have claimed already
        if (hasClaimed[_nftId]) return false;

        // Resolve requester
        address requester = _claimer;
        if (_nftOwner != address(0) && _nftOwner != _claimer) {
            // Check delegation
            bool isDelegateValid = IDelegateRegistry(DELEGATE_REGISTRY)
                .checkDelegateForERC721(_claimer, _nftOwner, address(nftCollection), _nftId, "");
            if (!isDelegateValid) return false;
            requester = _nftOwner;
        }

        // Check ownership
        if (nftCollection.ownerOf(_nftId) != requester) return false;

        // Check balance
        if (token.balanceOf(address(this)) < claimAmount) return false;

        return true;
    }
}