NFT 与数字收藏品

概述

NFT（非同质化代币，Non-Fungible Token）是指具有唯一性和不可互换性的数字资产。与 ERC-20 代币（每个代币完全相同）不同，每个 NFT 都有独特的标识和属性，代表真实世界或数字世界中的唯一物品的所有权。

1. 与 ERC-20 的本质区别

特性	ERC-20 代币	NFT (ERC-721)
同质性	完全同质，可互换	非同质，每个唯一
转账	任意数量转账	一次一个，不可分割
识别	通过数量识别	通过 Token ID 识别
应用场景	货币、支付	艺术品、收藏、游戏资产
智能合约标准	ERC-20	ERC-721, ERC-1155

2. NFT 的技术标准

2.1 ERC-721 标准

最基础的 NFT 标准，每个代币通过唯一的 tokenId 识别。

pragma solidity ^0.8.0;

interface IERC721 {
    // 返回账户拥有的 NFT 数量
    function balanceOf(address owner) external view returns (uint256 balance);

    // 返回 NFT 的所有者
    function ownerOf(uint256 tokenId) external view returns (address owner);

    // 转账 NFT
    function transferFrom(address from, address to, uint256 tokenId) external;

    // 授权第三方进行操作
    function approve(address to, uint256 tokenId) external;

    // 返回被授权的地址
    function getApproved(uint256 tokenId) external view returns (address operator);

    // 批量授权
    function setApprovalForAll(address operator, bool approved) external;

    // 检查是否被授权
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// 事件
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);

完整实现示例：

pragma solidity ^0.8.0;

