AI与电影海报：机器学习生成海报的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 PosterNFT is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;
    
    struct Poster {
        uint256 tokenId;
        string filmTitle;
        string designer;
        string aiModel;
        string prompt;
        string ipfsHash;
        uint256 timestamp;
        uint256 royaltyPercent;
        address creator;
    }
    
    mapping(uint256 => Poster) public posters;
    mapping(uint256 => uint256) public listingPrices;
    
    event PosterMinted(uint256 indexed tokenId, string filmTitle, address creator);
    event PosterSold(uint256 indexed tokenId, address buyer, uint256 price);
    
    constructor() ERC721("PosterNFT", "POSTER") {}
    
    function mintPoster(
        string memory filmTitle,
        string memory designer,
        string memory aiModel,
        string memory prompt,
        string memory ipfsHash,
        uint256 royaltyPercent
    ) external returns (uint256) {
        _tokenIds.increment();
        uint256 newTokenId = _tokenIds.current();
        
        _safeMint(msg.sender, newTokenId);
        posters[newTokenId] = Poster({
            tokenId: newTokenId,
            filmTitle: filmTitle,
            designer: designer,
            aiModel: aiModel,
            prompt: prompt,
            ipfsHash: ipfsHash,
            timestamp: block.timestamp,
            royaltyPercent: royaltyPercent,
            creator: msg.sender
        });
        
        emit PosterMinted(newTokenId, filmTitle, msg.sender);
        return newTokenId;
    }
    
    function buyPoster(uint256 tokenId) external payable {
        address seller = ownerOf(tokenId);
        uint256 price = listingPrices[tokenId];
        require(msg.value >= price, "Insufficient payment");
        
        uint256 royalty = price * posters[tokenId].royaltyPercent / 10000;
        uint256 sellerProceeds = price - royalty;
        
        payable(posters[tokenId].creator).transfer(royalty);
        payable(seller).transfer(sellerProceeds);
        _transfer(seller, msg.sender, tokenId);
        
        emit PosterSold(tokenId, msg.sender, price);
    }
}

from typing import Dict, List
import json
import hashlib

class AIPosterGenerator:
    """AI海报生成器"""
    
    def __init__(self):
        self.styles = ['minimal', 'vintage', 'modern', 'noir', 'retro']
        
    def generate_prompt(self, film_title: str, genre: str, mood: str, style: str) -> str:
        """生成AI海报提示词"""
        return f"Movie poster for '{film_title}', {genre} genre, {mood} mood, {style} style, cinematic lighting, text 'NOW IN THEATERS'"
    
    def generate_poster_hash(self, prompt: str, params: Dict) -> str:
        """生成海报的哈希标识"""
        data = json.dumps({'prompt': prompt, 'params': params}, sort_keys=True)
        return hashlib.sha256(data.encode()).hexdigest()
    
    def batch_generate(self, films: List[Dict]) -> List[Dict]:
        """批量生成海报"""
        posters = []
        for film in films:
            prompt = self.generate_prompt(
                film['title'],
                film['genre'],
                film['mood'],
                film.get('style', 'modern')
            )
            hash_id = self.generate_poster_hash(prompt, film)
            posters.append({
                'film_title': film['title'],
                'prompt': prompt,
                'hash': hash_id,
                'timestamp': __import__('datetime').datetime.now().isoformat()
            })
        return posters

generator = AIPosterGenerator()
posters = generator.batch_generate([
    {'title': 'The Algorithm', 'genre': 'sci-fi', 'mood': 'dark'},
    {'title': 'Digital Love', 'genre': 'romance', 'mood': 'warm'}
])
print(json.dumps(posters, indent=2))

class PosterGallery {
  constructor(contractAddress, providerUrl) {
    this.contract = new ethers.Contract(contractAddress, PosterNFTABI,
      new ethers.providers.JsonRpcProvider(providerUrl));
  }

  async getPosterDetails(tokenId) {
    const poster = await this.contract.posters(tokenId);
    return poster;
  }

  async getCollection(address) {
    const balance = await this.contract.balanceOf(address);
    const posters = [];
    for (let i = 0; i < balance.toNumber(); i++) {
      const tokenId = await this.contract.tokenOfOwnerByIndex(address, i);
      const poster = await this.contract.posters(tokenId);
      posters.push(poster);
    }
    return posters;
  }
}

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