AI生成的伦理困境：当算法取代人类创意工作者

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/// @title AIGC版权与收益分配合约
/// @notice 为AI辅助生成的影视作品登记人类贡献者、AI工具与训练数据来源，
///         并按比例自动分配二级市场收益
contract AIGCCopyrightRegistry is ERC721, Ownable {
    struct Contributor {
        address wallet;        // 创作者钱包地址
        string role;            // 角色：编剧/导演/剪辑/AI工具/训练数据提供者
        uint16 shareBps;        // 收益分成（基点，10000 = 100%）
        bool isHuman;           // 是否为人类创作者
        string evidenceHash;    // 贡献证据的哈希（如分镜稿、提示词记录）
    }

    struct Work {
        address creator;              // 登记者
        string contentHash;           // 作品内容哈希（IPFS CID）
        string aiModelHash;           // AI模型版本哈希
        bool copyrightClaimed;        // 是否主张完整版权
        Contributor[] contributors;   // 贡献者列表
        uint256 totalShares;          // 总基点（应为10000）
    }

    mapping(uint256 => Work) private _works;
    uint256 private _nextTokenId;

    // 二级市场版税费率（基点）
    uint16 public royaltyBps = 1000; // 10%

    event WorkRegistered(uint256 indexed tokenId, string contentHash, uint256 contributorCount);
    event RoyaltyDistributed(uint256 indexed tokenId, uint256 amount);

    constructor() ERC721("AIGC-Film-Right", "AIGCR") Ownable(msg.sender) {}

    /// @notice 注册一件AI辅助生成的作品
    function registerWork(
        string calldata contentHash,
        string calldata aiModelHash,
        bool claimCopyright,
        address[] calldata wallets,
        string[] calldata roles,
        uint16[] calldata shares,
        bool[] calldata isHumans,
        string[] calldata evidenceHashes
    ) external returns (uint256) {
        require(wallets.length == roles.length, "length mismatch");
        require(wallets.length == shares.length, "shares length mismatch");
        require(wallets.length == isHumans.length, "human flag mismatch");
        require(wallets.length == evidenceHashes.length, "evidence mismatch");

        uint256 tokenId = _nextTokenId++;
        _mint(msg.sender, tokenId);

        Work storage w = _works[tokenId];
        w.creator = msg.sender;
        w.contentHash = contentHash;
        w.aiModelHash = aiModelHash;
        w.copyrightClaimed = claimCopyright;

        uint256 total = 0;
        for (uint256 i = 0; i < wallets.length; i++) {
            w.contributors.push(Contributor({
                wallet: wallets[i],
                role: roles[i],
                shareBps: shares[i],
                isHuman: isHumans[i],
                evidenceHash: evidenceHashes[i]
            }));
            total += shares[i];
        }
        require(total == 10000, "shares must sum to 10000");
        w.totalShares = total;

        emit WorkRegistered(tokenId, contentHash, wallets.length);
        return tokenId;
    }

    /// @notice 二级市场转售时，按贡献者比例自动分配版税
    function distributeRoyalty(uint256 tokenId) external payable {
        Work storage w = _works[tokenId];
        require(w.contributors.length > 0, "no contributors");
        uint256 royaltyAmount = (msg.value * royaltyBps) / 10000;

        for (uint256 i = 0; i < w.contributors.length; i++) {
            uint256 share = (royaltyAmount * w.contributors[i].shareBps) / 10000;
            if (share > 0) {
                (bool ok, ) = payable(w.contributors[i].wallet).call{value: share}("");
                require(ok, "transfer failed");
            }
        }
        emit RoyaltyDistributed(tokenId, royaltyAmount);
    }

    function getWork(uint256 tokenId) external view returns (
        address creator,
        string memory contentHash,
        string memory aiModelHash,
        bool copyrightClaimed,
        uint256 contributorCount,
        uint256 totalShares
    ) {
        Work storage w = _works[tokenId];
        return (w.creator, w.contentHash, w.aiModelHash, w.copyrightClaimed, w.contributors.length, w.totalShares);
    }
}

from dataclasses import dataclass, field
from typing import List, Dict
from datetime import datetime

@dataclass
class Contributor:
    wallet: str
    role: str           # 编剧 / 导演 / 剪辑 / AI模型 / 训练数据池
    share_bps: int      # 基点，10000 = 100%
    is_human: bool
    evidence_hash: str

@dataclass
class UsageEvent:
    timestamp: datetime
    usage_type: str     # 授权 / 二级转售 / 流媒体播放
    gross_revenue: float
    platform_fee_bps: int  # 平台抽成基点

@dataclass
class AIGCWork:
    token_id: int
    content_hash: str
    ai_model_hash: str
    contributors: List[Contributor] = field(default_factory=list)
    usage_events: List[UsageEvent] = field(default_factory=list)

    def register_contributor(self, c: Contributor) -> None:
        self.contributors.append(c)

    def validate_shares(self) -> bool:
        total = sum(c.share_bps for c in self.contributors)
        if total != 10000:
            print(f"[WARN] shares sum {total} != 10000")
            return False
        return True

    def record_usage(self, event: UsageEvent) -> None:
        self.usage_events.append(event)

    def distribute(self) -> Dict[str, float]:
        """根据链上贡献结构分配所有使用事件的净收益"""
        if not self.validate_shares():
            raise ValueError("invalid contributor shares")
        payouts: Dict[str, float] = {c.wallet: 0.0 for c in self.contributors}
        for ev in self.usage_events:
            net = ev.gross_revenue * (10000 - ev.platform_fee_bps) / 10000
            for c in self.contributors:
                share = net * c.share_bps / 10000
                payouts[c.wallet] += share
        return payouts

    def report(self) -> None:
        print(f"=== AIGC 作品 #{self.token_id} 收益分配报告 ===")
        print(f"内容哈希: {self.content_hash}")
        print(f"AI模型:   {self.ai_model_hash}")
        print(f"贡献者数: {len(self.contributors)}")
        print("-" * 50)
        payouts = self.distribute()
        for c in self.contributors:
            tag = "人类" if c.is_human else "AI/数据"
            print(f"{c.role:8s} | {tag} | {c.wallet[:10]}... | "
                  f"分成 {c.share_bps/100:.2f}% | 累计 {payouts[c.wallet]:.2f}")
        print("-" * 50)
        print(f"总使用事件: {len(self.usage_events)}")

