NFT Standards and Marketplace Architecture 2026

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// Minimal ERC-721 with metadata and supply cap
contract BasicNFT is ERC721, Ownable {
    uint256 public totalSupply;
    uint256 public constant MAX_SUPPLY = 10000;
    string private baseURI;

    constructor(string memory name, string memory symbol, string memory _baseURI)
        ERC721(name, symbol)
        Ownable(msg.sender)
    {
        baseURI = _baseURI;
    }

    function mint(address to) external onlyOwner {
        require(totalSupply < MAX_SUPPLY, "Max supply reached");
        totalSupply++;
        _safeMint(to, totalSupply);
    }

    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    // Each token gets its own URI: baseURI + tokenId + ".json"
    function tokenURI(uint256 tokenId)
        public view override returns (string memory)
    {
        _requireOwned(tokenId);
        return string.concat(baseURI, Strings.toString(tokenId), ".json");
    }
}

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract GameItems is ERC1155, Ownable {
    // Token type constants
    uint256 public constant GOLD_COIN   = 0;  // Fungible — unlimited supply
    uint256 public constant SWORD       = 1;  // Semi-fungible — 500 copies
    uint256 public constant LEGENDARY   = 2;  // NFT — only 1 exists
    uint256 public constant POTION      = 3;  // Fungible — 10000 supply

    mapping(uint256 => uint256) public maxSupply;
    mapping(uint256 => uint256) public totalMinted;

    constructor() ERC1155("https://game.example/api/item/{id}.json") Ownable(msg.sender) {
        maxSupply[GOLD_COIN]  = type(uint256).max;  // Unlimited
        maxSupply[SWORD]      = 500;
        maxSupply[LEGENDARY]  = 1;
        maxSupply[POTION]     = 10000;
    }

    // Batch mint — one transaction, one gas cost
    function mintBatch(address to, uint256[] calldata ids, uint256[] calldata amounts)
        external onlyOwner
    {
        for (uint i = 0; i < ids.length; i++) {
            require(totalMinted[ids[i]] + amounts[i] <= maxSupply[ids[i]],
                "Exceeds max supply");
            totalMinted[ids[i]] += amounts[i];
        }
        _mintBatch(to, ids, amounts, "");
    }

    // Safe transfer with data hook for contract recipients
    function safeTransferFrom(address from, address to, uint256 id,
        uint256 value, bytes memory data) public override
    {
        require(balanceOf(from, id) >= value, "Insufficient balance");
        super.safeTransferFrom(from, to, id, value, data);
    }
}

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

// Minimal ERC-6551 registry — computes TBA address from token binding
contract TBARegistry {
    // Returns the deterministic TBA address for an NFT
    function account(address tokenContract, uint256 tokenId)
        external view returns (address)
    {
        // Compute CREATE2 address from token binding
        bytes32 salt = keccak256(abi.encodePacked(tokenContract, tokenId));
        address impl = getImplementation();
        bytes32 initCode = keccak256(
            abi.encodePacked(
                type(ERC6551Account).creationCode,
                abi.encode(tokenContract, tokenId)
            )
        );
        address predicted = address(
            uint160(uint(keccak256(
                abi.encodePacked(
                    bytes1(0xff),
                    address(this),
                    salt,
                    initCode
                )
            )))
        );
        return predicted.code.length > 0 ? predicted : address(0);
    }

    // Deploy a TBA for an NFT
    function createAccount(address tokenContract, uint256 tokenId)
        external returns (address)
    {
        bytes32 salt = keccak256(abi.encodePacked(tokenContract, tokenId));
        address impl = getImplementation();

        // Deploy minimal proxy (EIP-1167)
        address account = address(new ERC6551Account{salt: salt}(
            tokenContract, tokenId
        ));
        return account;
    }

    function getImplementation() internal pure returns (address) {
        // Returns the canonical TBA implementation address
        return 0x...; // Deployed once, used by all proxies
    }
}

