NFT高级应用与创新

随着区块链技术的不断发展，NFT（非同质化通证）已经从简单的数字艺术品扩展到了更广泛的应用领域。本章将深入探讨NFT的高级应用场景、技术创新以及未来发展趋势，帮助开发者了解NFT技术的前沿应用和实践方法。

NFT与元宇宙（Metaverse）

元宇宙中的NFT基础设施

元宇宙作为虚拟与现实融合的数字世界，NFT为其提供了关键的数字资产所有权和互操作性基础设施。

虚拟土地与空间所有权

虚拟土地NFT是元宇宙中的基础资产，代表着元宇宙中特定位置的所有权和开发权。

// 简化的虚拟土地NFT合约示例
contract VirtualLand is ERC721URIStorage {
    struct Land {n        uint256 id;n        uint256 x;n        uint256 y;n        uint256 width;n        uint256 height;n        string metadataURI;n        address owner;n        uint256 lastUpdated;n    }
    
    mapping(uint256 => Land) public lands;
    mapping(address => uint256[]) public ownerLands;
    
    // 生成土地NFT
    function mintLand(uint256 x, uint256 y, uint256 width, uint256 height, string calldata metadataURI) external payable {
        // 验证土地坐标和尺寸是否有效
        require(isValidLand(x, y, width, height), "无效的土地坐标或尺寸");
        
        uint256 tokenId = totalSupply() + 1;
        
        // 创建土地结构
        lands[tokenId] = Land({
            id: tokenId,
            x: x,
            y: y,
            width: width,
            height: height,
            metadataURI: metadataURI,
            owner: msg.sender,
            lastUpdated: block.timestamp
        });
        
        // 将土地添加到所有者的土地列表
        ownerLands[msg.sender].push(tokenId);
        
        // 铸造NFT
        _mint(msg.sender, tokenId);
        _setTokenURI(tokenId, metadataURI);
    }
    
    // 验证土地坐标和尺寸是否有效
    function isValidLand(uint256 x, uint256 y, uint256 width, uint256 height) internal view returns (bool) {
        // 检查边界条件和重叠
        // ...
        return true;
    }
    
    // 获取土地所有者的所有土地
    function getOwnerLands(address owner) external view returns (uint256[] memory) {
        return ownerLands[owner];
    }
}

3D资产与可组合性

元宇宙中的NFT需要支持3D模型、动画和交互性，同时具备高度的可组合性，允许用户将不同NFT组合使用。

// 前端实现3D NFT渲染和组合示例
import * as THREE from 'three';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';

class MetaverseRenderer {
    constructor() {
        this.scene = new THREE.Scene();
        this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
        this.renderer = new THREE.WebGLRenderer();
        this.loader = new GLTFLoader();
        
        // 设置渲染器
        this.renderer.setSize(window.innerWidth, window.innerHeight);
        document.body.appendChild(this.renderer.domElement);
        
        // 设置相机位置
        this.camera.position.z = 5;
    }
    
    // 加载并渲染3D NFT
    async loadAndRenderNFT(nftMetadata) {
        try {
            // 从IPFS或其他存储加载3D模型
            const gltf = await this.loader.loadAsync(nftMetadata.modelURI);
            
            // 添加到场景
            this.scene.add(gltf.scene);
            
            // 应用NFT元数据中的自定义属性
            this.applyNFTProperties(gltf.scene, nftMetadata.properties);
            
            // 开始渲染循环
            this.animate();
        } catch (error) {
            console.error('加载3D NFT失败:', error);
        }
    }
    
    // 应用NFT属性到3D模型
    applyNFTProperties(model, properties) {
        // 根据NFT元数据自定义3D模型
        if (properties.color) {
            model.traverse((child) => {
                if (child.isMesh) {
                    child.material.color.set(properties.color);
                }
            });
        }
        
        // 应用缩放、旋转等属性
        if (properties.scale) {
            model.scale.set(properties.scale, properties.scale, properties.scale);
        }
    }
    
    // 渲染循环
    animate() {
        requestAnimationFrame(this.animate.bind(this));
        this.renderer.render(this.scene, this.camera);
    }
    
    // 组合多个NFT到场景
    addNFTToScene(nft, position, rotation, scale) {
        // 将多个NFT组合到同一场景
        const nftClone = nft.scene.clone();
        nftClone.position.set(position.x, position.y, position.z);
        nftClone.rotation.set(rotation.x, rotation.y, rotation.z);
        nftClone.scale.set(scale, scale, scale);
        this.scene.add(nftClone);
    }
}

// 使用示例
const metaverseRenderer = new MetaverseRenderer();
const nftMetadata = {
    modelURI: 'https://ipfs.io/ipfs/Qmabcdef123456789',
    properties: {
        color: '#FF0000',
        scale: 1.2
    }
};
metaverseRenderer.loadAndRenderNFT(nftMetadata);

元宇宙互操作性协议

为了解决不同元宇宙平台间的资产流通问题，出现了多种元宇宙互操作性协议。

Loot和On-chain NFT

Loot开创了On-chain NFT的先河，将所有NFT数据直接存储在链上，确保了完全的去中心化和互操作性。

// 简化的On-chain NFT合约示例
contract OnChainNFT is ERC721 {
    struct OnChainMetadata {
        string name;
        string description;
        // 直接存储在链上的属性
        mapping(string => string) attributes;
        bytes imageData; // 可存储SVG或其他格式的图像数据
    }
    
    mapping(uint256 => OnChainMetadata) public tokenMetadata;
    
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
    
    // 铸造On-chain NFT
    function mintNFT(string memory name, string memory description, bytes calldata imageData) external {
        uint256 tokenId = totalSupply() + 1;
        
        // 直接在链上存储NFT数据
        OnChainMetadata storage metadata = tokenMetadata[tokenId];
        metadata.name = name;
        metadata.description = description;
        metadata.imageData = imageData;
        
        _mint(msg.sender, tokenId);
    }
    
    // 添加属性到NFT
    function addAttribute(uint256 tokenId, string memory key, string memory value) external {
        require(ownerOf(tokenId) == msg.sender, "不是NFT所有者");
        tokenMetadata[tokenId].attributes[key] = value;
    }
    
    // 重写tokenURI方法，返回链上生成的metadata JSON
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "无效的tokenId");
        
        OnChainMetadata storage metadata = tokenMetadata[tokenId];
        
        // 构建并返回JSON格式的metadata
        return string(abi.encodePacked(
            'data:application/json;utf8,{',
            '"name":"', metadata.name, '",',
            '"description":"', metadata.description, '",',
            '"image":"data:image/svg+xml;base64,', Base64.encode(metadata.imageData), '"',
            '}'
        ));
    }
}

