第十一章：NFT与数字资产

学习目标：

• 理解 NFT 的本质和技术原理
• 掌握 NFT 标准和智能合约实现
• 了解 NFT 应用场景和市场生态
• 探索数字资产的未来发展趋势

关键词：NFT、ERC-721、ERC-1155、数字收藏品、元宇宙、数字身份、链上资产

11.1 什么是 NFT？

NFT 的定义

NFT (Non-Fungible Token，非同质化代币) 是一种独特的、不可互换的数字资产。与比特币、以太坊等同质化代币不同，每个 NFT 都有独特的标识和属性。

NFT 市场数据 (2025)

指标	数值	说明
市场总值	$25B+	较 2024 年增长 40%
交易平台	200+	OpenSea, Blur, Magic Eden 等
活跃钱包	500万+	月活跃交易用户
累计交易额	$150B+	自 2021 年至今

NFT 的核心价值

1. 所有权证明：区块链提供不可篡改的所有权记录
2. 稀缺性保证：代码确保供应量上限
3. 可编程性：智能合约实现版税、权限等功能
4. 可组合性：可在不同应用间互操作
5. 流动性：7×24 全球交易市场

11.2 NFT 标准

ERC-721: 第一个 NFT 标准

ERC-721 由 CryptoKitties 团队于 2017 年提出，是最广泛使用的 NFT 标准。

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

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

contract MyNFT is ERC721, Ownable {
    uint256 private _tokenIdCounter;

    // Token URI mapping
    mapping(uint256 => string) private _tokenURIs;

    constructor() ERC721("MyNFT", "MNFT") Ownable(msg.sender) {}

    // 铸造 NFT
    function mint(address to, string memory uri) public onlyOwner {
        uint256 tokenId = _tokenIdCounter;
        _tokenIdCounter++;

        _safeMint(to, tokenId);
        _tokenURIs[tokenId] = uri;
    }

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

    // 批量转账 (注意: ERC-721 不支持批量，需循环)
    function batchTransfer(address[] memory recipients, uint256[] memory tokenIds) public {
        require(recipients.length == tokenIds.length, "Length mismatch");

        for (uint256 i = 0; i < recipients.length; i++) {
            safeTransferFrom(msg.sender, recipients[i], tokenIds[i]);
        }
    }
}

ERC-1155: 多代币标准

ERC-1155 由 Enjin 团队提出，支持在单个合约中管理多种代币（FT + NFT）。

// ERC-1155 示例
pragma solidity ^0.8.20;

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

contract GameItems is ERC1155, Ownable {
    // Token IDs
    uint256 public constant GOLD_COIN = 0;      // FT (可分割)
    uint256 public constant SWORD = 1;          // NFT (限量)
    uint256 public constant LEGENDARY_ARMOR = 2; // NFT (稀有)

    constructor() ERC1155("https://game.example/api/item/{id}.json") Ownable(msg.sender) {
        // 初始铸造
        _mint(msg.sender, GOLD_COIN, 10**6, "");      // 100万金币
        _mint(msg.sender, SWORD, 100, "");            // 100把剑
        _mint(msg.sender, LEGENDARY_ARMOR, 10, "");   // 10件传奇装甲
    }

    // 批量铸造
    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts)
        public onlyOwner
    {
        _mintBatch(to, ids, amounts, "");
    }

    // 批量转账 (原生支持)
    function batchTransfer(address to, uint256[] memory ids, uint256[] memory amounts)
        public
    {
        safeBatchTransferFrom(msg.sender, to, ids, amounts, "");
    }
}

NFT 元数据标准

NFT 的元数据通常存储在链下（IPFS、Arweave），通过 tokenURI 引用：

{
  "name": "My NFT #001",
  "description": "A unique digital collectible",
  "image": "ipfs://QmXyZ.../image.png",
  "attributes": [
    {
      "trait_type": "Background",
      "value": "Blue"
    },
    {
      "trait_type": "Rarity",
      "value": "Legendary"
    },
    {
      "display_type": "number",
      "trait_type": "Generation",
      "value": 1
    }
  ]
}

11.3 NFT 应用场景

数字艺术案例：Beeple 的《Everydays》

• 成交价格: $69,346,250 (Christie’s 拍卖行, 2021)
• 艺术家: Beeple (Mike Winkelmann)
• 作品: 5000 天的数字创作合集
• 意义: 标志着传统艺术界对 NFT 的认可

游戏应用：Axie Infinity

// Axie Infinity 简化版示例
pragma solidity ^0.8.20;

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