// Minimal ERC-6551 account — an ERC-4337 compatible smart account
contract ERC6551Account {
    address public tokenContract;
    uint256 public tokenId;

    constructor(address _tokenContract, uint256 _tokenId) {
        tokenContract = _tokenContract;
        tokenId = _tokenId;
    }

    // Only the NFT owner can execute through this account
    function execute(address to, uint256 value, bytes calldata data)
        external returns (bytes memory)
    {
        require(
            IERC721(tokenContract).ownerOf(tokenId) == msg.sender,
            "Not token owner"
        );
        (bool success, bytes memory result) = to.call{value: value}(data);
        require(success, "Execution failed");
        return result;
    }

    // Accept ETH
    receive() external payable {}
}

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

// Gasless NFT mint — uses ERC-4337 account abstraction
// User signs a message; a paymaster sponsors the gas
contract GaslessNFTMinter {
    using ECDSA for bytes32;

    struct MintRequest {
        address user;       // Who receives the NFT
        uint256 tokenId;
        uint256 nonce;      // Prevent replay
        uint256 deadline;   // Expiry timestamp
        uint256 price;      // Price in USDC (not ETH)
    }

    IERC20 public usdc;
    address public paymaster;  // Sponsors gas costs

    function mintWithSponsoredGas(MintRequest calldata req, bytes calldata signature)
        external
    {
        require(block.timestamp < req.deadline, "Expired");
        require(!usedNonces[req.nonce], "Nonce used");
        usedNonces[req.nonce] = true;

        // Verify signature (user authorized the mint)
        bytes32 hash = keccak256(abi.encode(req))
            .toEthSignedMessageHash();
        require(hash.recover(signature) == req.user, "Invalid signature");

        // User pays in USDC, not ETH
        usdc.transferFrom(req.user, address(this), req.price);

        // Paymaster covers gas — called via ERC-4337 handleOps
        _mint(req.user, req.tokenId);
    }
}

{
  "name": "CryptoKitty #1234",
  "description": "A rare striped crypto-kitty with blue eyes.",
  "image": "ipfs://QmZbH3Y8K9RcA5f7d6g2j4kL1m9n0b3v5c7x8z9w0q2w4e6r8t0y",
  "attributes": [
    { "trait_type": "Fur", "value": "Striped" },
    { "trait_type": "Eyes", "value": "Blue" },
    { "trait_type": "Rarity", "value": "Legendary" }
  ],
  "animation_url": "ipfs://QmX7y8Z9aB0c1d2e3f4g5h6i7j8k9l0m1n2o3p4q5r6s7t8u9v0w1x",
  "external_url": "https://example.com/nft/1234",
  "background_color": "FFFFFF"
}