NFT与游戏（GameFi）

链上游戏资产与所有权

NFT为游戏行业带来了真正的数字资产所有权，玩家可以完全控制和交易他们在游戏中获得的资产。

游戏内资产NFT化

将游戏内的角色、装备、土地等资产转换为NFT，实现真正的所有权和跨游戏流通。

// 游戏物品NFT合约示例
contract GameItems is ERC1155 {
    // 游戏物品类型
    enum ItemType {
        WEAPON,
        ARMOR,
        CONSUMABLE,
        COLLECTIBLE
    }
    
    // 物品属性结构
    struct ItemProperties {
        string name;
        string description;
        uint256 attackPower;
        uint256 defense;
        uint256 durability;
        ItemType itemType;
        // 其他自定义属性
    }
    
    // 存储物品属性
    mapping(uint256 => ItemProperties) public itemProperties;
    mapping(uint256 => string) public itemNames;
    
    // 游戏地址（控制物品铸造）
    address public gameAddress;
    
    constructor(address _gameAddress) ERC1155("https://api.gamefi.com/metadata/{id}.json") {
        gameAddress = _gameAddress;
    }
    
    // 只有游戏合约可以铸造物品
    modifier onlyGame() {
        require(msg.sender == gameAddress, "只有游戏合约可以调用");
        _;
    }
    
    // 铸造新物品
    function mintItem(
        address to,
        uint256 itemId,
        uint256 amount,
        string memory name,
        string memory description,
        uint256 attackPower,
        uint256 defense,
        uint256 durability,
        ItemType itemType
    ) external onlyGame {
        // 存储物品属性
        itemProperties[itemId] = ItemProperties({
            name: name,
            description: description,
            attackPower: attackPower,
            defense: defense,
            durability: durability,
            itemType: itemType
        });
        
        itemNames[itemId] = name;
        
        // 铸造物品NFT
        _mint(to, itemId, amount, "");
    }
    
    // 物品使用/损耗
    function useItem(uint256 itemId, uint256损耗Amount) external {
        // 检查物品所有权
        require(balanceOf(msg.sender, itemId) > 0, "你不拥有此物品");
        
        // 更新物品耐久性
        ItemProperties storage props = itemProperties[itemId];
        require(props.durability > 0, "物品已损坏");
        
        if (props.durability <= 损耗Amount) {
            // 物品损坏，销毁
            props.durability = 0;
            _burn(msg.sender, itemId, 1);
        } else {
            // 减少耐久性
            props.durability -= 损耗Amount;
        }
    }
    
    // 物品升级
    function upgradeItem(uint256 itemId, uint256 attackBonus, uint256 defenseBonus) external {
        // 检查物品所有权
        require(balanceOf(msg.sender, itemId) > 0, "你不拥有此物品");
        
        // 升级物品属性
        ItemProperties storage props = itemProperties[itemId];
        props.attackPower += attackBonus;
        props.defense += defenseBonus;
    }
}

Play-to-Earn经济模型

Play-to-Earn（边玩边赚）游戏将NFT与游戏经济模型结合，让玩家通过游戏获得实际收益。

