《醉乡民谣》与NFT音乐：民谣作为链上音乐NFT

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

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

/**
 * @title 音乐NFT合约
 */
contract MusicNFT is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    struct Song {
        uint256 tokenId;
        string title;
        string artist;
        string album;
        string ipfsHash;
        uint256 releaseYear;
        uint256 royaltyPercent;
        address creator;
        uint256 totalSales;
    }
    
    mapping(uint256 => Song) public songs;
    mapping(uint256 => uint256) public salePrices;
    mapping(address => uint256[]) public artistSongs;
    
    event SongMinted(uint256 indexed tokenId, string title, address artist);
    event SongSold(uint256 indexed tokenId, address buyer, uint256 price);
    
    constructor() ERC721("FolkMusicNFT", "FOLK") {}
    
    function mintSong(
        string memory title,
        string memory artist,
        string memory album,
        string memory ipfsHash,
        uint256 releaseYear,
        uint256 royaltyPercent
    ) external returns (uint256) {
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();
        
        _safeMint(msg.sender, newTokenId);
        songs[newTokenId] = Song({
            tokenId: newTokenId,
            title: title,
            artist: artist,
            album: album,
            ipfsHash: ipfsHash,
            releaseYear: releaseYear,
            royaltyPercent: royaltyPercent,
            creator: msg.sender,
            totalSales: 0
        });
        artistSongs[msg.sender].push(newTokenId);
        
        emit SongMinted(newTokenId, title, msg.sender);
        return newTokenId;
    }
    
    function buySong(uint256 tokenId) external payable {
        address seller = ownerOf(tokenId);
        uint256 price = salePrices[tokenId];
        require(msg.value >= price, "Insufficient payment");
        
        uint256 royalty = price * songs[tokenId].royaltyPercent / 10000;
        uint256 sellerProceeds = price - royalty;
        
        payable(songs[tokenId].creator).transfer(royalty);
        payable(seller).transfer(sellerProceeds);
        _transfer(seller, msg.sender, tokenId);
        
        songs[tokenId].totalSales++;
        emit SongSold(tokenId, msg.sender, price);
    }
    
    function setSalePrice(uint256 tokenId, uint256 price) external {
        require(ownerOf(tokenId) == msg.sender, "Not owner");
        salePrices[tokenId] = price;
    }
}

from typing import Dict, List
import json

class MusicNFTAnalyzer:
    """音乐NFT分析"""
    
    def analyze_artist_performance(self, songs: List[Dict]) -> Dict:
        """分析艺术家表现"""
        total_sales = sum(s.get('total_sales', 0) for s in songs)
        total_revenue = sum(s.get('revenue', 0) for s in songs)
        return {
            'total_songs': len(songs),
            'total_sales': total_sales,
            'total_revenue': total_revenue,
            'avg_price_per_song': total_revenue / max(len(songs), 1)
        }
    
    def calculate_royalty_distribution(self, sales: List[Dict]) -> Dict:
        """计算版税分布"""
        total = sum(s['price'] for s in sales)
        royalties = sum(s['price'] * s['royalty_percent'] / 10000 for s in sales)
        return {
            'total_volume': total,
            'total_royalties': royalties,
            'avg_royalty_rate': royalties / total if total > 0 else 0
        }

analyzer = MusicNFTAnalyzer()

const ethers = require('ethers');

class MusicMarketplace {
  constructor(contractAddress, providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.contract = new ethers.Contract(contractAddress, MusicNFTABI, this.provider);
  }

  async getSongDetails(tokenId) {
    const song = await this.contract.songs(tokenId);
    return song;
  }

  async getArtistSongs(address) {
    const count = await this.contract.getArtistSongCount(address);
    const songs = [];
    for (let i = 0; i < count.toNumber(); i++) {
      const id = await this.contract.artistSongs(address, i);
      const song = await this.contract.songs(id);
      songs.push(song);
    }
    return songs;
  }
}

const marketplace = new MusicMarketplace('0xContractAddress', 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');