链上身份与影迷社区：DID的粉丝经济模型

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

contract FilmFanDID {
    struct FanProfile {
        bytes32 did;
        address wallet;
        string username;
        uint256 reputation;
        uint256 contributionScore;
        uint256 joinDate;
        Badge[] badges;
        bool active;
    }

    struct Badge {
        string name;
        string description;
        uint256 awardedAt;
        bool active;
    }

    struct Contribution {
        address contributor;
        string contributionType;
        uint256 value;
        uint256 timestamp;
        bool verified;
    }

    mapping(address => FanProfile) public fans;
    mapping(bytes32 => address) public didToAddress;
    mapping(address => Contribution[]) public contributions;
    mapping(address => uint256) public fanTokenBalance;

    event FanRegistered(address indexed wallet, bytes32 did, string username);
    event ContributionVerified(address indexed fan, string contributionType, uint256 value);
    event BadgeAwarded(address indexed fan, string badgeName);

    function register(bytes32 did, string calldata username) external {
        require(didToAddress[did] == address(0), "DID exists");
        require(fans[msg.sender].wallet == address(0), "Already registered");

        fans[msg.sender] = FanProfile({
            did: did,
            wallet: msg.sender,
            username: username,
            reputation: 100,
            contributionScore: 0,
            joinDate: block.timestamp,
            badges: new Badge[](0),
            active: true
        });
        didToAddress[did] = msg.sender;
        emit FanRegistered(msg.sender, did, username);
    }

    function addContribution(string calldata contributionType, uint256 value) external {
        require(fans[msg.sender].active, "Not registered");
        contributions[msg.sender].push(Contribution({
            contributor: msg.sender,
            contributionType: contributionType,
            value: value,
            timestamp: block.timestamp,
            verified: false
        }));
    }

    function verifyContribution(address fan, uint256 contributionIndex) external {
        Contribution storage c = contributions[fan][contributionIndex];
        require(!c.verified, "Already verified");
        c.verified = true;
        fans[fan].contributionScore += c.value;
        fans[fan].reputation += c.value / 10;
        fanTokenBalance[fan] += c.value;
        emit ContributionVerified(fan, c.contributionType, c.value);
    }

    function awardBadge(address fan, string calldata name, string calldata description) external {
        FanProfile storage f = fans[fan];
        require(f.active, "Not registered");
        f.badges.push(Badge({
            name: name,
            description: description,
            awardedAt: block.timestamp,
            active: true
        }));
        emit BadgeAwarded(fan, name);
    }

    function getFanProfile(address fan) external view returns (FanProfile memory) {
        return fans[fan];
    }
}

import json
import random
from typing import Dict, List

class FanEconomyAnalyzer:
    def simulate_fan_community(self, n_fans: int = 1000) -> Dict:
        fans = [{
            'reputation': random.randint(0, 1000),
            'contributions': random.randint(0, 500),
            'badges': random.randint(0, 10),
            'tokens': random.randint(0, 10000)
        } for _ in range(n_fans)]

        return {
            'total_fans': n_fans,
            'avg_reputation': sum(f['reputation'] for f in fans) / n_fans,
            'total_contributions': sum(f['contributions'] for f in fans),
            'total_tokens': sum(f['tokens'] for f in fans),
            'top_fan_reputation': max(f['reputation'] for f in fans),
            'community_health': self._calculate_health(fans)
        }

    def _calculate_health(self, fans: List[Dict]) -> float:
        active = sum(1 for f in fans if f['contributions'] > 10)
        return active / len(fans) * 100


analyzer = FanEconomyAnalyzer()
result = analyzer.simulate_fan_community()
print(json.dumps(result, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const app = express();
app.use(express.json());

const FAN_ABI = [
    "function register(bytes32 did, string username) external",
    "function addContribution(string contributionType, uint256 value) external",
    "function verifyContribution(address fan, uint256 contributionIndex) external",
    "function awardBadge(address fan, string name, string description) external",
    "event FanRegistered(address indexed wallet, bytes32 did, string username)",
    "event BadgeAwarded(address indexed fan, string badgeName)"
];

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

    async register(privateKey, did, username) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.contract.connect(wallet);
        const tx = await contract.register(did, username);
        return await tx.wait();
    }
}

app.post('/api/fan/register', async (req, res) => {
    const { privateKey, did, username } = req.body;
    const manager = new FanDIDManager(process.env.RPC_URL, process.env.FAN_ADDRESS);
    const receipt = await manager.register(privateKey, did, username);
    res.json(receipt);
});

app.listen(3029, () => {
    console.log('Fan DID API running on port 3029');
});