contract AxieNFT is ERC721 {
    struct Axie {
        uint256 genes;        // 基因 (决定外观和属性)
        uint256 bornAt;       // 出生时间
        uint8 stage;          // 成长阶段 (蛋 -> 幼体 -> 成体)
        uint8 class;          // 职业 (Beast, Plant, Aquatic...)
        uint16 hp;            // 生命值
        uint16 speed;         // 速度
        uint16 skill;         // 技能
        uint16 morale;        // 士气
    }

    mapping(uint256 => Axie) public axies;

    constructor() ERC721("Axie", "AXIE") {}

    // 繁殖新 Axie
    function breed(uint256 parentId1, uint256 parentId2) external returns (uint256) {
        require(ownerOf(parentId1) == msg.sender, "Not owner");
        require(ownerOf(parentId2) == msg.sender, "Not owner");

        // 简化版基因组合
        uint256 newGenes = (axies[parentId1].genes + axies[parentId2].genes) / 2;

        uint256 newTokenId = totalSupply() + 1;
        _mint(msg.sender, newTokenId);

        axies[newTokenId] = Axie({
            genes: newGenes,
            bornAt: block.timestamp,
            stage: 0,  // 蛋阶段
            class: uint8(newGenes % 9),
            hp: 0, speed: 0, skill: 0, morale: 0
        });

        return newTokenId;
    }
}

11.4 NFT 的技术挑战

链上存储示例：SVG NFT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract OnChainSVG is ERC721 {
    using Strings for uint256;

    constructor() ERC721("OnChainArt", "OCA") {}

    function mint(uint256 tokenId) external {
        _mint(msg.sender, tokenId);
    }

    // 完全链上存储的 SVG
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(ownerOf(tokenId) != address(0), "Token does not exist");

        // 动态生成 SVG (基于 tokenId)
        string memory svg = string(abi.encodePacked(
            '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 400">',
            '<rect width="400" height="400" fill="hsl(', tokenId.toString(), ', 70%, 50%)"/>',
            '<text x="200" y="200" text-anchor="middle" font-size="48" fill="white">#', tokenId.toString(), '</text>',
            '</svg>'
        ));

        // Base64 编码
        string memory json = Base64.encode(
            bytes(
                string(
                    abi.encodePacked(
                        '{"name": "OnChain Art #', tokenId.toString(), '",',
                        '"description": "Fully on-chain generative SVG",',
                        '"image": "data:image/svg+xml;base64,', Base64.encode(bytes(svg)), '"}'
                    )
                )
            )
        );

        return string(abi.encodePacked('data:application/json;base64,', json));
    }
}

11.5 NFT-Fi：金融化创新

NFT 借贷协议

NFT AMM：Sudoswap

Sudoswap 使用 AMM 机制为 NFT 提供即时流动性：

// Sudoswap 简化原理
pragma solidity ^0.8.20;

contract NFTPool {
    // 线性定价曲线: price = startPrice + delta * numSold
    struct LinearCurve {
        uint128 startPrice;   // 起始价格
        uint128 delta;        // 每次交易价格变化
    }

    LinearCurve public curve;
    address[] public nftIds;  // 池中的 NFT

    // 买入 NFT (从池子)
    function buyNFT() external payable returns (uint256) {
        uint256 currentPrice = curve.startPrice + curve.delta * nftsSold;
        require(msg.value >= currentPrice, "Insufficient payment");

        // 转移 NFT
        uint256 tokenId = nftIds[nftIds.length - 1];
        nftIds.pop();

        // 价格上涨
        nftsSold++;

        return tokenId;
    }

    // 卖出 NFT (到池子)
    function sellNFT(uint256 tokenId) external {
        uint256 currentPrice = curve.startPrice + curve.delta * (nftsSold - 1);

        // 接收 NFT
        nftIds.push(tokenId);

        // 支付 ETH
        payable(msg.sender).transfer(currentPrice);

        // 价格下跌
        nftsSold--;
    }

    uint256 private nftsSold;
}

碎片化：Fractional NFT

将昂贵的 NFT 拆分成多个 ERC-20 代币，降低投资门槛：

// 简化版碎片化合约
pragma solidity ^0.8.20;

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

contract FractionalNFT is ERC20 {
    IERC721 public nft;
    uint256 public tokenId;
    uint256 public constant TOTAL_FRACTIONS = 1000000;  // 100万份

    constructor(address _nft, uint256 _tokenId) ERC20("Fractional NFT", "fNFT") {
        nft = IERC721(_nft);
        tokenId = _tokenId;

        // 将 NFT 锁定在合约中
        nft.transferFrom(msg.sender, address(this), _tokenId);

        // 铸造碎片代币
        _mint(msg.sender, TOTAL_FRACTIONS * 10**18);
    }

    // 赎回: 持有 100% 碎片可赎回 NFT
    function redeem() external {
        require(balanceOf(msg.sender) == TOTAL_FRACTIONS * 10**18, "Need 100% fractions");

        _burn(msg.sender, TOTAL_FRACTIONS * 10**18);
        nft.transferFrom(address(this), msg.sender, tokenId);
    }
}