// On-chain SVG generation — no external dependencies
contract OnChainNFT is ERC721, Ownable {
    function tokenURI(uint256 tokenId)
        public view override returns (string memory)
    {
        _requireOwned(tokenId);
        string memory svg = string.concat(
            '<svg xmlns="http://www.w3.org/2000/svg" width="500" height="500">',
            '<rect width="500" height="500" fill="',
            getColor(tokenId), '"/>',
            '<text x="250" y="250" text-anchor="middle" fill="white" font-size="48">',
            Strings.toString(tokenId),
            '</text></svg>'
        );

        string memory json = string.concat(
            '{"name":"OnChain #', Strings.toString(tokenId), '",',
            '"description":"Fully on-chain NFT",',
            '"image":"data:image/svg+xml;base64,',
            Base64.encode(bytes(svg)), '"}'
        );

        return string.concat(
            "data:application/json;base64,",
            Base64.encode(bytes(json))
        );
    }

    function getColor(uint256 tokenId) internal pure returns (string memory) {
        bytes1 b = bytes1(keccak256(abi.encodePacked(tokenId)));
        uint8 r = uint8(b) % 256;
        uint8 g = uint8(b << 1) % 256;
        uint8 b2 = uint8(b << 2) % 256;
        return string.concat("#", toHex(r), toHex(g), toHex(b2));
    }
}

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract RoyaltyNFT is ERC721 {
    // Royalty percentage in basis points (250 = 2.5%)
    uint96 public royaltyBps = 250;
    address public royaltyRecipient;

    // EIP-2981 royalty info
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external view returns (address receiver, uint256 royaltyAmount)
    {
        _requireOwned(tokenId);  // Validate token exists
        return (royaltyRecipient, (salePrice * royaltyBps) / 10000);
    }

    // EIP-2981 supportsInterface override
    function supportsInterface(bytes4 interfaceId)
        public view override returns (bool)
    {
        return interfaceId == 0x2a55205a  // EIP-2981
            || super.supportsInterface(interfaceId);
    }

    function setRoyalty(address recipient, uint96 bps) external onlyOwner {
        require(bps <= 1000, "Royalty max 10%");
        royaltyRecipient = recipient;
        royaltyBps = bps;
    }
}

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract LazyMintNFT is ERC721 {
    using ECDSA for bytes32;

    struct NFTVoucher {
        address creator;      // Original creator (receives royalty)
        address recipient;    // First buyer
        uint256 tokenId;
        uint256 price;        // Mint price in wei
        uint256 expiry;       // Voucher expiration
    }

    mapping(bytes32 => bool) public usedVouchers;

    function redeem(NFTVoucher calldata voucher, bytes calldata signature)
        external payable returns (uint256)
    {
        require(msg.value >= voucher.price, "Insufficient payment");
        require(block.timestamp < voucher.expiry, "Voucher expired");

        bytes32 hash = keccak256(abi.encode(voucher))
            .toEthSignedMessageHash();
        address signer = hash.recover(signature);
        require(signer == voucher.creator, "Invalid signature");
        require(!usedVouchers[hash], "Voucher already used");

        usedVouchers[hash] = true;
        _safeMint(voucher.recipient, voucher.tokenId);

        // Pay creator minus platform fee
        payable(voucher.creator).transfer(voucher.price * 95 / 100);

        return voucher.tokenId;
    }
}

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

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";

contract MinimalMarketplace {
    uint8 public constant FEE_BPS = 250;  // 2.5% platform fee

    struct Listing {
        address seller;
        address tokenContract;
        uint256 tokenId;
        uint256 quantity;    // 1 for ERC-721, >1 for ERC-1155
        uint256 priceWei;
        bool isERC1155;
        bool active;
    }

    mapping(bytes32 => Listing) public listings;  // listingId => Listing
    uint256 public totalListings;

    event ListingCreated(bytes32 indexed listingId, address seller,
        address tokenContract, uint256 tokenId, uint256 price);
    event Sale(bytes32 indexed listingId, address buyer,
        address seller, uint256 price, uint256 royaltyPaid);

    // Seller lists an NFT for sale
    function listItem(address tokenContract, uint256 tokenId,
        uint256 price, uint256 quantity, bool isERC1155)
        external returns (bytes32 listingId)
    {
        require(price > 0, "Price must be > 0");

        listingId = keccak256(abi.encodePacked(
            msg.sender, tokenContract, tokenId, block.timestamp
        ));
        totalListings++;

        listings[listingId] = Listing({
            seller: msg.sender,
            tokenContract: tokenContract,
            tokenId: tokenId,
            quantity: quantity,
            priceWei: price,
            isERC1155: isERC1155,
            active: true
        });

        // Transfer NFT to marketplace escrow
        if (isERC1155) {
            IERC1155(tokenContract).safeTransferFrom(
                msg.sender, address(this), tokenId, quantity, ""
            );
        } else {
            require(quantity == 1, "ERC-721 quantity must be 1");
            IERC721(tokenContract).transferFrom(
                msg.sender, address(this), tokenId
            );
        }

        emit ListingCreated(listingId, msg.sender, tokenContract, tokenId, price);
    }

    // Buyer purchases a listed NFT
    function buyItem(bytes32 listingId) external payable {
        Listing storage listing = listings[listingId];
        require(listing.active, "Listing not active");
        require(msg.value >= listing.priceWei, "Insufficient payment");

        listing.active = false;

        // Calculate fees
        uint256 platformFee = (msg.value * FEE_BPS) / 10000;

        // Check EIP-2981 royalties
        uint256 royaltyAmount;
        address royaltyRecipient;
        (bool success, bytes memory data) = listing.tokenContract.staticcall(
            abi.encodeWithSelector(
                0x2a55205a, listing.tokenId, msg.value
            )
        );
        if (success) {
            (royaltyRecipient, royaltyAmount) = abi.decode(data, (address, uint256));
        }

        // Distribute funds
        uint256 sellerProceeds = msg.value - platformFee - royaltyAmount;
        payable(listing.seller).transfer(sellerProceeds);
        if (royaltyRecipient != address(0) && royaltyAmount > 0) {
            payable(royaltyRecipient).transfer(royaltyAmount);
        }

        // Transfer NFT to buyer
        if (listing.isERC1155) {
            IERC1155(listing.tokenContract).safeTransferFrom(
                address(this), msg.sender, listing.tokenId, listing.quantity, ""
            );
        } else {
            IERC721(listing.tokenContract).transferFrom(
                address(this), msg.sender, listing.tokenId
            );
        }

        emit Sale(listingId, msg.sender, listing.seller, msg.value, royaltyAmount);
    }
}