// 简化的Play-to-Earn游戏合约示例
contract PlayToEarnGame {
    // 游戏代币
    IERC20 public gameToken;
    // 游戏物品NFT
    GameItems public gameItems;
    
    // 游戏内角色结构
    struct Character {
        uint256 id;
        address owner;
        uint256 level;
        uint256 experience;
        uint256 energy;
        uint256 lastEnergyRefresh;
    }
    
    // 存储角色数据
    mapping(uint256 => Character) public characters;
    mapping(address => uint256[]) public playerCharacters;
    
    // 角色创建费用
    uint256 public characterCreationFee = 100 * 10 ** 18;
    // 每小时恢复的能量
    uint256 public energyPerHour = 10;
    // 最大能量值
    uint256 public maxEnergy = 100;
    
    constructor(address _gameToken, address _gameItems) {
        gameToken = IERC20(_gameToken);
        gameItems = GameItems(_gameItems);
    }
    
    // 创建新角色
    function createCharacter() external {
        // 收取创建费用
        require(gameToken.transferFrom(msg.sender, address(this), characterCreationFee), "代币转账失败");
        
        uint256 characterId = totalSupply() + 1;
        
        // 创建角色
        characters[characterId] = Character({
            id: characterId,
            owner: msg.sender,
            level: 1,
            experience: 0,
            energy: maxEnergy,
            lastEnergyRefresh: block.timestamp
        });
        
        // 将角色添加到玩家的角色列表
        playerCharacters[msg.sender].push(characterId);
    }
    
    // 刷新角色能量
    function refreshEnergy(uint256 characterId) internal {
        Character storage character = characters[characterId];
        uint256 hoursPassed = (block.timestamp - character.lastEnergyRefresh) / 3600;
        
        if (hoursPassed > 0) {
            uint256 energyToAdd = hoursPassed * energyPerHour;
            character.energy = min(character.energy + energyToAdd, maxEnergy);
            character.lastEnergyRefresh = block.timestamp;
        }
    }
    
    // 完成游戏任务，获得奖励
    function completeQuest(uint256 characterId, uint256 questDifficulty) external {
        Character storage character = characters[characterId];
        
        // 检查角色所有权
        require(character.owner == msg.sender, "不是角色所有者");
        
        // 刷新能量
        refreshEnergy(characterId);
        
        // 检查能量是否足够
        uint256 energyCost = questDifficulty * 5;
        require(character.energy >= energyCost, "能量不足");
        
        // 消耗能量
        character.energy -= energyCost;
        
        // 计算奖励
        uint256 expReward = questDifficulty * 100;
        uint256 tokenReward = questDifficulty * 10 * 10 ** 18;
        
        // 增加经验值
        character.experience += expReward;
        
        // 检查是否升级
        checkLevelUp(characterId);
        
        // 发放代币奖励
        require(gameToken.transfer(msg.sender, tokenReward), "发放奖励失败");
        
        // 有几率获得物品
        if (block.timestamp % 5 == 0) {
            // 随机生成物品ID
            uint256 itemId = (block.timestamp % 10) + 1;
            // 铸造物品
            gameItems.mintItem(msg.sender, itemId, 1, "", "", 0, 0, 100, GameItems.ItemType.WEAPON);
        }
    }
    
    // 检查角色是否升级
    function checkLevelUp(uint256 characterId) internal {
        Character storage character = characters[characterId];
        uint256 requiredExp = character.level * 1000;
        
        if (character.experience >= requiredExp) {
            character.level += 1;
            character.experience -= requiredExp;
            // 升级后恢复全部能量
            character.energy = maxEnergy;
        }
    }
    
    // 获取玩家的所有角色
    function getPlayerCharacters(address player) external view returns (uint256[] memory) {
        return playerCharacters[player];
    }
    
    // 辅助函数：取最小值
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

动态NFT与游戏状态

动态NFT（Dynamic NFT）可以根据游戏内的行为和状态自动改变其属性和外观。

// 动态NFT合约示例
contract DynamicNFT is ERC721URIStorage {
    // NFT状态结构
    struct NFTState {
        uint256 level;
        uint256 experience;
        uint256 lastUpdated;
        // 其他可动态变化的属性
    }
    
    // 存储NFT状态
    mapping(uint256 => NFTState) public nftStates;
    
    // 元数据生成器地址
    address public metadataGenerator;
    
    modifier onlyMetadataGenerator() {
        require(msg.sender == metadataGenerator, "只有元数据生成器可以调用");
        _;
    }
    
    constructor(address _metadataGenerator) ERC721("DynamicNFT", "DNFT") {
        metadataGenerator = _metadataGenerator;
    }
    
    // 铸造动态NFT
    function mintNFT(address to) external returns (uint256) {
        uint256 tokenId = totalSupply() + 1;
        
        // 初始化NFT状态
        nftStates[tokenId] = NFTState({
            level: 1,
            experience: 0,
            lastUpdated: block.timestamp
        });
        
        // 铸造NFT
        _mint(to, tokenId);
        
        // 生成初始元数据
        updateMetadata(tokenId);
        
        return tokenId;
    }
    
    // 更新NFT状态
    function updateNFTState(uint256 tokenId, uint256 expGain) external {
        NFTState storage state = nftStates[tokenId];
        
        // 更新经验值
        state.experience += expGain;
        state.lastUpdated = block.timestamp;
        
        // 检查是否升级
        uint256 requiredExp = state.level * 100;
        if (state.experience >= requiredExp) {
            state.level += 1;
            state.experience -= requiredExp;
        }
        
        // 更新元数据
        updateMetadata(tokenId);
    }
    
    // 更新NFT元数据
    function updateMetadata(uint256 tokenId) public {
        NFTState storage state = nftStates[tokenId];
        
        // 构建新的元数据URI
        string memory metadataURI = generateMetadataURI(tokenId, state.level, state.experience);
        
        // 更新tokenURI
        _setTokenURI(tokenId, metadataURI);
    }
    
    // 生成元数据URI（简化版）
    function generateMetadataURI(uint256 tokenId, uint256 level, uint256 experience) internal pure returns (string memory) {
        // 在实际应用中，这可能会调用外部服务来生成元数据
        return string(abi.encodePacked(
            "https://api.dynamicnft.com/metadata/",
            tokenId,
            "?level=",
            level,
            "&exp=",
            experience
        ));
    }
}

NFT与DeFi的融合（NFT-Fi）

NFT抵押借贷

NFT-Fi将NFT作为抵押品，实现基于NFT价值的借贷服务，为NFT持有者提供流动性。

// NFT抵押借贷合约示例
contract NFTLending {
    // 贷款结构
    struct Loan {
        uint256 loanId;
        address borrower;
        address lender;
        uint256 nftTokenId;
        address nftContract;
        uint256 amount;
        uint256 interestRate;
        uint256 duration;
        uint256 startTime;
        bool repaid;
        bool liquidated;
    }
    
    // 存储贷款信息
    mapping(uint256 => Loan) public loans;
    uint256 public nextLoanId = 1;
    
    // 支持的NFT合约
    mapping(address => bool) public supportedNFTContracts;
    
    // 只有管理员可以添加支持的NFT合约
    address public admin;
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "只有管理员可以调用");
        _;
    }
    
    constructor() {
        admin = msg.sender;
    }
    
    // 添加支持的NFT合约
    function addSupportedNFTContract(address nftContract) external onlyAdmin {
        supportedNFTContracts[nftContract] = true;
    }
    
    // 创建贷款请求
    function createLoanRequest(
        address nftContract,
        uint256 nftTokenId,
        uint256 desiredAmount,
        uint256 interestRate,
        uint256 durationDays
    ) external {
        // 验证NFT合约是否支持
        require(supportedNFTContracts[nftContract], "不支持的NFT合约");
        
        // 验证用户是否拥有NFT
        IERC721 nft = IERC721(nftContract);
        require(nft.ownerOf(nftTokenId) == msg.sender, "你不是NFT的所有者");
        
        // 批准合约转移NFT
        require(nft.getApproved(nftTokenId) == address(this), "请先批准合约转移NFT");
        
        // 创建贷款
        uint256 loanId = nextLoanId++;
        
        loans[loanId] = Loan({
            loanId: loanId,
            borrower: msg.sender,
            lender: address(0),
            nftTokenId: nftTokenId,
            nftContract: nftContract,
            amount: desiredAmount,
            interestRate: interestRate,
            duration: durationDays * 24 * 60 * 60, // 转换为秒
            startTime: 0,
            repaid: false,
            liquidated: false
        });
    }
    
    // 接受贷款请求
    function acceptLoanRequest(uint256 loanId) external payable {
        Loan storage loan = loans[loanId];
        
        // 验证贷款是否存在且未被接受
        require(loan.lender == address(0), "贷款已被接受");
        require(!loan.repaid && !loan.liquidated, "贷款已结束");
        
        // 验证贷款金额
        require(msg.value == loan.amount, "贷款金额不匹配");
        
        // 更新贷款信息
        loan.lender = msg.sender;
        loan.startTime = block.timestamp;
        
        // 转移NFT到合约保管
        IERC721 nft = IERC721(loan.nftContract);
        nft.safeTransferFrom(loan.borrower, address(this), loan.nftTokenId);
        
        // 转移贷款金额给借款人
        (bool success, ) = loan.borrower.call{value: msg.value}("");
        require(success, "贷款发放失败");
    }
    
    // 偿还贷款
    function repayLoan(uint256 loanId) external payable {
        Loan storage loan = loans[loanId];
        
        // 验证还款人是借款人
        require(msg.sender == loan.borrower, "只有借款人可以还款");
        require(!loan.repaid && !loan.liquidated, "贷款已结束");
        
        // 计算应还金额（本金+利息）
        uint256 interest = loan.amount * loan.interestRate / 100;
        uint256 totalRepayment = loan.amount + interest;
        
        // 验证还款金额
        require(msg.value >= totalRepayment, "还款金额不足");
        
        // 更新贷款状态
        loan.repaid = true;
        
        // 转移NFT回借款人
        IERC721 nft = IERC721(loan.nftContract);
        nft.safeTransferFrom(address(this), loan.borrower, loan.nftTokenId);
        
        // 转移还款给贷款人
        (bool success, ) = loan.lender.call{value: totalRepayment}("");
        require(success, "还款失败");
        
        // 退还超额还款
        if (msg.value > totalRepayment) {
            (success, ) = msg.sender.call{value: msg.value - totalRepayment}("");
            // 忽略小额退款失败
        }
    }
    
    // 贷款清算（逾期后由贷款人执行）
    function liquidateLoan(uint256 loanId) external {
        Loan storage loan = loans[loanId];
        
        // 验证清算人是贷款人
        require(msg.sender == loan.lender, "只有贷款人可以清算");
        require(!loan.repaid && !loan.liquidated, "贷款已结束");
        
        // 检查是否逾期
        require(block.timestamp > loan.startTime + loan.duration, "贷款尚未逾期");
        
        // 更新贷款状态
        loan.liquidated = true;
        
        // 将NFT转移给贷款人作为清算
        IERC721 nft = IERC721(loan.nftContract);
        nft.safeTransferFrom(address(this), loan.lender, loan.nftTokenId);
    }
}

