IERC721A Interface¶

interface IERC721A {
    // ERC721 Standard Events
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    // ERC721A Specific Events
    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);

    // ERC721 Standard Functions
    function balanceOf(address owner) external view returns (uint256 balance);
    function ownerOf(uint256 tokenId) external view returns (address owner);
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function setApprovalForAll(address operator, bool approved) external;
    function getApproved(uint256 tokenId) external view returns (address operator);
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    // ERC721Metadata
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 tokenId) external view returns (string memory);

    // ERC721A Specific Functions
    function totalSupply() external view returns (uint256);
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

    // Batch Operations
    function safeMint(address to, uint256 quantity) external;
    function safeMint(address to, uint256 quantity, bytes memory data) external;

    // Advanced Queries
    function numberMinted(address owner) external view returns (uint256);
    function numberBurned(address owner) external view returns (uint256);
    function getAux(address owner) external view returns (uint64);
    function setAux(address owner, uint64 aux) external;

    // Token Existence
    function exists(uint256 tokenId) external view returns (bool);

    // Burning
    function burn(uint256 tokenId) external;
}

contract MyNFTCollection is IERC721A {
    string private _name;
    string private _symbol;
    string private _baseTokenURI;
    uint256 private _currentIndex;
    uint256 private _burnCounter;

    // Mapping from token ID to ownership details
    mapping(uint256 => TokenOwnership) private _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
        bool burned;
        uint24 extraData;
    }

    struct AddressData {
        uint64 balance;
        uint64 numberMinted;
        uint64 numberBurned;
        uint64 aux;
    }

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = 1; // Start token IDs at 1
    }

    function safeMint(address to, uint256 quantity) external override {
        require(to != address(0), "ERC721A: mint to zero address");
        require(quantity > 0, "ERC721A: quantity must be greater than 0");

        uint256 startTokenId = _currentIndex;
        _currentIndex += quantity;

        // Update balance and minted count
        _addressData[to].balance += uint64(quantity);
        _addressData[to].numberMinted += uint64(quantity);

        // Set ownership for the first token in the batch
        _ownerships[startTokenId] = TokenOwnership(
            to,
            uint64(block.timestamp),
            false,
            0
        );

        // Emit Transfer events
        for (uint256 i = 0; i < quantity; i++) {
            emit Transfer(address(0), to, startTokenId + i);
        }

        // Emit ConsecutiveTransfer event for gas optimization
        if (quantity > 1) {
            emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);
        }
    }

    function ownerOf(uint256 tokenId) public view override returns (address) {
        require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

        uint256 curr = tokenId;
        while (true) {
            TokenOwnership memory ownership = _ownerships[curr];
            if (ownership.addr != address(0)) {
                return ownership.addr;
            }
            curr--;
        }

        revert("ERC721A: unable to determine the owner of token");
    }

    function _exists(uint256 tokenId) internal view returns (bool) {
        return tokenId > 0 && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }
}

contract AdvancedERC721A is IERC721A {
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public constant MAX_BATCH_SIZE = 20;
    uint256 public mintPrice = 0.01 ether;

    mapping(address => bool) public whitelist;
    bool public whitelistActive = true;

    function publicMint(uint256 quantity) external payable {
        require(!whitelistActive, "Whitelist phase active");
        require(quantity <= MAX_BATCH_SIZE, "Exceeds max batch size");
        require(totalSupply() + quantity <= MAX_SUPPLY, "Exceeds max supply");
        require(msg.value >= mintPrice * quantity, "Insufficient payment");

        _safeMint(msg.sender, quantity);
    }

    function whitelistMint(uint256 quantity) external payable {
        require(whitelistActive, "Whitelist phase not active");
        require(whitelist[msg.sender], "Not whitelisted");
        require(quantity <= MAX_BATCH_SIZE, "Exceeds max batch size");
        require(totalSupply() + quantity <= MAX_SUPPLY, "Exceeds max supply");
        require(msg.value >= mintPrice * quantity, "Insufficient payment");

        _safeMint(msg.sender, quantity);
    }

    function airdrop(address[] calldata recipients, uint256[] calldata quantities) external onlyOwner {
        require(recipients.length == quantities.length, "Arrays length mismatch");

        for (uint256 i = 0; i < recipients.length; i++) {
            require(totalSupply() + quantities[i] <= MAX_SUPPLY, "Exceeds max supply");
            _safeMint(recipients[i], quantities[i]);
        }
    }
}

// Standard ERC721 - stores owner for each token
mapping(uint256 => address) private _owners; // 20k gas per token

// ERC721A - stores owner only for first token in batch
mapping(uint256 => TokenOwnership) private _ownerships; // 20k gas per batch

contract MarketplaceIntegration {
    IERC721A public nftContract;

    function listToken(uint256 tokenId, uint256 price) external {
        require(nftContract.ownerOf(tokenId) == msg.sender, "Not token owner");
        require(nftContract.getApproved(tokenId) == address(this) || 
                nftContract.isApprovedForAll(msg.sender, address(this)), "Not approved");

        // List token for sale
        _createListing(tokenId, price, msg.sender);
    }

    function buyToken(uint256 tokenId) external payable {
        Listing memory listing = listings[tokenId];
        require(listing.active, "Token not for sale");
        require(msg.value >= listing.price, "Insufficient payment");

        // Transfer token
        nftContract.safeTransferFrom(listing.seller, msg.sender, tokenId);

        // Handle payment
        _handlePayment(listing.seller, listing.price);
    }
}

contract NFTStaking {
    IERC721A public nftContract;
    mapping(uint252 => StakeInfo) public stakes;

    struct StakeInfo {
        address owner;
        uint256 stakedAt;
        uint256 rewards;
    }

    function stake(uint256[] calldata tokenIds) external {
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            require(nftContract.ownerOf(tokenId) == msg.sender, "Not token owner");

            // Transfer to staking contract
            nftContract.safeTransferFrom(msg.sender, address(this), tokenId);

            stakes[tokenId] = StakeInfo({
                owner: msg.sender,
                stakedAt: block.timestamp,
                rewards: 0
            });
        }
    }

    function unstake(uint256[] calldata tokenIds) external {
        for (uint256 i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            StakeInfo storage stake = stakes[tokenId];
            require(stake.owner == msg.sender, "Not stake owner");

            // Calculate and distribute rewards
            uint256 rewards = calculateRewards(tokenId);
            _distributeRewards(msg.sender, rewards);

            // Return NFT
            nftContract.safeTransferFrom(address(this), msg.sender, tokenId);
            delete stakes[tokenId];
        }
    }
}