// Seaport-style order structure (simplified)
struct Order {
    address offerer;           // Seller
    OfferItem[] offer;         // What seller gives (NFT)
    ConsiderationItem[] consideration;  // What seller receives (ETH + royalties)
    uint8 orderType;           // FULL_RESTRICTED, PARTIAL_RESTRICTED, etc.
    uint256 startTime;
    uint256 endTime;
    bytes32 salt;              // Unique per order
    bytes signature;           // EIP-712 signature
}

struct OfferItem {
    uint8 itemType;            // NATIVE, ERC20, ERC721, ERC1155
    address token;
    uint256 identifierOrCriteria;  // tokenId or criteria
    uint256 startAmount;
    uint256 endAmount;          // For Dutch auctions (declining price)
}

struct ConsiderationItem {
    uint8 itemType;
    address token;
    uint256 identifierOrCriteria;
    uint256 startAmount;
    uint256 endAmount;
    address recipient;          // Who receives this portion
}

// Bonding curve pricing for NFT pools
contract NFTAMMPool {
    // Constant product AMM: x * y = k
    // x = number of NFTs in pool
    // y = ETH in pool
    // Price per NFT = y / x (instantaneous price)

    IERC721 public nftContract;
    uint256 public constant K_FACTOR = 1_000_000;  // Fixed k for the pool

    function getBuyPrice(uint256 amount) public view returns (uint256) {
        uint256 nftBalance = getPoolBalance();
        uint256 ethBalance = address(this).balance;
        // Price increases as NFTs are removed (inventory decreases)
        // Marginal price = k / (nftBalance - amount)
        uint256 newBalance = nftBalance - amount;
        return (ethBalance * newBalance) / nftBalance; // Simplified
    }

    function buyNFT(uint256 amount) external payable {
        uint256 price = getBuyPrice(amount);
        require(msg.value >= price, "Insufficient payment");
        // Transfer NFTs from pool to buyer
        for (uint256 i = 0; i < amount; i++) {
            uint256 tokenId = getPoolToken();
            nftContract.transferFrom(address(this), msg.sender, tokenId);
        }
    }

    function sellNFT(uint256 tokenId) external {
        // Seller deposits NFT, receives ETH at current sell price
        nftContract.transferFrom(msg.sender, address(this), tokenId);
        uint256 price = getSellPrice(1);
        payable(msg.sender).transfer(price);
    }
}

