AI与电影角色生成：机器学习角色的NFT化

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract AIGeneratedCharacter is ERC721URIStorage, Ownable, ReentrancyGuard {
    using Counters for Counters.Counter;
    
    Counters.Counter private _characterIds;
    
    struct Character {
        uint256 id;
        string name;
        string role; // "protagonist", "antagonist", "supporting", "extra"
        string genre;
        uint256 generationTimestamp;
        string aiModel; // 生成角色的AI模型名称
        string modelVersion;
        string trainingData; // IPFS哈希，指向训练数据
        string traits; // IPFS哈希，指向角色特征JSON
        uint256 rarityScore;
        address creator;
        uint256 licensingFee;
        bool isLicensed;
        uint256 totalUsageCount;
    }
    
    struct CharacterAttribute {
        string attributeName;
        string attributeValue;
        uint256 score;
    }
    
    struct LicensingAgreement {
        address licensee;
        uint256 characterId;
        string projectName;
        uint256 fee;
        uint256 startDate;
        uint256 endDate;
        bool isActive;
    }
    
    mapping(uint256 => Character) public characters;
    mapping(uint256 => CharacterAttribute[]) public characterAttributes;
    mapping(uint256 => LicensingAgreement[]) public licensingHistory;
    mapping(address => uint256[]) public creatorCharacters;
    mapping(bytes32 => bool) public usedHashes; // 防止重复生成
    
    uint256 public constant MAX_CHARACTERS = 10000;
    uint256 public constant MIN_LICENSING_FEE = 0.01 ether;
    uint256 public constant CREATOR_ROYALTY = 500; // 5%
    
    event CharacterCreated(
        uint256 indexed characterId,
        string name,
        string role,
        address indexed creator,
        uint256 rarityScore
    );
    event CharacterLicensed(
        uint256 indexed characterId,
        address indexed licensee,
        string projectName,
        uint256 fee
    );
    event CharacterUsed(uint256 indexed characterId, string projectName);
    
    constructor() ERC721("AIGeneratedCharacter", "AIGC") {}
    
    function createCharacter(
        string memory _name,
        string memory _role,
        string memory _genre,
        string memory _aiModel,
        string memory _modelVersion,
        string memory _trainingData,
        string memory _traits,
        string memory _tokenURI,
        uint256 _licensingFee
    ) external returns (uint256) {
        require(_characterIds.current() < MAX_CHARACTERS, "Max characters reached");
        require(bytes(_name).length > 0, "Name required");
        require(_licensingFee >= MIN_LICENSING_FEE, "Fee too low");
        
        // 防止重复生成
        bytes32 hash = keccak256(abi.encodePacked(_name, _traits, msg.sender));
        require(!usedHashes[hash], "Character already exists");
        usedHashes[hash] = true;
        
        _characterIds.increment();
        uint256 newId = _characterIds.current();
        
        // 计算稀有度评分
        uint256 rarityScore = calculateRarityScore(
            _role, _genre, _aiModel, _traits
        );
        
        characters[newId] = Character({
            id: newId,
            name: _name,
            role: _role,
            genre: _genre,
            generationTimestamp: block.timestamp,
            aiModel: _aiModel,
            modelVersion: _modelVersion,
            trainingData: _trainingData,
            traits: _traits,
            rarityScore: rarityScore,
            creator: msg.sender,
            licensingFee: _licensingFee,
            isLicensed: false,
            totalUsageCount: 0
        });
        
        creatorCharacters[msg.sender].push(newId);
        
        _safeMint(msg.sender, newId);
        _setTokenURI(newId, _tokenURI);
        
        emit CharacterCreated(newId, _name, _role, msg.sender, rarityScore);
        
        return newId;
    }
    
    function calculateRarityScore(
        string memory _role,
        string memory _genre,
        string memory _aiModel,
        string memory _traits
    ) internal pure returns (uint256) {
        // 基础分数
        uint256 score = 50;
        
        // 角色类型加分
        if (keccak256(bytes(_role)) == keccak256(bytes("protagonist"))) {
            score += 20;
        } else if (keccak256(bytes(_role)) == keccak256(bytes("antagonist"))) {
            score += 15;
        } else if (keccak256(bytes(_role)) == keccak256(bytes("supporting"))) {
            score += 10;
        }
        
        // AI模型加分
        if (keccak256(bytes(_aiModel)) == keccak256(bytes("Sora"))) {
            score += 15;
        } else if (keccak256(bytes(_aiModel)) == keccak256(bytes("Midjourney"))) {
            score += 10;
        } else if (keccak256(bytes(_aiModel)) == keccak256(bytes("Runway"))) {
            score += 8;
        }
        
        // 特征复杂度（通过IPFS哈希长度估算）
        score += bytes(_traits).length % 30;
        
        return score;
    }
    
    function addCharacterAttribute(
        uint256 _characterId,
        string memory _attributeName,
        string memory _attributeValue,
        uint256 _score
    ) external {
        require(ownerOf(_characterId) == msg.sender, "Not the owner");
        
        characterAttributes[_characterId].push(CharacterAttribute({
            attributeName: _attributeName,
            attributeValue: _attributeValue,
            score: _score
        }));
        
        // 更新总稀有度评分
        characters[_characterId].rarityScore += _score;
    }
    
    function licenseCharacter(
        uint256 _characterId,
        string memory _projectName,
        uint256 _durationDays
    ) external payable nonReentrant {
        Character storage character = characters[_characterId];
        require(msg.value >= character.licensingFee, "Insufficient fee");
        require(!character.isLicensed, "Already licensed");
        
        // 分配费用
        uint256 royalty = (msg.value * CREATOR_ROYALTY) / 10000;
        uint256 ownerPayment = msg.value - royalty;
        
        payable(character.creator).transfer(royalty);
        payable(ownerOf(_characterId)).transfer(ownerPayment);
        
        licensingHistory[_characterId].push(LicensingAgreement({
            licensee: msg.sender,
            characterId: _characterId,
            projectName: _projectName,
            fee: msg.value,
            startDate: block.timestamp,
            endDate: block.timestamp + (_durationDays * 1 days),
            isActive: true
        }));
        
        character.isLicensed = true;
        
        emit CharacterLicensed(_characterId, msg.sender, _projectName, msg.value);
    }
    
    function recordUsage(uint256 _characterId) external {
        Character storage character = characters[_characterId];
        character.totalUsageCount++;
        
        emit CharacterUsed(_characterId, "AI Generation");
    }
    
    function getCharacterAttributes(
        uint256 _characterId
    ) external view returns (CharacterAttribute[] memory) {
        return characterAttributes[_characterId];
    }
    
    function getCreatorCharacters(
        address _creator
    ) external view returns (uint256[] memory) {
        return creatorCharacters[_creator];
    }
    
    function getCharacterRarity(uint256 _characterId)
        external view returns (uint256)
    {
        return characters[_characterId].rarityScore;
    }
    
    function searchCharacters(
        string memory _role,
        string memory _genre,
        uint256 _minRarity
    ) external view returns (uint256[] memory) {
        uint256 count;
        uint256 total = _characterIds.current();
        
        // 先统计数量
        for (uint256 i = 1; i <= total; i++) {
            if (
                (bytes(_role).length == 0 || 
                 keccak256(bytes(characters[i].role)) == keccak256(bytes(_role))) &&
                (bytes(_genre).length == 0 || 
                 keccak256(bytes(characters[i].genre)) == keccak256(bytes(_genre))) &&
                characters[i].rarityScore >= _minRarity
            ) {
                count++;
            }
        }
        
        uint256[] memory results = new uint256[](count);
        uint256 index;
        
        for (uint256 i = 1; i <= total; i++) {
            if (
                (bytes(_role).length == 0 || 
                 keccak256(bytes(characters[i].role)) == keccak256(bytes(_role))) &&
                (bytes(_genre).length == 0 || 
                 keccak256(bytes(characters[i].genre)) == keccak256(bytes(_genre))) &&
                characters[i].rarityScore >= _minRarity
            ) {
                results[index] = i;
                index++;
            }
        }
        
        return results;
    }
    
    function setLicensingFee(uint256 _characterId, uint256 _newFee) external {
        require(ownerOf(_characterId) == msg.sender, "Not the owner");
        require(_newFee >= MIN_LICENSING_FEE, "Fee too low");
        characters[_characterId].licensingFee = _newFee;
    }
}

