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

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

contract DecentralizedAdNetwork {
    IERC20 public token;
    uint256 public constant CREATOR_SHARE = 70;
    uint256 public constant VIEWER_SHARE = 20;
    uint256 public constant PROTOCOL_SHARE = 10;

    struct AdCampaign {
        uint256 campaignId;
        address advertiser;
        string adURI;
        string targetContent;
        uint256 totalBudget;
        uint256 spentBudget;
        uint256 pricePerView;
        uint256 maxViews;
        bool isActive;
    }

    struct AdView {
        uint256 viewId;
        uint256 campaignId;
        address viewer;
        uint256 reward;
        uint256 timestamp;
    }

    mapping(uint256 => AdCampaign) public campaigns;
    mapping(uint256 => AdView[]) public campaignViews;
    mapping(address => uint256[]) public viewerHistory;
    uint256 public campaignCounter;
    uint256 public viewCounter;

    event CampaignCreated(uint256 indexed campaignId, address indexed advertiser, uint256 budget);
    event AdViewed(uint256 indexed viewId, uint256 indexed campaignId, address indexed viewer, uint256 reward);

    constructor(address _token) {
        token = IERC20(_token);
    }

    function createCampaign(string calldata adURI, string calldata targetContent, uint256 totalBudget, uint256 pricePerView, uint256 maxViews) external returns (uint256) {
        require(token.transferFrom(msg.sender, address(this), totalBudget), "Transfer failed");
        campaignCounter++;
        campaigns[campaignCounter] = AdCampaign(campaignCounter, msg.sender, adURI, targetContent, totalBudget, 0, pricePerView, maxViews, true);
        emit CampaignCreated(campaignCounter, msg.sender, totalBudget);
        return campaignCounter;
    }

    function viewAd(uint256 campaignId, address creator) external {
        AdCampaign storage c = campaigns[campaignId];
        require(c.isActive, "Campaign not active");
        require(c.spentBudget + c.pricePerView <= c.totalBudget, "Budget exhausted");
        require(campaignViews[campaignId].length < c.maxViews, "Max views reached");

        viewCounter++;
        uint256 creatorReward = (c.pricePerView * CREATOR_SHARE) / 100;
        uint256 viewerReward = (c.pricePerView * VIEWER_SHARE) / 100;
        uint256 protocolReward = (c.pricePerView * PROTOCOL_SHARE) / 100;

        c.spentBudget += c.pricePerView;
        campaignViews[campaignId].push(AdView(viewCounter, campaignId, msg.sender, viewerReward, block.timestamp));
        viewerHistory[msg.sender].push(viewCounter);

        require(token.transfer(creator, creatorReward), "Creator transfer failed");
        require(token.transfer(msg.sender, viewerReward), "Viewer transfer failed");
        emit AdViewed(viewCounter, campaignId, msg.sender, viewerReward);
    }

    function getCampaign(uint256 campaignId) external view returns (AdCampaign memory) {
        return campaigns[campaignId];
    }

    function getViewerRewards(address viewer) external view returns (uint256) {
        uint256 total = 0;
        for (uint256 i = 0; i < viewerHistory[viewer].length; i++) {
            total += campaignViews[viewerHistory[viewer][i]][0].reward;
        }
        return total;
    }
}

interface IERC20 {
    function transferFrom(address, address, uint256) external returns (bool);
    function transfer(address, uint256) external returns (bool);
}

import random

class AdEconomySimulator:
    def __init__(self):
        self.creators = {}
        self.advertisers = {}
        self.viewers = {}

    def add_creator(self, addr, content_count):
        self.creators[addr] = {"content": content_count, "earnings": 0}

    def add_advertiser(self, addr, budget):
        self.advertisers[addr] = {"budget": budget, "spent": 0}

    def add_viewer(self, addr):
        self.viewers[addr] = {"views": 0, "rewards": 0}

    def run_ad_campaign(self, advertiser, budget, cpm):
        views = int(budget / (cpm / 1000))
        ad = self.advertisers[advertiser]
        ad["spent"] = budget

        for viewer in self.viewers:
            if random.random() > 0.5 and views > 0:
                self.viewers[viewer]["views"] += 1
                self.viewers[viewer]["rewards"] += cpm / 1000 * 0.2
                views -= 1

        creator_share = budget * 0.7
        for creator in self.creators:
            self.creators[creator]["earnings"] += creator_share / len(self.creators)

        return {"budget": budget, "views": int(budget / (cpm / 1000)) - views, "creator_share": creator_share}

sim = AdEconomySimulator()
sim.add_creator("0xCreator1", 50)
sim.add_advertiser("0xAdvertiser1", 10000)
sim.add_viewer("0xViewer1")
result = sim.run_ad_campaign("0xAdvertiser1", 10000, 5)
print(result)

class AdNetworkFrontend {
  constructor(contractAddress, signer) {
    this.contract = new ethers.Contract(contractAddress, AdABI, signer);
  }

  async createCampaign(adURI, targetContent, budget, pricePerView, maxViews) {
    const tx = await this.contract.createCampaign(adURI, targetContent, ethers.parseEther(budget), ethers.parseEther(pricePerView), maxViews);
    const receipt = await tx.wait();
    const campaignId = receipt.events[0].args.campaignId.toString();
    console.log("Campaign created: " + campaignId);
    return campaignId;
  }

  async viewAd(campaignId, creator) {
    const tx = await this.contract.viewAd(campaignId, creator);
    await tx.wait();
    console.log("Ad viewed, reward earned");
  }

  async getCampaignStats(campaignId) {
    const c = await this.contract.getCampaign(campaignId);
    return {
      budget: ethers.formatEther(c.totalBudget),
      spent: ethers.formatEther(c.spentBudget),
      views: c.maxViews.toString(),
      active: c.isActive
    };
  }
}

const ad = new AdNetworkFrontend("0xContract", signer);
ad.createCampaign("ipfs://ad123", "所有内容", "1000", "0.01", 10000);