NFT碎片化与流动性挖矿

NFT碎片化允许将高价NFT分割成多个可交易的部分，降低投资门槛并提高流动性。

// NFT碎片化合约示例
contract NFTFractionalization is ERC20 {
    // 碎片化的NFT信息
    address public nftContract;
    uint256 public nftTokenId;
    
    // 碎片化总量
    uint256 public totalFractions;
    
    // NFT当前状态
    enum NFTStatus {
        FRACTIONALIZED,
        REDEEMED,
        AUCTION
    }
    
    NFTStatus public nftStatus;
    
    // 拍卖相关信息
    uint256 public auctionStartTime;
    uint256 public auctionEndTime;
    uint256 public highestBid;
    address public highestBidder;
    
    // 合约管理员（NFT初始所有者）
    address public admin;
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "只有管理员可以调用");
        _;
    }
    
    constructor(
        address _nftContract,
        uint256 _nftTokenId,
        uint256 _totalFractions,
        string memory name,
        string memory symbol
    ) ERC20(name, symbol) {
        nftContract = _nftContract;
        nftTokenId = _nftTokenId;
        totalFractions = _totalFractions;
        admin = msg.sender;
        nftStatus = NFTStatus.FRACTIONALIZED;
        
        // 验证NFT所有权
        IERC721 nft = IERC721(nftContract);
        require(nft.ownerOf(nftTokenId) == msg.sender, "你不是NFT的所有者");
        
        // 铸造碎片化代币给管理员
        _mint(admin, totalFractions);
    }
    
    // 存入NFT到合约
    function depositNFT() external onlyAdmin {
        IERC721 nft = IERC721(nftContract);
        nft.safeTransferFrom(msg.sender, address(this), nftTokenId);
    }
    
    // 发起NFT赎回拍卖
    function startRedeemAuction(uint256 auctionDuration) external {
        require(nftStatus == NFTStatus.FRACTIONALIZED, "NFT不在碎片化状态");
        require(msg.sender == owner(), "只有合约所有者可以发起拍卖");
        
        nftStatus = NFTStatus.AUCTION;
        auctionStartTime = block.timestamp;
        auctionEndTime = block.timestamp + auctionDuration;
        highestBid = 0;
        highestBidder = address(0);
    }
    
    // 参与拍卖
    function placeBid() external payable {
        require(nftStatus == NFTStatus.AUCTION, "拍卖未开始");
        require(block.timestamp < auctionEndTime, "拍卖已结束");
        require(msg.value > highestBid, "出价低于当前最高价");
        
        // 退还之前最高出价者的资金
        if (highestBidder != address(0)) {
            (bool success, ) = highestBidder.call{value: highestBid}("");
            require(success, "退还出价失败");
        }
        
        // 更新最高出价
        highestBid = msg.value;
        highestBidder = msg.sender;
    }
    
    // 结束拍卖并赎回NFT
    function endAuction() external {
        require(nftStatus == NFTStatus.AUCTION, "拍卖未开始");
        require(block.timestamp >= auctionEndTime, "拍卖尚未结束");
        
        // 如果有出价，则完成赎回
        if (highestBidder != address(0)) {
            nftStatus = NFTStatus.REDEEMED;
            
            // 计算每个碎片化代币的价值
            uint256 fractionValue = highestBid / totalFractions;
            
            // 向所有代币持有者分发收益
            // 注意：实际实现中需要考虑gas优化，避免循环
            // ...
            
            // 转移NFT给最高出价者
            IERC721 nft = IERC721(nftContract);
            nft.safeTransferFrom(address(this), highestBidder, nftTokenId);
        } else {
            // 没有出价，恢复碎片化状态
            nftStatus = NFTStatus.FRACTIONALIZED;
        }
    }
}

NFT指数基金与投资组合

NFT指数基金允许投资者通过持有单一通证来获得多个NFT的价值敞口，分散投资风险。