import json
import hashlib
import numpy as np
import pandas as pd
from datetime import datetime
from typing import Dict, List, Tuple, Optional
import matplotlib.pyplot as plt
from dataclasses import dataclass
from collections import defaultdict
import random

@dataclass
class AICharacter:
    name: str
    role: str
    genre: str
    ai_model: str
    personality: Dict[str, float]
    appearance: Dict[str, str]
    backstory: str
    voice: str
    rarity_score: float
    nft_id: Optional[int] = None
    
class AICharacterGenerator:
    def __init__(self):
        self.generated_characters = []
        self.character_templates = self._load_templates()
        
    def _load_templates(self) -> Dict:
        """加载角色模板，就像导演的角色库"""
        return {
            'roles': ['protagonist', 'antagonist', 'supporting', 'extra', 'narrator'],
            'genres': ['科幻', '奇幻', '悬疑', '爱情', '动作', '恐怖', '喜剧', '剧情'],
            'personality_traits': [
                '勇敢', '狡猾', '善良', '阴险', '幽默', '忧郁',
                '自信', '自卑', '外向', '内向', '理性', '感性'
            ],
            'appearance_styles': [
                '写实', '卡通', '赛博朋克', '复古', '未来主义',
                '极简', '巴洛克', '印象派'
            ],
            'voice_types': [
                '低沉', '清脆', '沙哑', '温柔', '威严', '俏皮',
                '中性', '磁性', '稚嫩', '沧桑'
            ],
            'ai_models': ['Sora', 'Midjourney', 'Runway', 'DALL-E', 'StableDiffusion']
        }
    
    def generate_character(self, seed: Optional[str] = None) -> AICharacter:
        """生成AI角色，就像导演构思角色"""
        if seed:
            random.seed(hash(seed))
        else:
            random.seed(datetime.now().timestamp())
        
        # 随机选择角色属性
        role = random.choice(self.character_templates['roles'])
        genre = random.choice(self.character_templates['genres'])
        ai_model = random.choice(self.character_templates['ai_models'])
        voice = random.choice(self.character_templates['voice_types'])
        appearance_style = random.choice(self.character_templates['appearance_styles'])
        
        # 生成角色名
        name = self._generate_name(genre)
        
        # 生成个性特征
        personality = {}
        selected_traits = random.sample(
            self.character_templates['personality_traits'],
            random.randint(3, 6)
        )
        for trait in selected_traits:
            personality[trait] = round(random.uniform(0, 1), 2)
        
        # 生成外貌
        appearance = {
            'style': appearance_style,
            'hair_color': random.choice(['黑色', '金色', '棕色', '红色', '白色', '蓝色', '紫色']),
            'eye_color': random.choice(['黑色', '蓝色', '绿色', '棕色', '灰色', '红色']),
            'height': random.choice(['矮小', '中等', '高大']),
            'build': random.choice(['纤细', '匀称', '健壮', '丰满']),
            'age_group': random.choice(['少年', '青年', '中年', '老年'])
        }
        
        # 生成背景故事
        backstory = self._generate_backstory(role, genre)
        
        # 计算稀有度评分
        rarity_score = self._calculate_rarity(personality, appearance, role, ai_model)
        
        character = AICharacter(
            name=name,
            role=role,
            genre=genre,
            ai_model=ai_model,
            personality=personality,
            appearance=appearance,
            backstory=backstory,
            voice=voice,
            rarity_score=rarity_score
        )
        
        self.generated_characters.append(character)
        return character
    
    def _generate_name(self, genre: str) -> str:
        """生成角色名，就像编剧起名"""
        name_parts = {
            '科幻': ['星', '宇', '光', '电', '云', '风', '雷', '影'],
            '奇幻': ['灵', '幻', '魔', '龙', '凤', '神', '圣', '暗'],
            '悬疑': ['夜', '影', '谜', '暗', '幽', '迷', '踪', '隐'],
            '爱情': ['梦', '恋', '情', '思', '念', '心', '爱', '柔'],
            '动作': ['战', '霸', '龙', '虎', '铁', '刚', '猛', '烈'],
            '恐怖': ['夜', '暗', '血', '尸', '鬼', '煞', '厉', '怨'],
            '喜剧': ['乐', '欢', '喜', '逗', '俏', '皮', '闹', '搞'],
            '剧情': ['平', '淡', '真', '诚', '深', '厚', '暖', '静']
        }
        
        parts = name_parts.get(genre, ['影', '梦'])
        first = random.choice(parts)
        second = random.choice(parts)
        
        # 有时使用英文名
        if random.random() > 0.7:
            english_names = ['Alex', 'Max', 'Luna', 'Nova', 'Iris', 'Kai', 'Zara', 'Leo']
            return random.choice(english_names)
        
        return f"{first}{second}"
    
    def _generate_backstory(self, role: str, genre: str) -> str:
        """生成背景故事，就像编剧写角色小传"""
        templates = {
            'protagonist': {
                '科幻': '在星际联邦的阴影下长大，发现了改变世界的秘密。',
                '奇幻': '被预言选中的勇者，肩负着拯救王国的使命。',
                '悬疑': '一位私家侦探，接手了一桩看似普通的失踪案。',
                '爱情': '在城市的角落经营着一家花店，等待着命中注定的相遇。',
                '动作': '退役特种兵，被卷入了一场跨国阴谋。',
                '恐怖': '搬进了一座古老的宅邸，却发现房子里另有住客。',
                '喜剧': '一个倒霉的上班族，每天都在经历荒诞的日常。',
                '剧情': '小镇上的教师，面对教育体制的困境坚持自己的信念。'
            },
            'antagonist': {
                '科幻': '被科技公司改造的超级战士，试图推翻现有秩序。',
                '奇幻': '堕落的魔法师，想要用黑暗力量统治世界。',
                '悬疑': '表面上是慈善家，背地里操控着城市的犯罪网络。',
                '动作': '国际犯罪组织首领，为了复仇不惜一切代价。',
                '恐怖': '被诅咒的亡灵，在人间寻找替身。',
                '剧情': '腐败的政客，为了权力不择手段。'
            }
        }
        
        role_templates = templates.get(role, templates['protagonist'])
        return role_templates.get(genre, '一个神秘的角色，拥有不为人知的过去。')
    
    def _calculate_rarity(
        self, personality: Dict, appearance: Dict,
        role: str, ai_model: str
    ) -> float:
        """计算角色稀有度，就像评估演员的独特气质"""
        score = 0.0
        
        # 角色类型权重
        role_weights = {'protagonist': 90, 'antagonist': 80, 'supporting': 70, 'extra': 50, 'narrator': 60}
        score += role_weights.get(role, 50)
        
        # AI模型权重
        model_weights = {'Sora': 95, 'Midjourney': 85, 'DALL-E': 80, 'Runway': 75, 'StableDiffusion': 70}
        score += model_weights.get(ai_model, 60)
        
        # 个性多样性
        personality_diversity = len(personality) * 5
        score += personality_diversity
        
        # 外貌独特性
        unique_features = len(set(appearance.values()))
        score += unique_features * 3
        
        # 随机波动
        score += random.uniform(-10, 10)
        
        return min(100, max(0, score))
    
    def generate_character_batch(
        self, count: int = 10, genre: Optional[str] = None
    ) -> List[AICharacter]:
        """批量生成角色，就像选角导演的海选"""
        characters = []
        for i in range(count):
            char = self.generate_character(seed=f"batch_{i}")
            if genre:
                char.genre = genre
            characters.append(char)
        return characters
    
    def analyze_character_distribution(self) -> pd.DataFrame:
        """分析角色分布，就像评估选角多样性"""
        if not self.generated_characters:
            return pd.DataFrame()
        
        df = pd.DataFrame([{
            'name': c.name,
            'role': c.role,
            'genre': c.genre,
            'ai_model': c.ai_model,
            'rarity_score': c.rarity_score,
            'personality_count': len(c.personality),
            'voice': c.voice
        } for c in self.generated_characters])
        
        return df
    
    def visualize_character_analytics(self):
        """可视化角色分析"""
        df = self.analyze_character_distribution()
        if df.empty:
            print("No characters generated")
            return
        
        fig, axes = plt.subplots(2, 2, figsize=(14, 12))
        
        # 1. 角色类型分布
        ax1 = axes[0, 0]
        role_counts = df['role'].value_counts()
        ax1.pie(role_counts.values, labels=role_counts.index, 
               autopct='%1.1f%%', colors=plt.cm.Set3(np.linspace(0, 1, len(role_counts))))
        ax1.set_title('角色类型分布')
        
        # 2. 稀有度评分分布
        ax2 = axes[0, 1]
        ax2.hist(df['rarity_score'], bins=20, color='gold', edgecolor='black', alpha=0.7)
        ax2.axvline(df['rarity_score'].mean(), color='red', linestyle='--', 
                   label=f'平均: {df["rarity_score"].mean():.1f}')
        ax2.set_title('稀有度评分分布')
        ax2.set_xlabel('稀有度评分')
        ax2.set_ylabel('角色数量')
        ax2.legend()
        
        # 3. AI模型使用分布
        ax3 = axes[1, 0]
        model_counts = df['ai_model'].value_counts()
        ax3.bar(model_counts.index, model_counts.values, 
               color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7'])
        ax3.set_title('AI模型分布')
        ax3.set_xticklabels(model_counts.index, rotation=45, ha='right')
        ax3.set_ylabel('角色数量')
        
        # 4. 类型与稀有度关系
        ax4 = axes[1, 1]
        genre_rarity = df.groupby('genre')['rarity_score'].mean().sort_values()
        ax4.barh(genre_rarity.index, genre_rarity.values, color='lightcoral')
        ax4.set_title('各类型平均稀有度')
        ax4.set_xlabel('平均稀有度评分')
        
        plt.tight_layout()
        return plt
    
    def export_to_nft_metadata(self, character: AICharacter) -> Dict:
        """导出为NFT元数据，就像制作角色档案"""
        metadata = {
            'name': character.name,
            'description': f"AI生成的{character.genre}类型{character.role}角色",
            'image': f"ipfs://QmYourHash/{character.name.replace(' ', '_')}.png",
            'attributes': [
                {'trait_type': 'Role', 'value': character.role},
                {'trait_type': 'Genre', 'value': character.genre},
                {'trait_type': 'AI Model', 'value': character.ai_model},
                {'trait_type': 'Voice', 'value': character.voice},
                {'trait_type': 'Rarity', 'value': character.rarity_score},
                {'trait_type': 'Personality Count', 'value': len(character.personality)}
            ],
            'properties': {
                'personality': character.personality,
                'appearance': character.appearance,
                'backstory': character.backstory,
                'ai_model_version': 'v2.0',
                'generation_date': datetime.now().isoformat()
            }
        }
        return metadata


# 使用示例
if __name__ == "__main__":
    generator = AICharacterGenerator()
    
    # 生成角色
    characters = generator.generate_character_batch(count=20, genre='科幻')
    print(f"生成了 {len(characters)} 个科幻角色")
    
    # 分析分布
    df = generator.analyze_character_distribution()
    print("\n角色类型分布:")
    print(df['role'].value_counts())
    
    print(f"\n平均稀有度评分: {df['rarity_score'].mean():.1f}")
    print(f"最高稀有度: {df['rarity_score'].max():.1f}")
    
    # 导出NFT元数据
    sample_char = characters[0]
    metadata = generator.export_to_nft_metadata(sample_char)
    print(f"\nNFT元数据示例:")
    print(f"  名称: {metadata['name']}")
    print(f"  类型: {metadata['attributes'][0]['value']}")
    print(f"  稀有度: {metadata['attributes'][4]['value']}")

// AI角色NFT市场前端
const Web3 = require('web3');
const axios = require('axios');

class AICharacterMarket {
    constructor(providerUrl, contractAddress) {
        this.web3 = new Web3(providerUrl);
        this.contractAddress = contractAddress;
        this.contract = null;
        this.userAccount = null;
        this.characters = new Map();
    }
    
    async initContract(abi) {
        this.contract = new this.web3.eth.Contract(abi, this.contractAddress);
    }
    
    async connectWallet() {
        if (window.ethereum) {
            const accounts = await window.ethereum.request({
                method: 'eth_requestAccounts'
            });
            this.userAccount = accounts[0];
            return this.userAccount;
        }
        throw new Error('请安装MetaMask');
    }
    
    // 铸造AI角色
    async mintCharacter(characterData) {
        const {
            name, role, genre, aiModel, modelVersion,
            trainingData, traits, tokenURI, licensingFee
        } = characterData;
        
        const feeWei = this.web3.utils.toWei(licensingFee.toString(), 'ether');
        
        const result = await this.contract.methods
            .createCharacter(
                name, role, genre, aiModel, modelVersion,
                trainingData, traits, tokenURI, feeWei
            )
            .send({ from: this.userAccount });
        
        console.log(`[铸造] AI角色已铸造: ${name}`);
        return result;
    }
    
    // 获取角色详情
    async getCharacterDetails(characterId) {
        try {
            const character = await this.contract.methods
                .getCharacter(characterId)
                .call();
            
            const attributes = await this.contract.methods
                .getCharacterAttributes(characterId)
                .call();
            
            const details = {
                id: characterId,
                name: character.name,
                role: character.role,
                genre: character.genre,
                aiModel: character.aiModel,
                rarityScore: character.rarityScore,
                licensingFee: this.web3.utils.fromWei(character.licensingFee, 'ether'),
                creator: character.creator,
                isLicensed: character.isLicensed,
                totalUsage: character.totalUsageCount,
                attributes: attributes.map(a => ({
                    name: a.attributeName,
                    value: a.attributeValue,
                    score: a.score
                }))
            };
            
            this.characters.set(characterId, details);
            return details;
        } catch (error) {
            console.error('获取角色详情失败:', error);
            return null;
        }
    }
    
    // 搜索角色
    async searchCharacters(filters) {
        const { role, genre, minRarity } = filters;
        
        const result = await this.contract.methods
            .searchCharacters(role || '', genre || '', minRarity || 0)
            .call();
        
        const characters = [];
        for (const id of result) {
            const details = await this.getCharacterDetails(parseInt(id));
            if (details) {
                characters.push(details);
            }
        }
        
        return characters;
    }
    
    // 授权使用角色
    async licenseCharacter(characterId, projectName, durationDays) {
        const character = await this.getCharacterDetails(characterId);
        const feeWei = this.web3.utils.toWei(
            character.licensingFee.toString(), 'ether'
        );
        
        const result = await this.contract.methods
            .licenseCharacter(characterId, projectName, durationDays)
            .send({
                from: this.userAccount,
                value: feeWei
            });
        
        console.log(`[授权] 已授权使用角色 #${characterId}`);
        return result;
    }
    
    // 获取创作者的角色列表
    async getCreatorCollection(creatorAddress) {
        const characterIds = await this.contract.methods
            .getCreatorCharacters(creatorAddress)
            .call();
        
        const collection = [];
        for (const id of characterIds) {
            const details = await this.getCharacterDetails(parseInt(id));
            if (details) {
                collection.push(details);
            }
        }
        
        return collection;
    }
    
    // 计算角色稀有度等级
    getRarityLevel(score) {
        if (score >= 90) return { level: '神话', color: '#FFD700' };
        if (score >= 75) return { level: '传说', color: '#FF6B6B' };
        if (score >= 60) return { level: '史诗', color: '#C084FC' };
        if (score >= 40) return { level: '稀有', color: '#60A5FA' };
        return { level: '普通', color: '#9CA3AF' };
    }
    
    // 角色推荐引擎
    async getRecommendations(preferences) {
        const { genre, role, minRarity } = preferences;
        const candidates = await this.searchCharacters({
            genre,
            role,
            minRarity: minRarity || 0
        });
        
        // 基于稀有度排序
        candidates.sort((a, b) => b.rarityScore - a.rarityScore);
        
        return candidates.slice(0, 10);
    }
    
    // 事件监听
    listenToEvents() {
        this.contract.events.CharacterCreated({
            fromBlock: 'latest'
        })
        .on('data', event => {
            console.log('[事件] 新角色诞生:', event.returnValues.name);
            this.getCharacterDetails(parseInt(event.returnValues.characterId));
        });
        
        this.contract.events.CharacterLicensed({
            fromBlock: 'latest'
        })
        .on('data', event => {
            console.log('[事件] 角色被授权:', event.returnValues.characterId);
        });
    }
}

// 使用示例
const market = new AICharacterMarket(
    'https://mainnet.infura.io/v3/YOUR_PROJECT_ID',
    '0xContractAddress'
);

(async () => {
    await market.initContract([]);
    await market.connectWallet();
    
    const recommendations = await market.getRecommendations({
        genre: '科幻',
        role: 'protagonist',
        minRarity: 60
    });
    
    console.log('推荐角色:', recommendations.slice(0, 5));
})();