《阿凡达》与数字分身：化身NFT与潘多拉的去中心化网络

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

/**
 * @title PandoraAvatarNFT - 潘多拉化身NFT合约
 * @notice 每个化身都是独一无二的数字分身，与纳美人的灵魂绑定
 * @dev 实现了ERC-721标准的灵魂绑定版本，不可转让
 */
contract PandoraAvatarNFT {
    mapping(uint256 => address) private _owners;
    mapping(uint256 => string) private _avatarMetadata;
    mapping(address => uint256) private _soulboundTokens;
    mapping(uint256 => uint256) private _connectionStrength;
    
    uint256 private _tokenIdCounter;
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public constant EYWA_CONNECTION_COST = 0.01 ether;
    
    event AvatarTransformed(uint256 indexed tokenId, address indexed driver, string dnaSignature);
    event EywaConnection(uint256 indexed tokenId, uint256 strength, uint256 timestamp);
    
    function mintAvatar(address driver, string memory dnaSignature) public returns (uint256) {
        require(_tokenIdCounter < MAX_SUPPLY, "潘多拉星球已满，无法铸造更多化身");
        require(driver != address(0), "驾驶员地址不能为空");
        _tokenIdCounter++;
        uint256 newTokenId = _tokenIdCounter;
        _owners[newTokenId] = driver;
        _avatarMetadata[newTokenId] = dnaSignature;
        _soulboundTokens[driver] = newTokenId;
        emit AvatarTransformed(newTokenId, driver, dnaSignature);
        return newTokenId;
    }
    
    function connectToEywa(uint256 tokenId) public payable returns (bool) {
        require(_owners[tokenId] == msg.sender, "只有化身驾驶员可以连接Eywa");
        require(msg.value >= EYWA_CONNECTION_COST, "连接Eywa需要支付能量费用");
        _connectionStrength[tokenId] += msg.value;
        emit EywaConnection(tokenId, _connectionStrength[tokenId], block.timestamp);
        return true;
    }
    
    function getSoulboundAvatar(address driver) public view returns (uint256) {
        uint256 tokenId = _soulboundTokens[driver];
        require(tokenId != 0, "该地址没有灵魂绑定的化身");
        return tokenId;
    }
    
    function getConnectionStrength(uint256 tokenId) public view returns (uint256) {
        return _connectionStrength[tokenId];
    }
    
    function getAvatarMetadata(uint256 tokenId) public view returns (string memory) {
        return _avatarMetadata[tokenId];
    }
}

import requests
from web3 import Web3
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

# 连接到以太坊节点
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))