// NFT指数基金合约示例
contract NFTIndexFund is ERC20 {
    // 基金管理团队
    address public fundManager;
    
    // 持仓NFT列表
    struct FundNFT {
        address nftContract;
        uint256 tokenId;
        uint256 acquisitionPrice;
        uint256 lastValuation;
    }
    
    FundNFT[] public portfolio;
    
    // 基金管理费
    uint256 public managementFee = 100; // 1%
    
    // 基金价值缓存
    uint256 public cachedNavPerShare;
    uint256 public lastNavUpdate;
    
    modifier onlyFundManager() {
        require(msg.sender == fundManager, "只有基金经理可以调用");
        _;
    }
    
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        fundManager = msg.sender;
    }
    
    // 申购基金份额
    function invest() external payable {
        // 计算可以申购的份额
        uint256 navPerShare = getNavPerShare();
        uint256 shares = msg.value / navPerShare;
        
        // 铸造份额给投资者
        _mint(msg.sender, shares);
    }
    
    // 赎回基金份额
    function redeem(uint256 shares) external {
        // 计算赎回金额
        uint256 navPerShare = getNavPerShare();
        uint256 redemptionAmount = shares * navPerShare;
        
        // 检查基金是否有足够的流动性
        require(address(this).balance >= redemptionAmount, "流动性不足");
        
        // 销毁份额
        _burn(msg.sender, shares);
        
        // 转移资金给投资者
        (bool success, ) = msg.sender.call{value: redemptionAmount}("");
        require(success, "赎回失败");
    }
    
    // 计算基金净值
    function getNavPerShare() public returns (uint256) {
        // 定期更新净值（例如每小时）
        if (block.timestamp > lastNavUpdate + 3600) {
            updateNav();
        }
        
        return cachedNavPerShare;
    }
    
    // 更新基金净值
    function updateNav() internal {
        // 计算总资产价值
        uint256 totalValue = address(this).balance;
        
        // 对持仓的每个NFT进行估值
        // 注意：实际实现中需要接入NFT估值服务
        for (uint256 i = 0; i < portfolio.length; i++) {
            // 简化示例：这里应该调用NFT估值API或Oracle
            uint256 nftValue = estimateNFTValue(portfolio[i].nftContract, portfolio[i].tokenId);
            totalValue += nftValue;
            portfolio[i].lastValuation = nftValue;
        }
        
        // 扣除管理费
        uint256 totalShares = totalSupply();
        if (totalShares > 0) {
            cachedNavPerShare = totalValue / totalShares;
        } else {
            cachedNavPerShare = 10 ** 18; // 初始净值设为1
        }
        
        lastNavUpdate = block.timestamp;
    }
    
    // 估算NFT价值（简化示例）
    function estimateNFTValue(address nftContract, uint256 tokenId) internal view returns (uint256) {
        // 实际应用中应该使用更复杂的估值模型
        // 这里只是一个简化的例子
        return 1000 * 10 ** 18; // 假设每个NFT价值1000 ETH
    }
    
    // 基金购买NFT
    function buyNFT(address nftContract, uint256 tokenId) external onlyFundManager {
        IERC721 nft = IERC721(nftContract);
        
        // 验证NFT是否存在
        require(nft.ownerOf(tokenId) != address(0), "NFT不存在");
        
        // 这里应该有更复杂的购买逻辑和价格协商
        // 简化示例：假设直接从当前所有者购买
        address owner = nft.ownerOf(tokenId);
        uint256 price = estimateNFTValue(nftContract, tokenId);
        
        // 转移资金
        (bool success, ) = owner.call{value: price}("");
        require(success, "购买NFT失败");
        
        // 等待NFT转移到合约
        // 实际应用中应该使用安全转账和回调机制
        
        // 将NFT添加到投资组合
        portfolio.push(FundNFT({
            nftContract: nftContract,
            tokenId: tokenId,
            acquisitionPrice: price,
            lastValuation: price
        }));
    }
    
    // 基金出售NFT
    function sellNFT(uint256 index) external onlyFundManager {
        require(index < portfolio.length, "索引无效");
        
        FundNFT storage nft = portfolio[index];
        IERC721 nftContract = IERC721(nft.nftContract);
        
        // 这里应该有更复杂的出售逻辑
        // 简化示例：假设以当前估值出售
        uint256 price = nft.lastValuation;
        address buyer = findNFTSeller(price);
        
        // 转移NFT
        nftContract.safeTransferFrom(address(this), buyer, nft.tokenId);
        
        // 接收资金
        // 实际应用中应该使用安全转账和回调机制
        
        // 从投资组合中移除NFT
        portfolio[index] = portfolio[portfolio.length - 1];
        portfolio.pop();
    }
    
    // 寻找NFT买家（简化示例）
    function findNFTSeller(uint256 price) internal pure returns (address) {
        // 实际应用中应该有更复杂的机制
        // 这里只是一个简化的例子
        return address(0x1234567890123456789012345678901234567890);
    }
}

NFT与DAO治理

NFT作为治理通证

NFT可以作为独特的治理通证，为持有者提供参与社区决策的权利，同时保持持有者的独特身份。

// NFT治理合约示例
contract NFTGovernance is ERC721URIStorage {
    // 提案结构
    struct Proposal {
        uint256 id;
        string description;
        address proposer;
        uint256 startTime;
        uint256 endTime;
        uint256 forVotes;
        uint256 againstVotes;
        bool executed;
        mapping(address => bool) hasVoted;
    }
    
    // 存储提案
    mapping(uint256 => Proposal) public proposals;
    uint256 public nextProposalId = 1;
    
    // 投票持续时间（秒）
    uint256 public votingPeriod = 7 * 24 * 60 * 60; // 7天
    
    // 创建NFT治理合约
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
    
    // 铸造治理NFT
    function mintGovernanceNFT(address to, string calldata uri) external {
        // 实际应用中应该有更严格的铸造限制
        uint256 tokenId = totalSupply() + 1;
        _mint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }
    
    // 创建提案
    function createProposal(string calldata description) external {
        // 验证创建者是否持有治理NFT
        require(balanceOf(msg.sender) > 0, "你必须持有治理NFT才能创建提案");
        
        uint256 proposalId = nextProposalId++;
        Proposal storage proposal = proposals[proposalId];
        
        proposal.id = proposalId;
        proposal.description = description;
        proposal.proposer = msg.sender;
        proposal.startTime = block.timestamp;
        proposal.endTime = block.timestamp + votingPeriod;
        proposal.forVotes = 0;
        proposal.againstVotes = 0;
        proposal.executed = false;
    }
    
    // 投票
    function vote(uint256 proposalId, bool support) external {
        Proposal storage proposal = proposals[proposalId];
        
        // 验证提案是否存在
        require(proposal.id == proposalId, "提案不存在");
        
        // 验证投票是否在有效期内
        require(block.timestamp >= proposal.startTime, "投票尚未开始");
        require(block.timestamp <= proposal.endTime, "投票已结束");
        
        // 验证投票人是否持有治理NFT
        require(balanceOf(msg.sender) > 0, "你必须持有治理NFT才能投票");
        
        // 验证投票人是否已经投票
        require(!proposal.hasVoted[msg.sender], "你已经投过票了");
        
        // 记录投票
        proposal.hasVoted[msg.sender] = true;
        
        // 计算投票权重（每个NFT代表1票）
        uint256 voteWeight = balanceOf(msg.sender);
        
        // 统计票数
        if (support) {
            proposal.forVotes += voteWeight;
        } else {
            proposal.againstVotes += voteWeight;
        }
    }
    
    // 执行提案
    function executeProposal(uint256 proposalId) external {
        Proposal storage proposal = proposals[proposalId];
        
        // 验证提案是否存在
        require(proposal.id == proposalId, "提案不存在");
        
        // 验证投票是否结束
        require(block.timestamp > proposal.endTime, "投票尚未结束");
        
        // 验证提案是否已执行
        require(!proposal.executed, "提案已执行");
        
        // 验证提案是否通过
        require(proposal.forVotes > proposal.againstVotes, "提案未通过");
        
        // 标记提案为已执行
        proposal.executed = true;
        
        // 这里应该包含提案执行的具体逻辑
        // 实际应用中可能会调用外部合约或执行其他操作
        executeProposalLogic(proposal.description);
    }
    
    // 执行提案逻辑（简化示例）
    function executeProposalLogic(string calldata description) internal {
        // 实际应用中应该有更复杂的提案执行逻辑
        // 这里只是一个简化的例子
        emit ProposalExecuted(description);
    }
    
    // 事件定义
    event ProposalExecuted(string description);
}

