NFT 市场合约开发：ERC-721/1155 深入与版税

// ERC-721：ownerOf 返回唯一持有人
function ownerOf(uint256 tokenId) external view returns (address owner);

// ERC-1155：余额按 (owner, id) 查询，batch 传输带 extraData
function balanceOf(address account, uint256 id) external view returns (uint256);
function safeBatchTransferFrom(
    address from, address to,
    uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data
) external;

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

interface IERC2981 {
    /// @notice 返回指定 tokenId 在给定成交价下的版税接收方与金额
    /// @return receiver 版税接收地址
    /// @return royaltyAmount 版税金额（wei）
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external view returns (address receiver, uint256 royaltyAmount);

    /// @notice 是否支持 ERC-2981（interface ID: 0x2a55205a）
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC2981} from "@openzeppelin/contracts/interfaces/IERC2981.sol";

contract RoyaltyNFT is ERC721, IERC2981 {
    address public royaltyReceiver;
    uint96 public royaltyBps;   // 以 basis points 计（1% = 100）

    constructor() ERC721("RoyaltyNFT", "RNFT") {
        royaltyReceiver = msg.sender;
        royaltyBps = 500;       // 5%
    }

    function royaltyInfo(uint256, uint256 salePrice)
        external view override returns (address receiver, uint256 royaltyAmount)
    {
        return (royaltyReceiver, (salePrice * royaltyBps) / 10_000);
    }

    function supportsInterface(bytes4 interfaceId)
        public view virtual override(ERC721, IERC2981) returns (bool)
    {
        return interfaceId == 0x2a55205a || super.supportsInterface(interfaceId);
    }
}

// 结算时：先扣手续费，再付版税，最后付卖家
function _settlePayment(address tokenContract, uint256 tokenId,
                        uint256 price, address seller) internal {
    uint256 protocolFee = (price * protocolBps) / 10_000;
    uint256 remainder = price - protocolFee;

    // 读取版税
    (address receiver, uint256 royaltyAmount) = IERC2981(tokenContract).royaltyInfo(tokenId, price);
    if (receiver != address(0) && royaltyAmount > 0) {
        remainder -= royaltyAmount;
        _transferEth(receiver, royaltyAmount);
    }
    _transferEth(seller, remainder);   // 卖家最后收款
}

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

import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract Marketplace is ReentrancyGuard {
    uint256 public protocolBps = 250;                    // 2.5%
    mapping(address => mapping(uint256 => Listing)) public listings;

    struct Listing {
        address seller;
        uint256 price;
        uint256 deadline;
        bool active;
    }

    event ListingCreated(address indexed token, uint256 indexed tokenId, address seller, uint256 price);
    event ListingCancelled(address indexed token, uint256 indexed tokenId, address seller);
    event OrderFilled(address indexed token, uint256 indexed tokenId, address buyer, address seller, uint256 price);

    // ---- 上架：卖家需已授权给本合约 ----
    function createListing(address tokenContract, uint256 tokenId,
                           uint256 price, uint256 deadline) external {
        require(price > 0, "Price must be > 0");
        require(block.timestamp < deadline, "Bad deadline");

        // 校验卖家确实是 owner（721）或至少拥有该资产
        IERC721 nft = IERC721(tokenContract);
        require(nft.ownerOf(tokenId) == msg.sender, "Not owner");
        require(nft.getApproved(tokenId) == address(this)
             || nft.isApprovedForAll(msg.sender, address(this)), "Not approved");

        listings[tokenContract][tokenId] = Listing(msg.sender, price, deadline, true);
        emit ListingCreated(tokenContract, tokenId, msg.sender, price);
    }

    // ---- 购买：CEI 顺序 ----
    function purchase(address tokenContract, uint256 tokenId)
        external payable nonReentrant
    {
        Listing memory l = listings[tokenContract][tokenId];
        require(l.active, "Not listed");
        require(block.timestamp <= l.deadline, "Expired");
        require(msg.value >= l.price, "Insufficient funds");

        // Effect：先移除挂单，防重入双花
        listings[tokenContract][tokenId].active = false;

        // Interaction：转 NFT（safeTransferFrom 会回调，故须在上锁内）
        IERC721(tokenContract).safeTransferFrom(l.seller, msg.sender, tokenId);

        // 结算资金（协议费 + 版税 + 卖家）
        _settlePayment(tokenContract, tokenId, l.price, l.seller);

        // 退还多付的 ETH
        if (msg.value > l.price) _transferEth(msg.sender, msg.value - l.price);

        emit OrderFilled(tokenContract, tokenId, msg.sender, l.seller, l.price);
    }

    function _transferEth(address to, uint256 amount) internal {
        (bool ok, ) = to.call{value: amount}("");
        require(ok, "ETH transfer failed");
    }
}

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