contract SimpleNFT {
    string public name = "Simple NFT";
    string public symbol = "SNFT";

    // Token 元数据
    mapping(uint256 => string) private tokenURI;
    mapping(uint256 => address) private tokenOwner;
    mapping(address => uint256) private balances;
    mapping(uint256 => address) private tokenApprovals;
    mapping(address => mapping(address => bool)) private operatorApprovals;

    uint256 private tokenIdCounter;

    // 事件
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event Mint(address indexed to, uint256 indexed tokenId, string uri);

    // 铸造 NFT
    function mint(address to, string memory uri) public returns (uint256) {
        require(to != address(0), "Invalid address");

        uint256 tokenId = tokenIdCounter++;
        tokenOwner[tokenId] = to;
        balances[to]++;

        tokenURI[tokenId] = uri;

        emit Mint(to, tokenId, uri);
        emit Transfer(address(0), to, tokenId);

        return tokenId;
    }

    // 销毁 NFT
    function burn(uint256 tokenId) public {
        require(msg.sender == tokenOwner[tokenId], "Not owner");

        address owner = tokenOwner[tokenId];
        balances[owner]--;
        delete tokenOwner[tokenId];
        delete tokenURI[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    // 转账（带授权检查）
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(from == tokenOwner[tokenId], "Not from owner");
        require(to != address(0), "Invalid address");
        require(
            msg.sender == from || msg.sender == tokenApprovals[tokenId] || operatorApprovals[from][msg.sender],
            "Not approved"
        );

        // 转移所有权
        tokenOwner[tokenId] = to;
        balances[from]--;
        balances[to]++;

        // 清除单次授权
        if (tokenApprovals[tokenId] != address(0)) {
            delete tokenApprovals[tokenId];
        }

        emit Transfer(from, to, tokenId);
    }

    // 获取 Token 元数据 URI
    function getTokenURI(uint256 tokenId) public view returns (string memory) {
        require(tokenOwner[tokenId] != address(0), "Token does not exist");
        return tokenURI[tokenId];
    }

    // 获取余额
    function balanceOf(address owner) public view returns (uint256) {
        return balances[owner];
    }

    // 获取所有者
    function ownerOf(uint256 tokenId) public view returns (address) {
        return tokenOwner[tokenId];
    }

    // 授权
    function approve(address to, uint256 tokenId) public {
        address owner = tokenOwner[tokenId];
        require(msg.sender == owner || operatorApprovals[owner][msg.sender], "Not authorized");

        tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    // 批量授权
    function setApprovalForAll(address operator, bool approved) public {
        operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }
}

2.2 ERC-1155 标准

支持同时发行可交换和不可交换代币，更灵活且 Gas 高效。

pragma solidity ^0.8.0;

interface IERC1155 {
    // 查询余额
    function balanceOf(address account, uint256 id) external view returns (uint256);

    // 批量查询余额
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external view returns (uint256[] memory);

    // 转账
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    // 批量转账
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;

    // 批量授权
    function setApprovalForAll(address operator, bool approved) external;

    // 检查授权
    function isApprovedForAll(address account, address operator) external view returns (bool);
}

event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);

ERC-1155 的优势：

• 可同时管理多种资产（纯 NFT、可交换代币、半可交换代币）

• 单次交易可处理多个 ID，Gas 费用更低

• 适合游戏中各类资源的管理（武器、皮肤、货币等）

3. NFT 元数据标准

NFT 的真实内容（图片、视频、文本）通常不存储在区块链上，而是存储在链外存储（如 IPFS），智能合约仅保存指向这些资源的 URI。

3.1 标准元数据格式

ERC-721 使用 JSON 格式描述元数据：

{
  "name": "Bored Ape #1",
  "description": "A rare digital ape from the Bored Ape Yacht Club collection",
  "image": "ipfs://QmRZeF3mAL4VY5N8w8Wz8H6k1m2Zx4c7v8b9d0e1f2g3h4i",
  "attributes": [
    {
      "trait_type": "Background",
      "value": "Blue"
    },
    {
      "trait_type": "Fur",
      "value": "Tan"
    },
    {
      "trait_type": "Eyes",
      "value": "Blue Beams"
    },
    {
      "trait_type": "Mouth",
      "value": "Bored"
    },
    {
      "trait_type": "Rarity Score",
      "value": 8.5
    }
  ]
}

3.2 使用 IPFS 存储元数据

// 使用 web3.storage 或 NFT.storage 上传到 IPFS
const NFTStorage = require('nft.storage');
const fs = require('fs');

async function uploadMetadata() {
    const client = new NFTStorage({ token: process.env.NFT_STORAGE_TOKEN });

    const metadata = {
        name: "My NFT",
        description: "A beautiful digital art",
        image: new File([fs.readFileSync('art.jpg')], 'art.jpg', { type: 'image/jpeg' }),
        attributes: [
            { trait_type: "Color", value: "Blue" },
            { trait_type: "Rarity", value: "Rare" }
        ]
    };

    // 上传并获取 IPFS CID
    const cid = await client.store(metadata);
    const uri = `ipfs://${cid}`;

    console.log(`元数据已上传到: ${uri}`);
    return uri;
}

4. NFT 应用场景

4.1 数字艺术品与收藏品

OpenSea、Blur 等平台使开发者和艺术家无需编写代码即可创建和交易 NFT。

特点：

• 高度个性化和稀有性

• 社区驱动的价值发现

• 版税机制（艺术家可在每次转售中获得分成）

代码示例 - 支持版税的 NFT：

pragma solidity ^0.8.0;

contract RoyaltyNFT {
    mapping(uint256 => address) public creators;
    mapping(uint256 => uint256) public royaltyPercent;  // 百分比，基数 10000

    event RoyaltyTransfer(address indexed recipient, uint256 amount);

    // 销售时调用，自动分配版税
    function handleSale(uint256 tokenId, uint256 salePrice) internal {
        address creator = creators[tokenId];
        if (creator != address(0)) {
            uint256 royalty = (salePrice * royaltyPercent[tokenId]) / 10000;
            payable(creator).transfer(royalty);
            emit RoyaltyTransfer(creator, royalty);
        }
    }

    // 市场合约会调用此函数
    function onSale(uint256 tokenId, uint256 price) public {
        handleSale(tokenId, price);
    }
}

4.2 游戏资产

链上游戏（GameFi）使用 NFT 表示游戏内物品，玩家真正拥有这些资产。

示例架构：

pragma solidity ^0.8.0;

contract GameAsset is ERC1155 {
    enum AssetType { Weapon, Armor, Consumable }

    mapping(uint256 => AssetType) public assetTypes;
    mapping(uint256 => uint256) public assetStats;  // 攻击力、防御力等

    function mintWeapon(address to, uint256 damage) public onlyGameMaster {
        uint256 assetId = totalAssets++;

        assetTypes[assetId] = AssetType.Weapon;
        assetStats[assetId] = damage;

        _mint(to, assetId, 1, "");
    }

    function upgradeAsset(uint256 assetId, uint256 increaseStats) public {
        require(balanceOf(msg.sender, assetId) > 0, "Not owner");
        assetStats[assetId] += increaseStats;
    }
}

4.3 身份与凭证

可验证的链上身份、学位证书、会员证等。

优势：

• 防伪性强（由区块链保证）

• 可验证性（任何人可查证真伪）

• 可转移性（持有者可出售或转赠）

4.4 域名和地址

ENS（Ethereum Name Service）将复杂的钱包地址映射到易记的域名。

pragma solidity ^0.8.0;

contract SimpleDomainNFT {
    mapping(string => address) public domainOwners;
    mapping(address => string) public addressToDomain;

    event DomainRegistered(string indexed domain, address indexed owner);

    function registerDomain(string memory domain, address to) public {
        require(bytes(domain).length > 0, "Invalid domain");
        require(domainOwners[domain] == address(0), "Domain taken");

        domainOwners[domain] = to;
        addressToDomain[to] = domain;

        emit DomainRegistered(domain, to);
    }

    function resolveDomain(string memory domain) public view returns (address) {
        return domainOwners[domain];
    }
}

5. NFT 市场合约

二级市场允许持有者之间交易 NFT。

简单的 NFT 市场实现：

pragma solidity ^0.8.0;

interface IERC721 {
    function transferFrom(address from, address to, uint256 tokenId) external;
}

contract NFTMarketplace {
    struct Listing {
        address seller;
        uint256 price;
        bool active;
    }

    IERC721 public nftContract;
    mapping(uint256 => Listing) public listings;

    event Listed(uint256 indexed tokenId, address indexed seller, uint256 price);
    event Sold(uint256 indexed tokenId, address indexed seller, address indexed buyer, uint256 price);

    constructor(address _nftContract) {
        nftContract = IERC721(_nftContract);
    }

    // 卖家上架 NFT
    function list(uint256 tokenId, uint256 price) public {
        require(price > 0, "Invalid price");

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

        emit Listed(tokenId, msg.sender, price);
    }

    // 买家购买 NFT
    function buy(uint256 tokenId) public payable {
        Listing memory listing = listings[tokenId];
        require(listing.active, "Not listed");
        require(msg.value >= listing.price, "Insufficient payment");

        // 转移 NFT
        nftContract.transferFrom(listing.seller, msg.sender, tokenId);

        // 转移支付
        payable(listing.seller).transfer(msg.value);

        // 标记为已售
        listings[tokenId].active = false;

        emit Sold(tokenId, listing.seller, msg.sender, listing.price);
    }

    // 卖家撤销上架
    function unlist(uint256 tokenId) public {
        require(listings[tokenId].seller == msg.sender, "Not seller");
        listings[tokenId].active = false;
    }
}

6. NFT 的风险和挑战

技术风险：

• 智能合约漏洞可导致资产被盗

• 元数据链接失效（IPFS 节点关闭，中心化服务器关闭）

• 跨链桥接风险（跨链 NFT 时可能丢失）

市场风险：

• 价格波动剧烈，投机成分大

• 洗盘行为（人为抬高价格）

• 地板价格（底价）可能长期低迷

法律风险：

• 知识产权问题（NFT 不等于版权）

• 监管不确定性

• 税收处理复杂

7. 最佳实践

1. 使用经审计的 ERC-721 标准库

   import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
   
   contract MyNFT is ERC721 {
       constructor() ERC721("MyNFT", "MNFT") {}
   }

2. 元数据持久化：使用 Arweave（永久存储）而非 IPFS（节点可能关闭）

3. 版税支持：实现 ERC-2981 标准以获得市场支持

4. 提供升级机制：使用代理模式以应对安全发现

这样的深入理解 NFT 技术和应用，将为进一步的区块链应用开发打下坚实基础。