┌─────────────────────────────────────────────────────────────────────┐
│                    ZORA NETWORK ARCHITECTURE                         │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────────────────────────────────────────────────┐       │
│  │                   ETHEREUM L1 (Settlement)               │       │
│  │  • State root commitments posted every ~15 min           │       │
│  │  • Dispute window for fraud proofs                       │       │
│  │  • Final settlement after challenge period               │       │
│  └───────────────────────┬─────────────────────────────────┘       │
│                          │                                          │
│  ┌───────────────────────┴─────────────────────────────────┐       │
│  │                OP STACK SEQUENCER                        │       │
│  │  • Orders L2 transactions into batches                   │       │
│  │  • Posts batch data + state roots to L1                  │       │
│  │  • Zora-specific: subsidized mint transactions           │       │
│  └───────────────────────┬─────────────────────────────────┘       │
│                          │                                          │
│  ┌───────────────────────┴─────────────────────────────────┐       │
│  │               ZORA L2 EXECUTION LAYER                    │       │
│  │                                                          │       │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐              │       │
│  │  │ Minting  │  │ Trading  │  │ Royalty  │              │       │
│  │  │ Module   │  │ Module   │  │ Module   │              │       │
│  │  └──────────┘  └──────────┘  └──────────┘              │       │
│  │                                                          │       │
│  │  Gas model: 0.00001 ETH per mint ≈ $0.001               │       │
│  └─────────────────────────────────────────────────────────┘       │
│                                                                     │
│  ECOSYSTEM: Base / OP Mainnet / Mode / Zora                         │
│  All connected via OP Superchain interoperability                  │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

// Simplified NFT bridge — lock on source, mint on destination
contract NFTBridge {
    IERC721 public nftContract;
    uint256 public nonce;

    // Mapping from source (chainId + tokenId) to destination token
    mapping(bytes32 => bool) public bridgedTokens;

    event Bridged(address sender, uint256 tokenId,
        uint256 sourceChain, uint256 destChain, uint256 destTokenId);

    // Lock NFT on source chain
    function bridgeOut(uint256 tokenId, uint256 destChainId) external {
        // Transfer NFT to bridge contract
        nftContract.transferFrom(msg.sender, address(this), tokenId);

        bytes32 bridgeId = keccak256(abi.encodePacked(
            block.chainid, tokenId, destChainId
        ));
        bridgedTokens[bridgeId] = true;

        emit Bridged(msg.sender, tokenId, block.chainid, destChainId, tokenId);
    }

    // Mint wrapped NFT on destination chain (called by relayer)
    function bridgeIn(uint256 tokenId, uint256 sourceChainId,
        address recipient, bytes calldata proof) external
    {
        require(verifyProof(sourceChainId, tokenId, proof), "Invalid proof");
        bytes32 bridgeId = keccak256(abi.encodePacked(
            sourceChainId, tokenId, block.chainid
        ));
        require(!bridgedTokens[bridgeId], "Already bridged");
        bridgedTokens[bridgeId] = true;

        _mint(recipient, tokenId);
    }
}

// Real estate fractionalization contract
contract RealEstateToken is ERC1155, Ownable {
    struct Property {
        string deedHash;      // IPFS hash of legal deed
        uint256 totalTokens;  // Total fractional shares (e.g. 10000)
        uint256 pricePerShare; // Minimum price per share in USDC
        address propertyManager;
        bool verified;        // Legal verification flag
    }

    mapping(uint256 => Property) public properties;
    uint256 public nextPropertyId;

    function tokenizeProperty(
        string calldata deedHash,
        uint256 totalTokens,
        uint256 pricePerShare
    ) external returns (uint256 propertyId)
    {
        require(bytes(deedHash).length > 0, "Invalid deed");
        propertyId = nextPropertyId++;

        properties[propertyId] = Property({
            deedHash: deedHash,
            totalTokens: totalTokens,
            pricePerShare: pricePerShare,
            propertyManager: msg.sender,
            verified: false
        });

        // Mint all tokens to property manager initially
        _mint(msg.sender, propertyId, totalTokens, "");
    }

    // Shareholder dividend distribution
    function distributeDividends(uint256 propertyId)
        external payable
    {
        Property storage prop = properties[propertyId];
        uint256 totalSupply = prop.totalTokens;

        // Distribute ETH proportionally to all token holders
        // In production, iterate over holder list
        // payable(holder).transfer(msg.value * balance / totalSupply);
    }
}