收藏者DAO与策展治理

收藏者DAO允许NFT收藏者通过集体决策来管理和策展共同的NFT收藏。

// 收藏者DAO合约示例
contract CollectorsDAO {
    // DAO成员结构
    struct Member {
        address account;
        uint256 membershipTokens;
        uint256 joinedAt;
    }
    
    // 收藏的NFT结构
    struct CollectionNFT {
        address nftContract;
        uint256 tokenId;
        uint256 acquisitionPrice;
        uint256 acquiredAt;
    }
    
    // DAO成员列表
    Member[] public members;
    mapping(address => uint256) public memberIndex;
    
    // DAO收藏的NFT列表
    CollectionNFT[] public collection;
    
    // DAO治理参数
    uint256 public quorum = 50; // 50%
    uint256 public votingPeriod = 3 * 24 * 60 * 60; // 3天
    uint256 public proposalThreshold = 1000 * 10 ** 18; // 提案所需代币数量
    
    // 提案结构
    struct Proposal {
        uint256 id;
        string description;
        address proposer;
        uint256 startTime;
        uint256 endTime;
        uint256 forVotes;
        uint256 againstVotes;
        bool executed;
        ProposalType proposalType;
        // 购买NFT提案的额外信息
        address targetNFTContract;
        uint256 targetTokenId;
        uint256 proposedPrice;
        // 出售NFT提案的额外信息
        uint256 collectionIndex;
        uint256 minimumPrice;
        // 投票记录
        mapping(address => bool) hasVoted;
    }
    
    // 提案类型
    enum ProposalType {
        BUY_NFT,
        SELL_NFT,
        CHANGE_PARAMS,
        OTHER
    }
    
    // 存储提案
    mapping(uint256 => Proposal) public proposals;
    uint256 public nextProposalId = 1;
    
    // DAO代币（用于治理和投票）
    IERC20 public daoToken;
    
    // 创建收藏者DAO
    constructor(address _daoToken) {
        daoToken = IERC20(_daoToken);
    }
    
    // 加入DAO
    function joinDAO(uint256 tokenAmount) external {
        // 转移DAO代币到合约
        require(daoToken.transferFrom(msg.sender, address(this), tokenAmount), "代币转账失败");
        
        // 检查是否已经是成员
        if (memberIndex[msg.sender] == 0) {
            // 新成员
            members.push(Member({
                account: msg.sender,
                membershipTokens: tokenAmount,
                joinedAt: block.timestamp
            }));
            memberIndex[msg.sender] = members.length;
        } else {
            // 现有成员增加持股
            members[memberIndex[msg.sender] - 1].membershipTokens += tokenAmount;
        }
    }
    
    // 创建购买NFT的提案
    function proposeBuyNFT(address nftContract, uint256 tokenId, uint256 price) external {
        // 验证提案者是否持有足够的DAO代币
        uint256 proposerTokens = getMemberTokens(msg.sender);
        require(proposerTokens >= proposalThreshold, "代币数量不足，无法创建提案");
        
        uint256 proposalId = nextProposalId++;
        Proposal storage proposal = proposals[proposalId];
        
        proposal.id = proposalId;
        proposal.description = string(abi.encodePacked("购买NFT: 合约=", nftContract, ", ID=", tokenId, ", 价格=", price));
        proposal.proposer = msg.sender;
        proposal.startTime = block.timestamp;
        proposal.endTime = block.timestamp + votingPeriod;
        proposal.forVotes = 0;
        proposal.againstVotes = 0;
        proposal.executed = false;
        proposal.proposalType = ProposalType.BUY_NFT;
        proposal.targetNFTContract = nftContract;
        proposal.targetTokenId = tokenId;
        proposal.proposedPrice = price;
    }
    
    // 创建出售NFT的提案
    function proposeSellNFT(uint256 index, uint256 minimumPrice) external {
        // 验证提案者是否持有足够的DAO代币
        uint256 proposerTokens = getMemberTokens(msg.sender);
        require(proposerTokens >= proposalThreshold, "代币数量不足，无法创建提案");
        
        // 验证NFT索引是否有效
        require(index < collection.length, "NFT索引无效");
        
        uint256 proposalId = nextProposalId++;
        Proposal storage proposal = proposals[proposalId];
        
        CollectionNFT storage nft = collection[index];
        
        proposal.id = proposalId;
        proposal.description = string(abi.encodePacked("出售NFT: 合约=", nft.nftContract, ", ID=", nft.tokenId, ", 最低价格=", minimumPrice));
        proposal.proposer = msg.sender;
        proposal.startTime = block.timestamp;
        proposal.endTime = block.timestamp + votingPeriod;
        proposal.forVotes = 0;
        proposal.againstVotes = 0;
        proposal.executed = false;
        proposal.proposalType = ProposalType.SELL_NFT;
        proposal.collectionIndex = index;
        proposal.minimumPrice = minimumPrice;
    }
    
    // 投票
    function vote(uint256 proposalId, bool support) external {
        Proposal storage proposal = proposals[proposalId];
        
        // 验证提案是否存在
        require(proposal.id == proposalId, "提案不存在");
        
        // 验证投票是否在有效期内
        require(block.timestamp >= proposal.startTime, "投票尚未开始");
        require(block.timestamp <= proposal.endTime, "投票已结束");
        
        // 验证投票人是否是DAO成员
        uint256 voterTokens = getMemberTokens(msg.sender);
        require(voterTokens > 0, "你不是DAO成员");
        
        // 验证投票人是否已经投票
        require(!proposal.hasVoted[msg.sender], "你已经投过票了");
        
        // 记录投票
        proposal.hasVoted[msg.sender] = true;
        
        // 计算投票权重（基于持有代币数量）
        uint256 voteWeight = voterTokens;
        
        // 统计票数
        if (support) {
            proposal.forVotes += voteWeight;
        } else {
            proposal.againstVotes += voteWeight;
        }
    }
    
    // 执行提案
    function executeProposal(uint256 proposalId) external {
        Proposal storage proposal = proposals[proposalId];
        
        // 验证提案是否存在
        require(proposal.id == proposalId, "提案不存在");
        
        // 验证投票是否结束
        require(block.timestamp > proposal.endTime, "投票尚未结束");
        
        // 验证提案是否已执行
        require(!proposal.executed, "提案已执行");
        
        // 验证投票是否达到法定人数
        uint256 totalVotingPower = getTotalVotingPower();
        uint256 quorumRequired = totalVotingPower * quorum / 100;
        require(proposal.forVotes + proposal.againstVotes >= quorumRequired, "未达到法定人数");
        
        // 验证提案是否通过
        require(proposal.forVotes > proposal.againstVotes, "提案未通过");
        
        // 标记提案为已执行
        proposal.executed = true;
        
        // 根据提案类型执行不同的逻辑
        if (proposal.proposalType == ProposalType.BUY_NFT) {
            executeBuyNFTProposal(proposal);
        } else if (proposal.proposalType == ProposalType.SELL_NFT) {
            executeSellNFTProposal(proposal);
        } else if (proposal.proposalType == ProposalType.CHANGE_PARAMS) {
            executeChangeParamsProposal(proposal);
        }
    }
    
    // 执行购买NFT提案
    function executeBuyNFTProposal(Proposal storage proposal) internal {
        // 验证合约余额是否足够
        require(address(this).balance >= proposal.proposedPrice, "DAO资金不足");
        
        // 这里应该有更复杂的NFT购买逻辑
        // 简化示例：假设直接从当前所有者购买
        IERC721 nft = IERC721(proposal.targetNFTContract);
        address owner = nft.ownerOf(proposal.targetTokenId);
        
        // 转移资金
        (bool success, ) = owner.call{value: proposal.proposedPrice}("");
        require(success, "购买NFT失败");
        
        // 等待NFT转移到合约
        // 实际应用中应该使用安全转账和回调机制
        
        // 将NFT添加到收藏
        collection.push(CollectionNFT({
            nftContract: proposal.targetNFTContract,
            tokenId: proposal.targetTokenId,
            acquisitionPrice: proposal.proposedPrice,
            acquiredAt: block.timestamp
        }));
    }
    
    // 执行出售NFT提案
    function executeSellNFTProposal(Proposal storage proposal) internal {
        // 验证NFT索引是否有效
        require(proposal.collectionIndex < collection.length, "NFT索引无效");
        
        CollectionNFT storage nft = collection[proposal.collectionIndex];
        IERC721 nftContract = IERC721(nft.nftContract);
        
        // 这里应该有更复杂的NFT出售逻辑
        // 简化示例：假设以提议的最低价格出售给买家
        address buyer = findNFTSeller(proposal.minimumPrice);
        
        // 转移NFT
        nftContract.safeTransferFrom(address(this), buyer, nft.tokenId);
        
        // 接收资金
        // 实际应用中应该使用安全转账和回调机制
        
        // 从收藏中移除NFT
        collection[proposal.collectionIndex] = collection[collection.length - 1];
        collection.pop();
    }
    
    // 获取成员持有的代币数量
    function getMemberTokens(address member) internal view returns (uint256) {
        if (memberIndex[member] == 0) {
            return 0;
        }
        return members[memberIndex[member] - 1].membershipTokens;
    }
    
    // 获取总投票权
    function getTotalVotingPower() internal view returns (uint256) {
        uint256 total = 0;
        for (uint256 i = 0; i < members.length; i++) {
            total += members[i].membershipTokens;
        }
        return total;
    }
    
    // 寻找NFT买家（简化示例）
    function findNFTSeller(uint256 minimumPrice) internal pure returns (address) {
        // 实际应用中应该有更复杂的机制
        return address(0x1234567890123456789012345678901234567890);
    }
    
    // 接收资金
    receive() external payable {}
}