contract SignedOrderMarketplace {
    // EIP-712 域分隔符
    bytes32 public immutable DOMAIN_SEPARATOR;
    bytes32 internal constant ORDER_TYPEHASH =
        keccak256("Order(address token,uint256 tokenId,uint256 price,uint256 deadline,uint256 nonce)");

    mapping(address => uint256) public nonces;
    mapping(bytes32 => bool) public filled;

    constructor() {
        DOMAIN_SEPARATOR = keccak256(abi.encode(
            keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
            keccak256("SignedOrderMarketplace"),
            keccak256("1"),
            block.chainid,
            address(this)
        ));
    }

    function _hashOrder(Order calldata o) internal view returns (bytes32) {
        return keccak256(abi.encodePacked(
            "\x19\x01", DOMAIN_SEPARATOR,
            keccak256(abi.encode(ORDER_TYPEHASH,
                o.token, o.tokenId, o.price, o.deadline, o.nonce))
        ));
    }

    struct Order {
        address token;
        uint256 tokenId;
        uint256 price;
        uint256 deadline;
        uint256 nonce;
    }

    function fillOrder(Order calldata order, bytes calldata signature) external nonReentrant {
        bytes32 digest = _hashOrder(order);
        require(!filled[digest], "Order already filled");
        require(block.timestamp <= order.deadline, "Order expired");

        // ECDSA 恢复签名者
        address signer = ecrecover(digest, /* v,r,s */ ...);
        require(signer == order.seller, "Bad signature");

        filled[digest] = true;
        nonces[signer] = order.nonce + 1;
        // ... 结算
    }
}

{
  "offer": [{ "itemType": 2, "token": "0x...", "identifier": 123, "amount": 1 }],
  "consideration": [
    { "itemType": 0, "token": "0x0", "identifier": 0, "amount": 1000000000000000000 },
    { "itemType": 3, "token": "0xRoyalty", "identifier": 0, "amount": 50000000000000000 }
  ],
  "startTime": 1700000000, "endTime": 1730000000,
  "signature": "0x..."
}

// 抢单缓解：为卖方提供"更低价格窗口"
function purchaseWithLimit(address tokenContract, uint256 tokenId,
                           uint256 maxPrice) external payable nonReentrant {
    Listing memory l = listings[tokenContract][tokenId];
    require(l.active, "Not listed");
    require(l.price <= maxPrice, "Price moved");   // 防止地板价暴跌后被割
    // ... 后续同 purchase
}

// 防 ERC-1155 数量耗尽
function purchaseBatch1155(address tokenContract, uint256 id, uint256 amount, uint256 price)
    external payable nonReentrant
{
    require(IERC1155(tokenContract).balanceOf(msg.sender, id) >= amount, "Not enough");
    // ...
}

# 部署 + 交互示例
forge create src/Marketplace.sol:Marketplace --rpc-url $RPC --private-key $KEY
cast send <MARKETPLACE> "createListing(address,uint256,uint256,uint256)" \
  $NFT 1 1ether 1730000000 --private-key $SELLER_KEY
cast send <MARKETPLACE> "purchase(address,uint256)" $NFT 1 \
  --value 1ether --private-key $BUYER_KEY