11.6 NFT 的未来趋势

1. 动态 NFT (dNFT)

元数据可根据链上/链下事件更新：

pragma solidity ^0.8.20;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract DynamicNFT is ERC721 {
    AggregatorV3Interface internal priceFeed;

    mapping(uint256 => string) public tokenURIs;

    constructor() ERC721("DynamicNFT", "dNFT") {
        // Chainlink ETH/USD Price Feed
        priceFeed = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
    }

    // 根据 ETH 价格更新 NFT 外观
    function updateMetadata(uint256 tokenId) external {
        (, int256 price, , ,) = priceFeed.latestRoundData();

        if (price > 3000 * 10**8) {
            tokenURIs[tokenId] = "ipfs://Qm.../bull.json";  // 牛市形象
        } else {
            tokenURIs[tokenId] = "ipfs://Qm.../bear.json";  // 熊市形象
        }
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        return tokenURIs[tokenId];
    }
}

2. 跨链 NFT

使用 LayerZero 实现 Omnichain NFT：

pragma solidity ^0.8.20;

import "@layerzerolabs/solidity-examples/contracts/token/onft/ONFT721.sol";

// Omnichain NFT - 可在多条链间转移
contract CrossChainNFT is ONFT721 {
    constructor(
        string memory _name,
        string memory _symbol,
        address _layerZeroEndpoint
    ) ONFT721(_name, _symbol, _layerZeroEndpoint) {}

    // 跨链转移 NFT
    function sendFrom(
        address _from,
        uint16 _dstChainId,      // 目标链 ID
        bytes memory _toAddress,  // 目标地址
        uint256 _tokenId,
        address payable _refundAddress,
        address _zroPaymentAddress,
        bytes memory _adapterParams
    ) public payable override {
        // LayerZero 会自动处理跨链消息
        super.sendFrom(_from, _dstChainId, _toAddress, _tokenId, _refundAddress, _zroPaymentAddress, _adapterParams);
    }
}

3. 灵魂绑定代币 (SBT)

不可转让的 NFT，用于身份/信誉：

pragma solidity ^0.8.20;

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

contract SoulboundToken is ERC721 {
    constructor() ERC721("SoulBound", "SBT") {}

    // 禁止转账
    function _update(address to, uint256 tokenId, address auth)
        internal
        virtual
        override
        returns (address)
    {
        address from = _ownerOf(tokenId);

        // 只允许铸造 (from == address(0))
        // 禁止转账 (from != address(0) && to != address(0))
        if (from != address(0) && to != address(0)) {
            revert("Soulbound: Transfer not allowed");
        }

        return super._update(to, tokenId, auth);
    }

    // 发行学历证书
    function issueDiploma(address student, string memory university) external {
        uint256 tokenId = uint256(keccak256(abi.encodePacked(student, university)));
        _safeMint(student, tokenId);
    }
}

本章小结

本章深入介绍了 NFT 的核心概念、技术标准和应用生态：

1. NFT 本质：非同质化、独特性、可验证稀缺性
2. 技术标准：ERC-721 (单一 NFT)、ERC-1155 (多代币)、ERC-2981 (版税)
3. 应用场景：数字艺术、游戏道具、元宇宙、数字身份、实用型 NFT、金融 NFT
4. 技术挑战：存储成本、版税执行、流动性不足
5. NFT-Fi 创新：借贷协议、AMM、碎片化
6. 未来趋势：动态 NFT、跨链 NFT、灵魂绑定代币 (SBT)

关键要点：

• NFT 不仅是 JPEG 图片，更是可编程的数字所有权证明
• 选择合适的标准 (ERC-721 vs ERC-1155) 取决于具体应用场景
• NFT-Fi 正在为 NFT 提供更多金融属性和流动性
• 未来 NFT 将更注重实用性、动态性和跨链互操作性

参考资料

• EIP-721: https://eips.ethereum.org/EIPS/eip-721
• EIP-1155: https://eips.ethereum.org/EIPS/eip-1155
• EIP-2981: https://eips.ethereum.org/EIPS/eip-2981 (NFT Royalty Standard)
• OpenZeppelin Contracts: https://docs.openzeppelin.com/contracts/
• NFT 市场数据: DappRadar, NFTGo, CryptoSlam
• Sudoswap Docs: https://docs.sudoswap.xyz/
• LayerZero ONFT: https://layerzero.gitbook.io/docs/

下一章预告

第十二章《治理与 DAO》将介绍：

• DAO 的组织形式和治理机制
• 链上投票系统 (Governor, Snapshot)
• 代币经济学与激励设计
• 多签钱包与治理安全
• DAO 工具栈和最佳实践

让我们继续探索去中心化组织的未来！