去中心化广告与创作者变现：Web3的注意力经济

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract DecentralizedAd is ERC20, Ownable, ReentrancyGuard {
    struct AdCampaign {
        uint256 id;
        address advertiser;
        string content;
        uint256 budget;
        uint256 costPerView;
        uint256 totalViews;
        uint256 maxViews;
        uint256 startTime;
        uint256 endTime;
        bool isActive;
    }
    
    struct Creator {
        address addr;
        string name;
        uint256 totalEarnings;
        uint256 totalViews;
        uint256 adCount;
        bool isRegistered;
    }
    
    struct ViewRecord {
        address viewer;
        address creator;
        uint256 campaignId;
        uint256 timestamp;
        uint256 reward;
        bool isPaid;
    }
    
    mapping(uint256 => AdCampaign) public campaigns;
    mapping(address => Creator) public creators;
    mapping(address => mapping(uint256 => bool)) public hasViewed;
    mapping(uint256 => ViewRecord[]) public viewRecords;
    
    uint256 public campaignCount;
    uint256 public viewCount;
    uint256 public constant CREATOR_SHARE = 7000; // 70%
    uint256 public constant VIEWER_SHARE = 2000; // 20%
    uint256 public constant PLATFORM_SHARE = 1000; // 10%
    
    event CampaignCreated(uint256 indexed id, address indexed advertiser, uint256 budget);
    event AdViewed(uint256 indexed campaignId, address indexed viewer, address indexed creator);
    event RewardDistributed(uint256 indexed campaignId, address indexed recipient, uint256 amount);
    
    constructor() ERC20("AdToken", "ADTK") {
        _mint(msg.sender, 1000000 * 10**18);
    }
    
    function registerCreator(string memory _name) external {
        require(!creators[msg.sender].isRegistered, "Already registered");
        
        creators[msg.sender] = Creator({
            addr: msg.sender,
            name: _name,
            totalEarnings: 0,
            totalViews: 0,
            adCount: 0,
            isRegistered: true
        });
    }
    
    function createCampaign(
        string memory _content,
        uint256 _budget,
        uint256 _costPerView,
        uint256 _maxViews,
        uint256 _durationDays
    ) external payable returns (uint256) {
        require(msg.value >= _budget, "Insufficient budget");
        require(_costPerView > 0, "Cost per view must be > 0");
        
        campaignCount++;
        campaigns[campaignCount] = AdCampaign({
            id: campaignCount,
            advertiser: msg.sender,
            content: _content,
            budget: _budget,
            costPerView: _costPerView,
            totalViews: 0,
            maxViews: _maxViews,
            startTime: block.timestamp,
            endTime: block.timestamp + (_durationDays * 1 days),
            isActive: true
        });
        
        emit CampaignCreated(campaignCount, msg.sender, _budget);
        return campaignCount;
    }
    
    function viewAd(uint256 _campaignId, address _creator) external nonReentrant {
        AdCampaign storage campaign = campaigns[_campaignId];
        require(campaign.isActive, "Campaign not active");
        require(block.timestamp <= campaign.endTime, "Campaign ended");
        require(campaign.totalViews < campaign.maxViews, "Max views reached");
        require(!hasViewed[msg.sender][_campaignId], "Already viewed");
        
        campaign.totalViews++;
        hasViewed[msg.sender][_campaignId] = true;
        
        uint256 reward = campaign.costPerView;
        uint256 creatorReward = (reward * CREATOR_SHARE) / 10000;
        uint256 viewerReward = (reward * VIEWER_SHARE) / 10000;
        uint256 platformReward = (reward * PLATFORM_SHARE) / 10000;
        
        viewCount++;
        viewRecords[_campaignId].push(ViewRecord({
            viewer: msg.sender,
            creator: _creator,
            campaignId: _campaignId,
            timestamp: block.timestamp,
            reward: viewerReward,
            isPaid: true
        }));
        
        payable(_creator).transfer(creatorReward);
        payable(msg.sender).transfer(viewerReward);
        payable(owner()).transfer(platformReward);
        
        creators[_creator].totalEarnings += creatorReward;
        creators[_creator].totalViews++;
        creators[_creator].adCount++;
        
        emit AdViewed(_campaignId, msg.sender, _creator);
        emit RewardDistributed(_campaignId, _creator, creatorReward);
        emit RewardDistributed(_campaignId, msg.sender, viewerReward);
    }
    
    function getCampaignInfo(uint256 _campaignId)
        external view returns (AdCampaign memory)
    {
        return campaigns[_campaignId];
    }
    
    function getCreatorInfo(address _creator)
        external view returns (Creator memory)
    {
        return creators[_creator];
    }
}

import numpy as np
import pandas as pd
from typing import Dict, List
import matplotlib.pyplot as plt

class AdEconomyAnalyzer:
    def __init__(self):
        self.campaigns = []
        
    def generate_synthetic_data(self, n: int = 100):
        np.random.seed(42)
        
        for i in range(n):
            campaign = {
                'id': i + 1,
                'budget': np.random.exponential(50000),
                'cost_per_view': np.random.uniform(0.001, 0.1),
                'total_views': int(np.random.exponential(10000)),
                'creator_share': np.random.uniform(0.5, 0.8),
                'viewer_share': np.random.uniform(0.1, 0.3),
                'platform_share': 0.1,
                'is_successful': np.random.random() > 0.3
            }
            self.campaigns.append(campaign)
    
    def analyze_economics(self) -> Dict:
        df = pd.DataFrame(self.campaigns)
        total_budget = df['budget'].sum()
        creator_total = (df['budget'] * df['creator_share']).sum()
        viewer_total = (df['budget'] * df['viewer_share']).sum()
        platform_total = (df['budget'] * df['platform_share']).sum()
        
        return {
            'total_budget': total_budget,
            'creator_revenue': creator_total,
            'viewer_revenue': viewer_total,
            'platform_revenue': platform_total,
            'creator_percentage': creator_total / total_budget * 100,
            'viewer_percentage': viewer_total / total_budget * 100
        }
    
    def generate_report(self) -> str:
        eff = self.analyze_economics()
        report = f"""
=== 去中心化广告经济分析 ===

总广告预算: ${eff['total_budget']:,.2f}
创作者收入: ${eff['creator_revenue']:,.2f} ({eff['creator_percentage']:.1f}%)
观众收入: ${eff['viewer_revenue']:,.2f} ({eff['viewer_percentage']:.1f}%)
平台收入: ${eff['platform_revenue']:,.2f}
"""
        return report


if __name__ == "__main__":
    analyzer = AdEconomyAnalyzer()
    analyzer.generate_synthetic_data(100)
    report = analyzer.generate_report()
    print(report)

class AdManager {
    constructor(providerUrl, contractAddress) {
        this.web3 = new Web3(providerUrl);
        this.contract = new this.web3.eth.Contract([], contractAddress);
    }
    
    async registerCreator(name) {
        return await this.contract.methods.registerCreator(name).send({ from: this.userAccount });
    }
    
    async createCampaign(content, budget, costPerView, maxViews, durationDays) {
        const budgetWei = this.web3.utils.toWei(budget.toString(), 'ether');
        return await this.contract.methods
            .createCampaign(content, budgetWei, costPerView, maxViews, durationDays)
            .send({ from: this.userAccount, value: budgetWei });
    }
    
    async viewAd(campaignId, creator) {
        return await this.contract.methods.viewAd(campaignId, creator).send({ from: this.userAccount });
    }
}

const manager = new AdManager('https://mainnet.infura.io/v3/YOUR_ID', '0x...');