NFT与IP知识产权

NFT在知识产权保护中的应用

NFT为数字内容创作者提供了一种新的知识产权保护和管理方式。

数字内容确权与追踪

NFT可以为数字艺术品、音乐、文学作品等提供独特的身份证明和所有权记录。

// IP保护NFT合约示例
contract IPNFT is ERC721URIStorage {
    // IP元数据结构
    struct IPDetails {
        string title;
        string creator;
        string creationDate;
        string description;
        string contentType;
        string originalHash; // 原始内容哈希
        string[] licensingTerms;
        bool registeredWithCopyrightOffice;
    }
    
    // 存储IP详情
    mapping(uint256 => IPDetails) public ipDetails;
    
    // 存储内容哈希到NFT ID的映射（用于查重）
    mapping(string => uint256) public contentHashToTokenId;
    
    // 只有获得授权的创作者可以铸造NFT
    mapping(address => bool) public authorizedCreators;
    
    // 合约管理员
    address public admin;
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "只有管理员可以调用");
        _;
    }
    
    modifier onlyAuthorizedCreator() {
        require(authorizedCreators[msg.sender], "你不是授权创作者");
        _;
    }
    
    constructor() ERC721("IPNFT", "IPNFT") {
        admin = msg.sender;
        // 初始授权管理员为创作者
        authorizedCreators[msg.sender] = true;
    }
    
    // 授权创作者
    function authorizeCreator(address creator) external onlyAdmin {
        authorizedCreators[creator] = true;
    }
    
    // 撤销创作者授权
    function revokeCreator(address creator) external onlyAdmin {
        authorizedCreators[creator] = false;
    }
    
    // 铸造IP NFT
    function mintIPNFT(
        string calldata title,
        string calldata description,
        string calldata contentType,
        string calldata originalHash,
        string[] calldata licensingTerms,
        bool registeredWithCopyrightOffice,
        string calldata metadataURI
    ) external onlyAuthorizedCreator {
        // 检查内容是否已经存在
        require(contentHashToTokenId[originalHash] == 0, "内容已存在");
        
        uint256 tokenId = totalSupply() + 1;
        
        // 存储IP详情
        ipDetails[tokenId] = IPDetails({
            title: title,
            creator: msg.sender,
            creationDate: block.timestamp.toString(),
            description: description,
            contentType: contentType,
            originalHash: originalHash,
            licensingTerms: licensingTerms,
            registeredWithCopyrightOffice: registeredWithCopyrightOffice
        });
        
        // 记录内容哈希映射
        contentHashToTokenId[originalHash] = tokenId;
        
        // 铸造NFT
        _mint(msg.sender, tokenId);
        _setTokenURI(tokenId, metadataURI);
    }
    
    // 验证内容所有权
    function verifyContentOwnership(string calldata contentHash) external view returns (bool, address, uint256) {
        uint256 tokenId = contentHashToTokenId[contentHash];
        if (tokenId == 0) {
            return (false, address(0), 0);
        }
        return (true, ownerOf(tokenId), tokenId);
    }
    
    // 添加许可条款
    function addLicensingTerm(uint256 tokenId, string calldata term) external {
        require(ownerOf(tokenId) == msg.sender, "只有NFT所有者可以添加许可条款");
        ipDetails[tokenId].licensingTerms.push(term);
    }
}

自动化版税与收益管理