class PandoraOnChainAnalyzer:
    """
    潘多拉链上数据分析器
    追踪化身NFT的交易模式、持有者分布和Eywa连接强度
    """
    
    def __init__(self, contract_address):
        self.contract = w3.eth.contract(
            address=contract_address,
            abi=self._load_avatar_abi()
        )
        self.transaction_log = []
        self.whale_threshold = 100  # 持有超过100个化身视为巨鲸
    
    def _load_avatar_abi(self):
        """加载化身NFT合约的ABI"""
        return [
            {"inputs": [], "name": "totalSupply", "outputs": [{"type": "uint256"}], "type": "function"},
            {"inputs": [{"type": "address"}], "name": "balanceOf", "outputs": [{"type": "uint256"}], "type": "function"},
            {"inputs": [{"type": "uint256"}], "name": "ownerOf", "outputs": [{"type": "address"}], "type": "function"},
            {"inputs": [{"type": "uint256"}], "name": "getConnectionStrength", "outputs": [{"type": "uint256"}], "type": "function"},
        ]
    
    def analyze_avatar_ownership(self, token_ids):
        """分析多个化身NFT的所有权分布"""
        ownership_data = []
        for tid in token_ids:
            try:
                owner = self.contract.functions.ownerOf(tid).call()
                strength = self.contract.functions.getConnectionStrength(tid).call()
                ownership_data.append({
                    'token_id': tid,
                    'owner': owner,
                    'connection_strength': strength,
                    'is_whale': self._is_whale(owner)
                })
            except Exception as e:
                print(f"Token {tid} 查询失败: {e}")
        return pd.DataFrame(ownership_data)
    
    def _is_whale(self, address):
        """判断地址是否为巨鲸"""
        try:
            balance = self.contract.functions.balanceOf(address).call()
            return balance >= self.whale_threshold
        except:
            return False
    
    def _get_transfer_events(self, token_id, from_block=0, to_block='latest'):
        """获取特定Token的转移事件"""
        transfer_filter = self.contract.events.Transfer.create_filter(
            argument_filters={'tokenId': token_id},
            fromBlock=from_block,
            toBlock=to_block
        )
        return transfer_filter.get_all_entries()
    
    def calculate_eywa_connection_score(self, address):
        """计算地址与Eywa网络的连接评分"""
        balance = self.contract.functions.balanceOf(address).call()
        if balance == 0:
            return 0.0
        total_strength = 0
        for i in range(balance):
            token_id = self.contract.functions.tokenOfOwnerByIndex(address, i).call()
            total_strength += self.contract.functions.getConnectionStrength(token_id).call()
        score = min(balance * 10 + total_strength * 0.01, 100)
        return round(score, 2)
    
    def generate_whale_report(self, top_n=10):
        """生成巨鲸持有者报告"""
        total_supply = self.contract.functions.totalSupply().call()
        print(f"潘多拉化身总供应量: {total_supply}")
        print(f"巨鲸阈值: {self.whale_threshold} 个化身")
        return {"total_supply": total_supply, "whale_threshold": self.whale_threshold}

# 实例化分析器
analyzer = PandoraOnChainAnalyzer('0xPandoraAvatarContractAddress')
df = analyzer.analyze_avatar_ownership(range(1, 101))
print(f"已分析 {len(df)} 个化身NFT的所有权分布")
whales = df[df['is_whale'] == True]
print(f"巨鲸数量: {len(whales)}")
print(f"平均Eywa连接强度: {df['connection_strength'].mean():.2f}")

import React, { useState, useEffect, useCallback } from 'react';
import { ethers } from 'ethers';
import PandoraAvatarABI from './contracts/PandoraAvatarABI.json';
import './PandoraDashboard.css';

const CONTRACT_ADDRESS = '0xPandoraAvatarContract';
const EYWA_NETWORK_ID = 137; // Polygon Mumbai测试网

