AIGC 链上确权：从内容指纹到智能合约存证的工程架构

一、AIGC 内容的版权困境：生成即侵权的灰色地带

AIGC 生成的内容在版权归属上存在根本性模糊：模型训练数据包含受版权保护的素材，生成结果是否构成侵权尚无法律定论。但一个更紧迫的工程问题是：即使法律明确了版权归属，如何证明"这段内容在某个时间点由某个系统生成"？传统的版权登记流程周期长、成本高，无法适应 AIGC 每天产出海量内容的节奏。

区块链的不可篡改性为这个问题提供了一种技术解法：将 AIGC 内容的数字指纹（哈希值）写入智能合约，利用链上时间戳证明内容的生成时间和来源。这不是法律意义上的版权确认，而是技术层面的存证——证明"某时某刻，某系统生成了某内容"。这种存证在争议发生时可以作为证据链的一环。

二、链上存证的架构设计与数据流

AIGC 链上存证系统的核心挑战是成本控制。以太坊主网写入一笔交易的 Gas 费用在 1-10 美元之间，对海量 AIGC 内容来说不可承受。因此采用"链下存储 + 链上存证"的分层架构：内容本体存储在 IPFS 或对象存储中，仅将内容哈希和元数据写入链上。

flowchart TB
    AIGC[AIGC 生成服务] --> FP[内容指纹计算 SHA-256]
    FP --> META[元数据封装]
    META --> IPFS[IPFS 存储 内容本体]
    META --> SC[智能合约存证]

    subgraph 链下层
        AIGC
        FP
        META
        IPFS
    end

    subgraph 链上层
        SC --> |事件日志| INDEX[索引服务]
    end

    VERIFY[验证服务] --> IPFS
    VERIFY --> SC
    VERIFY --> INDEX

    subgraph 应用层
        VERIFY
    end

智能合约只存储三类信息：内容哈希（32 字节）、生成者标识（地址）、时间戳（区块高度）。元数据（模型名称、Prompt 摘要、IPFS CID）通过事件日志发出，由索引服务（如 The Graph）建立查询接口。这种设计将链上存储压缩到最小，单次存证的 Gas 成本控制在 0.01 美元以下。

三、智能合约存证服务的工程实现

import hashlib
import json
import time
from dataclasses import dataclass
from web3 import Web3

@dataclass
class AIGCContent:
    """AIGC 内容数据结构"""
    content: str
    model_name: str
    prompt_hash: str  # Prompt 的哈希，避免存储原始 Prompt
    generator_address: str
    timestamp: int = int(time.time())

@dataclass
class Certificate:
    """链上存证凭证"""
    content_hash: str
    ipfs_cid: str
    tx_hash: str
    block_number: int
    generator_address: str

class ContentFingerprint:
    """内容指纹计算：多层哈希"""
    @staticmethod
    def compute(content: str, metadata: dict) -> str:
        # 第一层：内容本体哈希
        content_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()
        # 第二层：内容 + 元数据联合哈希，防止元数据篡改
        combined = json.dumps(
            {"content_hash": content_hash, **metadata},
            sort_keys=True, ensure_ascii=False
        )
        return hashlib.sha256(combined.encode("utf-8")).hexdigest()

class OnChainNotary:
    """链上存证服务"""
    # 精简的 Solidity 合约接口 ABI
    CONTRACT_ABI = json.loads('''[
        {
            "inputs": [
                {"name": "contentHash", "type": "bytes32"},
                {"name": "ipfsCid", "type": "string"}
            ],
            "name": "registerContent",
            "outputs": [],
            "stateMutability": "nonpayable",
            "type": "function"
        },
        {
            "anonymous": false,
            "inputs": [
                {"indexed": true, "name": "contentHash", "type": "bytes32"},
                {"indexed": false, "name": "generator", "type": "address"},
                {"indexed": false, "name": "ipfsCid", "type": "string"},
                {"indexed": false, "name": "timestamp", "type": "uint256"}
            ],
            "name": "ContentRegistered",
            "type": "event"
        }
    ]''')

    def __init__(self, rpc_url: str, contract_address: str, private_key: str):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.contract = self.w3.eth.contract(
            address=Web3.to_checksum_address(contract_address),
            abi=self.CONTRACT_ABI
        )
        self.account = self.w3.eth.account.from_key(private_key)

    async def register(self, content: AIGCContent, ipfs_cid: str) -> Certificate:
        """将 AIGC 内容存证上链"""
        # 计算内容指纹
        metadata = {
            "model": content.model_name,
            "prompt_hash": content.prompt_hash,
        }
        fingerprint = ContentFingerprint.compute(content.content, metadata)
        content_hash_bytes = Web3.keccak(hexstr=fingerprint)

        # 构造交易
        nonce = self.w3.eth.get_transaction_count(self.account.address)
        tx = self.contract.functions.registerContent(
            content_hash_bytes, ipfs_cid
        ).build_transaction({
            "from": self.account.address,
            "nonce": nonce,
            "gas": 100000,  # 预估 Gas 上限
            "gasPrice": self.w3.eth.gas_price,
        })

        # 签名并发送
        signed = self.account.sign_transaction(tx)
        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)

        # 等待确认
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)

        if receipt.status != 1:
            raise RuntimeError(f"交易失败，tx_hash: {tx_hash.hex()}")

        return Certificate(
            content_hash=fingerprint,
            ipfs_cid=ipfs_cid,
            tx_hash=tx_hash.hex(),
            block_number=receipt.blockNumber,
            generator_address=content.generator_address,
        )

    def verify(self, content: str, metadata: dict, claimed_hash: str) -> bool:
        """验证内容是否与链上存证一致"""
        computed = ContentFingerprint.compute(content, metadata)
        return computed == claimed_hash

关键设计：ContentFingerprint.compute 使用双层哈希，第一层锁定内容本体，第二层绑定元数据，防止任何一方被篡改；智能合约只存储 32 字节的哈希值和 IPFS CID，将 Gas 成本压缩到最低；verify 方法提供链下快速验证，无需链上查询。

四、链上存证方案的 Trade-offs 分析

法律效力有限：链上存证只能证明"某时某刻某地址提交了某哈希"，不能证明内容的原创性或版权归属。如果训练数据本身侵权，存证反而可能成为侵权证据。存证是技术手段，不是法律保障。

链上成本与确认延迟：即使优化后单次存证 Gas 成本约 0.01 美元，日生成 10 万条内容的存证费用仍达 1000 美元/天。可考虑批量存证：将多个内容哈希构建 Merkle 树，只将根哈希上链，单次交易存证数百条内容。但批量存证牺牲了单条内容的即时确认能力。

隐私泄露风险：内容哈希本身不泄露内容，但如果攻击者已知部分内容（如公开的 AIGC 图片），可以通过暴力比对哈希值验证。对隐私敏感的场景，建议在哈希计算前加入随机盐值，但盐值需要安全存储，增加了密钥管理复杂度。

跨链互操作：不同链上的存证无法互相验证。如果业务需要多链部署，需要设计跨链桥或使用 LayerZero 等跨链协议同步存证状态，架构复杂度显著增加。

五、总结

AIGC 链上存证的核心价值是提供技术层面的时间戳证明，而非法律层面的版权确认。工程实现上，"链下存储 + 链上存证"的分层架构通过最小化链上数据将成本控制在可接受范围。双层哈希机制保障了内容与元数据的完整性，Merkle 树批量存证可进一步降低成本。但需要清醒认识到存证的法律效力有限，且存在隐私泄露和跨链互操作的工程挑战。建议在部署前明确存证的法律定位，避免给用户造成"上链即确权"的误解。