NFT可以实现创作者版税的自动计算和分配，确保创作者从后续销售中持续获得收益。

// 支持创作者版税的NFT合约示例
contract RoyaltyNFT is ERC721URIStorage {
    // 版税结构
    struct RoyaltyInfo {
        address receiver;
        uint256 royaltyPercentage; // 0-10000，表示0-100%
    }
    
    // 存储每个NFT的版税信息
    mapping(uint256 => RoyaltyInfo) public royaltyInfo;
    
    // 合约管理员
    address public admin;
    
    // 支持EIP-2981标准
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
    }
    
    constructor() ERC721("RoyaltyNFT", "RNFT") {
        admin = msg.sender;
    }
    
    // 铸造带版税的NFT
    function mintWithRoyalty(address to, uint256 tokenId, string calldata uri, address royaltyReceiver, uint256 royaltyPercentage) external {
        // 验证版税比例是否有效（最大100%）
        require(royaltyPercentage <= 10000, "版税比例过高");
        
        // 存储版税信息
        royaltyInfo[tokenId] = RoyaltyInfo({
            receiver: royaltyReceiver,
            royaltyPercentage: royaltyPercentage
        });
        
        // 铸造NFT
        _mint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }
    
    // 实现EIP-2981的royaltyInfo方法
    function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount) {
        RoyaltyInfo memory info = royaltyInfo[tokenId];
        return (
            info.receiver,
            salePrice * info.royaltyPercentage / 10000
        );
    }
    
    // 更新版税接收者
    function updateRoyaltyReceiver(uint256 tokenId, address newReceiver) external {
        require(royaltyInfo[tokenId].receiver == msg.sender, "只有当前版税接收者可以更新");
        royaltyInfo[tokenId].receiver = newReceiver;
    }
}

// EIP-2981接口定义
interface IERC2981 {
    function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount);
}

NFT许可证与使用协议管理

NFT可以代表特定内容的使用许可，实现灵活的数字内容授权管理。

// NFT许可证合约示例
contract NFTLicense is ERC721URIStorage {
    // 许可证类型
    enum LicenseType {
        PERSONAL,
        COMMERCIAL,
        EXCLUSIVE,
        SUBSCRIPTION
    }
    
    // 许可证结构
    struct License {
        uint256 id;
        address licensedContentOwner;
        address nftContract;
        uint256 nftTokenId;
        LicenseType licenseType;
        uint256 startTime;
        uint256 duration; // 秒，如果为0则永久有效
        uint256 maxUsageCount; // 最大使用次数，如果为0则无限制
        uint256 usageCount;
        string[] restrictions;
        bool revoked;
    }
    
    // 存储许可证
    mapping(uint256 => License) public licenses;
    uint256 public nextLicenseId = 1;
    
    // 合约管理员
    address public admin;
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "只有管理员可以调用");
        _;
    }
    
    constructor() ERC721("NFTLicense", "NLIC") {
        admin = msg.sender;
    }
    
    // 创建许可证NFT
    function createLicense(
        address licensedContentOwner,
        address nftContract,
        uint256 nftTokenId,
        LicenseType licenseType,
        uint256 duration,
        uint256 maxUsageCount,
        string[] calldata restrictions
    ) external {
        // 验证NFT是否存在
        IERC721 nft = IERC721(nftContract);
        require(nft.ownerOf(nftTokenId) == licensedContentOwner, "NFT所有者不匹配");
        
        uint256 licenseId = nextLicenseId++;
        
        // 创建许可证
        licenses[licenseId] = License({
            id: licenseId,
            licensedContentOwner: licensedContentOwner,
            nftContract: nftContract,
            nftTokenId: nftTokenId,
            licenseType: licenseType,
            startTime: block.timestamp,
            duration: duration,
            maxUsageCount: maxUsageCount,
            usageCount: 0,
            restrictions: restrictions,
            revoked: false
        });
        
        // 铸造许可证NFT
        _mint(msg.sender, licenseId);
        
        // 生成并设置许可证元数据URI
        string memory metadataURI = generateLicenseMetadata(licenseId);
        _setTokenURI(licenseId, metadataURI);
    }
    
    // 使用许可证
    function useLicense(uint256 licenseId) external returns (bool) {
        License storage license = licenses[licenseId];
        
        // 验证许可证是否由调用者持有
        require(ownerOf(licenseId) == msg.sender, "你不是许可证持有者");
        
        // 验证许可证是否有效
        if (license.revoked) {
            return false;
        }
        
        // 验证许可证是否过期
        if (license.duration > 0 && block.timestamp > license.startTime + license.duration) {
            return false;
        }
        
        // 验证使用次数限制
        if (license.maxUsageCount > 0 && license.usageCount >= license.maxUsageCount) {
            return false;
        }
        
        // 增加使用次数
        license.usageCount += 1;
        
        // 触发使用事件
        emit LicenseUsed(licenseId, msg.sender);
        
        return true;
    }
    
    // 检查许可证是否有效
    function isLicenseValid(uint256 licenseId) external view returns (bool) {
        License storage license = licenses[licenseId];
        
        if (license.revoked) {
            return false;
        }
        
        if (license.duration > 0 && block.timestamp > license.startTime + license.duration) {
            return false;
        }
        
        if (license.maxUsageCount > 0 && license.usageCount >= license.maxUsageCount) {
            return false;
        }
        
        return true;
    }
    
    // 撤销许可证
    function revokeLicense(uint256 licenseId) external {
        License storage license = licenses[licenseId];
        
        // 只有内容所有者或管理员可以撤销许可证
        require(msg.sender == license.licensedContentOwner || msg.sender == admin, "无权撤销许可证");
        
        license.revoked = true;
        
        // 触发撤销事件
        emit LicenseRevoked(licenseId);
    }
    
    // 生成许可证元数据（简化版）
    function generateLicenseMetadata(uint256 licenseId) internal view returns (string memory) {
        License storage license = licenses[licenseId];
        
        // 在实际应用中，这应该生成一个完整的JSON元数据
        return string(abi.encodePacked(
            "https://api.nftlicense.com/license/",
            licenseId
        ));
    }
    
    // 事件定义
    event LicenseUsed(uint256 indexed licenseId, address indexed user);
    event LicenseRevoked(uint256 indexed licenseId);
}

总结

NFT技术正在迅速发展和演进，从最初的数字艺术品扩展到了更广泛的应用领域，包括元宇宙、游戏、DeFi、DAO治理和知识产权保护等。随着技术的不断创新，NFT将继续打破传统行业的边界，为数字世界带来更多可能性。作为开发者，了解和掌握NFT的高级应用和创新技术，将有助于在这个快速发展的领域中保持竞争力，开发出更具创新性和实用性的NFT应用。