const PandoraAvatarManager = () => {
  const [account, setAccount] = useState(null);
  const [avatarNFTs, setAvatarNFTs] = useState([]);
  const [eywaConnection, setEywaConnection] = useState(false);
  const [provider, setProvider] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  // 连接MetaMask钱包
  const connectWallet = useCallback(async () => {
    if (!window.ethereum) {
      setError('请安装MetaMask钱包以连接潘多拉网络');
      return;
    }
    try {
      const accounts = await window.ethereum.request({
        method: 'eth_requestAccounts'
      });
      const chainId = await window.ethereum.request({ method: 'eth_chainId' });
      if (parseInt(chainId) !== EYWA_NETWORK_ID) {
        await window.ethereum.request({
          method: 'wallet_switchEthereumChain',
          params: [{ chainId: '0x89' }] // Polygon主网
        });
      }
      setAccount(accounts[0]);
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      setProvider(provider);
      setError(null);
    } catch (err) {
      setError('钱包连接失败: ' + err.message);
    }
  }, []);

  // 获取用户持有的化身NFT
  const fetchAvatars = useCallback(async () => {
    if (!provider || !account) return;
    setLoading(true);
    try {
      const contract = new ethers.Contract(
        CONTRACT_ADDRESS,
        PandoraAvatarABI,
        provider
      );
      const balance = await contract.balanceOf(account);
      const avatars = [];
      for (let i = 0; i < balance.toNumber(); i++) {
        const tokenId = await contract.tokenOfOwnerByIndex(account, i);
        const metadata = await contract.getAvatarMetadata(tokenId);
        const strength = await contract.getConnectionStrength(tokenId);
        avatars.push({
          id: tokenId.toNumber(),
          dna: metadata,
          strength: strength.toNumber(),
          level: Math.floor(strength.toNumber() / 100) + 1
        });
      }
      setAvatarNFTs(avatars);
      setError(null);
    } catch (err) {
      setError('获取化身数据失败: ' + err.message);
    } finally {
      setLoading(false);
    }
  }, [provider, account]);

  // 铸造新的化身NFT
  const mintNewAvatar = useCallback(async (dnaSignature) => {
    if (!provider || !account) return;
    setLoading(true);
    try {
      const signer = provider.getSigner();
      const contract = new ethers.Contract(
        CONTRACT_ADDRESS,
        PandoraAvatarABI,
        signer
      );
      const tx = await contract.mintAvatar(account, dnaSignature);
      await tx.wait();
      await fetchAvatars();
      setError(null);
    } catch (err) {
      setError('化身铸造失败: ' + err.message);
    } finally {
      setLoading(false);
    }
  }, [provider, account, fetchAvatars]);

  // 连接到Eywa网络
  const connectToEywa = useCallback(async (tokenId) => {
    if (!provider || !account) return;
    setLoading(true);
    try {
      const signer = provider.getSigner();
      const contract = new ethers.Contract(
        CONTRACT_ADDRESS,
        PandoraAvatarABI,
        signer
      );
      const tx = await contract.connectToEywa(tokenId, {
        value: ethers.utils.parseEther('0.01')
      });
      await tx.wait();
      setEywaConnection(true);
      await fetchAvatars();
      setError(null);
    } catch (err) {
      setError('Eywa连接失败: ' + err.message);
    } finally {
      setLoading(false);
    }
  }, [provider, account, fetchAvatars]);

  useEffect(() => {
    if (account && provider) {
      fetchAvatars();
    }
  }, [account, provider, fetchAvatars]);

  return (
    <div className="pandora-dapp">
      <div className="header">
        <h1>潘多拉化身管理系统</h1>
        <p className="subtitle">连接你的灵魂，探索去中心化的潘多拉</p>
      </div>
      {!account ? (
        <div className="connect-section">
          <button onClick={connectWallet} className="connect-btn" disabled={loading}>
            {loading ? '正在连接...' : '连接你的化身舱 — 开始潘多拉之旅'}
          </button>
          {error && <p className="error">{error}</p>}
        </div>
      ) : (
        <div className="dashboard">
          <div className="driver-info">
            <p>驾驶员地址: {account.slice(0, 8)}...{account.slice(-6)}</p>
            <p>持有化身: {avatarNFTs.length} 个</p>
          </div>
          <div className="avatar-grid">
            {avatarNFTs.map(avatar => (
              <div key={avatar.id} className="avatar-card">
                <div className="avatar-header">
                  <h3>化身 #{avatar.id}</h3>
                  <span className="level">Lv.{avatar.level}</span>
                </div>
                <div className="avatar-body">
                  <p>DNA签名: {avatar.dna.slice(0, 20)}...</p>
                  <p>Eywa连接强度: {avatar.strength}</p>
                </div>
                <button
                  onClick={() => connectToEywa(avatar.id)}
                  disabled={eywaConnection || loading}
                  className="eywa-btn"
                >
                  {eywaConnection ? '已连接Eywa' : '连接灵魂树'}
                </button>
              </div>
            ))}
          </div>
          <div className="actions">
            <button
              onClick={() => mintNewAvatar('NAVI-' + Date.now())}
              disabled={loading}
              className="mint-btn"
            >
              {loading ? '铸造中...' : '铸造新的化身'}
            </button>
          </div>
          {error && <p className="error">{error}</p>}
        </div>
      )}
    </div>
  );
};

export default PandoraAvatarManager;