if __name__ == "__main__":
    work = AIGCWork(
        token_id=42,
        content_hash="QmXyz...AI生成短片",
        ai_model_hash="model-v3.2-hash"
    )
    work.register_contributor(Contributor("0xA1...导演", "导演", 3000, True, "导演阐述哈希"))
    work.register_contributor(Contributor("0xB2...编剧", "编剧", 2500, True, "剧本终稿哈希"))
    work.register_contributor(Contributor("0xC3...剪辑", "剪辑", 1500, True, "EDL时间线哈希"))
    work.register_contributor(Contributor("0xD4...AI公司", "AI模型", 2000, False, "模型版本哈希"))
    work.register_contributor(Contributor("0xE5...数据池", "训练数据", 1000, False, "数据集Merkle根"))
    work.record_usage(UsageEvent(datetime.now(), "流媒体播放", 10000.0, 1500))
    work.record_usage(UsageEvent(datetime.now(), "授权使用", 5000.0, 1000))
    work.record_usage(UsageEvent(datetime.now(), "二级转售", 8000.0, 2500))
    work.report()

// AIGC人机协作创作日志 —— 将每一次人类创意决策与AI生成记录上链
const { ethers } = require("ethers");

// 创作日志条目结构
class CreationLogEntry {
  constructor(stage, humanInput, aiOutput, decisionHash, timestamp) {
    this.stage = stage;             // 阶段：剧本/分镜/拍摄/剪辑/调色/混音
    this.humanInput = humanInput;   // 人类输入（提示词/修改意见/选择）
    this.aiOutput = aiOutput;       // AI输出哈希
    this.decisionHash = decisionHash; // 人类决策的哈希
    this.timestamp = timestamp;    // 时间戳
  }
}

// 创作日志管理器
class CreationLedger {
  constructor(workTokenId, registryAddress, providerUrl, privateKey) {
    this.workTokenId = workTokenId;
    this.entries = [];
    this.provider = new ethers.JsonRpcProvider(providerUrl);
    this.wallet = new ethers.Wallet(privateKey, this.provider);
    this.registry = new ethers.Contract(
      registryAddress,
      ["function appendLog(uint256 tokenId, string memory stage, string memory humanInput, string memory aiOutput, string memory decisionHash) external"],
      this.wallet
    );
  }

  // 记录一次人机协作的创作决策
  async logCreationStep(stage, humanInput, aiOutputContent) {
    const decisionHash = ethers.keccak256(
      ethers.toUtf8Bytes(humanInput + aiOutputContent + Date.now())
    );
    const aiHash = ethers.keccak256(ethers.toUtf8Bytes(aiOutputContent));
    const entry = new CreationLogEntry(
      stage, humanInput, aiHash, decisionHash, Date.now()
    );
    this.entries.push(entry);
    // 上链记录
    const tx = await this.registry.appendLog(
      this.workTokenId, stage, humanInput, aiHash, decisionHash
    );
    await tx.wait();
    console.log(`[链上记录] 阶段: ${stage} | 决策哈希: ${decisionHash.slice(0, 18)}...`);
    return entry;
  }

  // 生成创作链路报告，用于版权确权
  generateAuthorshipReport() {
    console.log(`\n=== 作品 #${this.workTokenId} 创作链路报告 ===`);
    let humanDecisionCount = 0;
    let aiGenerationCount = 0;
    for (const e of this.entries) {
      console.log(`[${e.stage}] 人类输入: "${e.humanInput.slice(0, 40)}..." | AI输出哈希: ${e.aiOutput.slice(0, 18)}... | 决策哈希: ${e.decisionHash.slice(0, 18)}...`);
      if (e.humanInput && e.humanInput.length > 0) humanDecisionCount++;
      aiGenerationCount++;
    }
    console.log(`\n人类创意决策次数: ${humanDecisionCount}`);
    console.log(`AI生成次数: ${aiGenerationCount}`);
    console.log(`人类决策占比: ${((humanDecisionCount / aiGenerationCount) * 100).toFixed(1)}%`);
    console.log("=== 该报告可作为人类作者身份的链上证据 ===\n");
  }
}

// 示例使用：模拟一部AI辅助短片的创作全过程
async function main() {
  const ledger = new CreationLedger(
    42,
    "0xRegistry...",
    "https://rpc-testnet.example.com",
    "0x" + "ab".repeat(32) // 演示私钥，实际应从安全存储读取
  );
  await ledger.logCreationStep("剧本", "一位老放映员在数字影厅里寻找最后一卷胶片", "AI生成的三幕剧初稿...");
  await ledger.logCreationStep("分镜", "开场用固定长镜头，光线从背后打来", "AI生成的12张分镜画面...");
  await ledger.logCreationStep("剪辑", "第二幕节奏放缓，留白增加两秒", "AI生成的剪辑建议...");
  await ledger.logCreationStep("调色", "整体偏暖橙调，高光略压暗", "AI生成的调色LUT...");
  await ledger.logCreationStep("混音", "环境声增强，对白降低2dB", "AI生成的混音方案...");
  ledger.generateAuthorshipReport();
}

main().catch(console.error);