链上公证与数字版权：区块链的版权存证

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

contract CopyrightRegistry {
    using SafeERC20 for IERC20;

    struct Copyright {
        bytes32 contentHash;
        address creator;
        uint256 timestamp;
        string title;
        string description;
        string metadata;
        CopyrightStatus status;
        License[] licenses;
        uint256 licenseCount;
    }

    struct License {
        address licensee;
        uint256 startTime;
        uint256 duration;
        LicenseType licenseType;
        uint256 fee;
        bool active;
    }

    enum CopyrightStatus { UNREGISTERED, REGISTERED, DISPUTED, TRANSFERRED }
    enum LicenseType { 
        FREE,           // 免费授权
        COMMERCIAL,     // 商业授权
        EXCLUSIVE,      // 独家授权
        DERIVATIVE      // 衍生作品授权
    }

    mapping(bytes32 => Copyright) public copyrights;
    mapping(address => bytes32[]) public creatorWorks;
    mapping(bytes32 => address) public hashToCreator;
    mapping(bytes32 => bool) public registeredHashes;

    uint256 public registrationFee = 0.01 ether;
    address public admin;
    IERC20 public paymentToken;

    event CopyrightRegistered(bytes32 indexed contentHash, address indexed creator, string title);
    event LicenseGranted(bytes32 indexed contentHash, address indexed licensee, LicenseType licenseType);
    event CopyrightTransferred(bytes32 indexed contentHash, address indexed from, address indexed to);
    event DisputeFiled(bytes32 indexed contentHash, address indexed challenger, string reason);
    event DisputeResolved(bytes32 indexed contentHash, bool resolved);

    constructor(address _paymentToken) {
        admin = msg.sender;
        paymentToken = IERC20(_paymentToken);
    }

    modifier onlyCreator(bytes32 contentHash) {
        require(copyrights[contentHash].creator == msg.sender, "Not the creator");
        _;
    }

    function registerCopyright(
        bytes32 contentHash,
        string calldata title,
        string calldata description,
        string calldata metadata
    ) external payable returns (bytes32) {
        require(!registeredHashes[contentHash], "Content already registered");
        require(msg.value >= registrationFee, "Insufficient fee");
        require(bytes(title).length > 0, "Title required");

        Copyright storage c = copyrights[contentHash];
        c.contentHash = contentHash;
        c.creator = msg.sender;
        c.timestamp = block.timestamp;
        c.title = title;
        c.description = description;
        c.metadata = metadata;
        c.status = CopyrightStatus.REGISTERED;

        registeredHashes[contentHash] = true;
        hashToCreator[contentHash] = msg.sender;
        creatorWorks[msg.sender].push(contentHash);

        emit CopyrightRegistered(contentHash, msg.sender, title);
        return contentHash;
    }

    function grantLicense(
        bytes32 contentHash,
        address licensee,
        LicenseType licenseType,
        uint256 durationDays,
        uint256 fee
    ) external onlyCreator(contentHash) {
        Copyright storage c = copyrights[contentHash];
        require(c.status == CopyrightStatus.REGISTERED, "Invalid status");

        if (fee > 0) {
            paymentToken.safeTransferFrom(licensee, msg.sender, fee);
        }

        License memory newLicense = License({
            licensee: licensee,
            startTime: block.timestamp,
            duration: durationDays * 1 days,
            licenseType: licenseType,
            fee: fee,
            active: true
        });

        c.licenses.push(newLicense);
        c.licenseCount++;

        emit LicenseGranted(contentHash, licensee, licenseType);
    }

    function transferCopyright(bytes32 contentHash, address newOwner) 
        external onlyCreator(contentHash) {
        Copyright storage c = copyrights[contentHash];
        require(newOwner != address(0), "Invalid owner");
        require(newOwner != msg.sender, "Same owner");

        address oldCreator = c.creator;
        c.creator = newOwner;
        c.status = CopyrightStatus.TRANSFERRED;
        hashToCreator[contentHash] = newOwner;

        // Update creator listings
        bytes32[] storage oldList = creatorWorks[oldCreator];
        for (uint256 i = 0; i < oldList.length; i++) {
            if (oldList[i] == contentHash) {
                oldList[i] = oldList[oldList.length - 1];
                oldList.pop();
                break;
            }
        }
        creatorWorks[newOwner].push(contentHash);

        emit CopyrightTransferred(contentHash, oldCreator, newOwner);
    }

    function fileDispute(bytes32 contentHash, string calldata reason) external {
        require(registeredHashes[contentHash], "Content not registered");
        require(copyrights[contentHash].creator != msg.sender, "Cannot dispute own work");
        require(copyrights[contentHash].status == CopyrightStatus.REGISTERED, "Invalid status");

        copyrights[contentHash].status = CopyrightStatus.DISPUTED;
        emit DisputeFiled(contentHash, msg.sender, reason);
    }

    function resolveDispute(bytes32 contentHash, bool inFavorOfCreator) 
        external {
        require(msg.sender == admin, "Only admin");
        require(copyrights[contentHash].status == CopyrightStatus.DISPUTED, "No dispute");

        if (inFavorOfCreator) {
            copyrights[contentHash].status = CopyrightStatus.REGISTERED;
        } else {
            copyrights[contentHash].status = CopyrightStatus.UNREGISTERED;
            registeredHashes[contentHash] = false;
        }

        emit DisputeResolved(contentHash, inFavorOfCreator);
    }

    function verifyCopyright(bytes32 contentHash) 
        external view returns (bool, address, uint256) {
        Copyright storage c = copyrights[contentHash];
        if (c.status == CopyrightStatus.REGISTERED) {
            return (true, c.creator, c.timestamp);
        }
        return (false, address(0), 0);
    }

    function getCreatorWorks(address creator) 
        external view returns (bytes32[] memory) {
        return creatorWorks[creator];
    }

    function getLicenseInfo(bytes32 contentHash, uint256 licenseIndex) 
        external view returns (License memory) {
        return copyrights[contentHash].licenses[licenseIndex];
    }
}

import hashlib
import time
import json
from typing import Dict, List, Tuple
from dataclasses import dataclass
from datetime import datetime
import requests
import os

@dataclass
class CopyrightRecord:
    content_hash: str
    creator: str
    timestamp: float
    title: str
    description: str
    previous_hash: str
    block_number: int

class CopyrightChain:
    def __init__(self):
        self.chain: List[CopyrightRecord] = []
        self.creators: Dict[str, List[str]] = {}
        self.registered_hashes: set = set()

    def calculate_hash(self, content: bytes) -> str:
        """Calculate SHA-256 hash of content"""
        return hashlib.sha256(content).hexdigest()

    def calculate_file_hash(self, file_path: str) -> str:
        """Calculate hash of a file"""
        sha256_hash = hashlib.sha256()
        with open(file_path, "rb") as f:
            for byte_block in iter(lambda: f.read(4096), b""):
                sha256_hash.update(byte_block)
        return sha256_hash.hexdigest()

    def register_copyright(self, content: bytes, creator: str, 
                          title: str, description: str) -> CopyrightRecord:
        """Register a new copyright on the chain"""
        content_hash = self.calculate_hash(content)
        return self.register_by_hash(content_hash, creator, title, description)

    def register_by_hash(self, content_hash: str, creator: str,
                        title: str, description: str) -> CopyrightRecord:
        """Register copyright using pre-computed hash"""
        if content_hash in self.registered_hashes:
            raise ValueError("Content already registered")

        previous_hash = self.chain[-1].content_hash if self.chain else "0" * 64

        record = CopyrightRecord(
            content_hash=content_hash,
            creator=creator,
            timestamp=time.time(),
            title=title,
            description=description,
            previous_hash=previous_hash,
            block_number=len(self.chain)
        )

        self.chain.append(record)
        self.registered_hashes.add(content_hash)

        if creator not in self.creators:
            self.creators[creator] = []
        self.creators[creator].append(content_hash)

        return record

    def verify_copyright(self, content: bytes, creator: str) -> Dict:
        """Verify if content is registered to a specific creator"""
        content_hash = self.calculate_hash(content)
        return self.verify_by_hash(content_hash, creator)

    def verify_by_hash(self, content_hash: str, creator: str) -> Dict:
        """Verify copyright by hash"""
        if content_hash not in self.registered_hashes:
            return {
                "verified": False,
                "reason": "Content not registered"
            }

        for record in self.chain:
            if record.content_hash == content_hash:
                if record.creator == creator:
                    return {
                        "verified": True,
                        "creator": record.creator,
                        "timestamp": record.timestamp,
                        "title": record.title,
                        "block_number": record.block_number,
                        "chain_proof": self._generate_chain_proof(record)
                    }
                else:
                    return {
                        "verified": False,
                        "reason": "Creator mismatch",
                        "actual_creator": record.creator
                    }

        return {"verified": False, "reason": "Chain error"}

    def _generate_chain_proof(self, record: CopyrightRecord) -> List[str]:
        """Generate Merkle-style proof for the record"""
        proof = []
        current_hash = record.content_hash

        for chain_record in reversed(self.chain):
            if chain_record.content_hash == current_hash:
                proof.append(chain_record.previous_hash)
                current_hash = chain_record.previous_hash
                if current_hash == "0" * 64:
                    break

        return proof

    def detect_plagiarism(self, content: bytes, threshold: float = 0.8) -> List[Dict]:
        """Detect potential plagiarism by comparing with registered content"""
        content_hash = self.calculate_hash(content)
        results = []

        for record in self.chain:
            if record.content_hash == content_hash:
                continue

            # In production, use actual content comparison
            # Here we simulate with hash similarity
            similarity = self._calculate_similarity(content_hash, record.content_hash)
            if similarity > threshold:
                results.append({
                    "registered_hash": record.content_hash,
                    "registered_creator": record.creator,
                    "similarity": similarity,
                    "title": record.title,
                    "timestamp": record.timestamp
                })

        return sorted(results, key=lambda x: x['similarity'], reverse=True)

    def _calculate_similarity(self, hash1: str, hash2: str) -> float:
        """Calculate similarity between two hashes (simplified)"""
        if len(hash1) != len(hash2):
            return 0.0

        matching_chars = sum(1 for a, b in zip(hash1, hash2) if a == b)
        return matching_chars / len(hash1)

    def get_chain_integrity(self) -> bool:
        """Verify the integrity of the entire chain"""
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i - 1]

            if current.previous_hash != previous.content_hash:
                return False

            if current.content_hash in self.registered_hashes:
                continue

        return True

    def export_chain(self, file_path: str):
        """Export the chain to a JSON file"""
        export_data = []
        for record in self.chain:
            export_data.append({
                "content_hash": record.content_hash,
                "creator": record.creator,
                "timestamp": record.timestamp,
                "title": record.title,
                "description": record.description,
                "previous_hash": record.previous_hash,
                "block_number": record.block_number
            })

        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(export_data, f, indent=2, ensure_ascii=False)

    def import_chain(self, file_path: str):
        """Import chain from a JSON file"""
        with open(file_path, 'r', encoding='utf-8') as f:
            data = json.load(f)

        for item in data:
            record = CopyrightRecord(
                content_hash=item['content_hash'],
                creator=item['creator'],
                timestamp=item['timestamp'],
                title=item['title'],
                description=item['description'],
                previous_hash=item['previous_hash'],
                block_number=item['block_number']
            )
            self.chain.append(record)
            self.registered_hashes.add(item['content_hash'])

            if item['creator'] not in self.creators:
                self.creators[item['creator']] = []
            self.creators[item['creator']].append(item['content_hash'])

    def generate_copyright_certificate(self, content_hash: str) -> Dict:
        """Generate a formal copyright certificate"""
        for record in self.chain:
            if record.content_hash == content_hash:
                return {
                    "certificate_id": f"COPY-{record.block_number:06d}-{record.content_hash[:8].upper()}",
                    "content_hash": record.content_hash,
                    "creator": record.creator,
                    "registration_date": datetime.fromtimestamp(record.timestamp).isoformat(),
                    "title": record.title,
                    "description": record.description,
                    "block_number": record.block_number,
                    "chain_length": len(self.chain),
                    "chain_integrity": self.get_chain_integrity(),
                    "verification_url": f"https://explorer/verify/{record.content_hash}"
                }
        return None


# Demo
chain = CopyrightChain()

# Register some works
chain.register_copyright(
    b"This is my original screenplay about blockchain and film",
    "0xCreator1",
    "My Original Screenplay",
    "A screenplay about the intersection of blockchain and cinema"
)

chain.register_copyright(
    b"Another original work about decentralized storage",
    "0xCreator2",
    "Decentralized Visions",
    "An essay about IPFS and film preservation"
)

# Verify a work
result = chain.verify_copyright(
    b"This is my original screenplay about blockchain and film",
    "0xCreator1"
)
print(json.dumps(result, indent=2))

# Generate certificate
cert = chain.generate_copyright_certificate(
    hashlib.sha256(b"This is my original screenplay about blockchain and film").hexdigest()
)
print(json.dumps(cert, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const crypto = require('crypto');
const multer = require('multer');
const fs = require('fs');
const path = require('path');

const app = express();
const upload = multer({ dest: 'uploads/' });
app.use(express.json({ limit: '50mb' }));

const COPYRIGHT_ABI = [
    "function registerCopyright(bytes32 contentHash, string title, string description, string metadata) external payable returns (bytes32)",
    "function grantLicense(bytes32 contentHash, address licensee, uint8 licenseType, uint256 durationDays, uint256 fee) external",
    "function transferCopyright(bytes32 contentHash, address newOwner) external",
    "function verifyCopyright(bytes32 contentHash) external view returns (bool, address, uint256)",
    "event CopyrightRegistered(bytes32 indexed contentHash, address indexed creator, string title)",
    "event LicenseGranted(bytes32 indexed contentHash, address indexed licensee, uint8 licenseType)"
];

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

    calculateContentHash(content) {
        return ethers.utils.solidityKeccak256(['string'], [content]);
    }

    calculateFileHash(fileBuffer) {
        return ethers.utils.keccak256(fileBuffer);
    }

    async register(privateKey, title, description, metadata, contentHash) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.contract.connect(wallet);

        const tx = await contract.registerCopyright(
            contentHash,
            title,
            description,
            metadata,
            { value: ethers.utils.parseEther('0.01') }
        );
        const receipt = await tx.wait();
        return receipt;
    }

    async grantLicense(privateKey, contentHash, licensee, licenseType, durationDays, fee) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.contract.connect(wallet);

        const tx = await contract.grantLicense(
            contentHash,
            licensee,
            licenseType,
            durationDays,
            ethers.utils.parseEther(fee.toString())
        );
        const receipt = await tx.wait();
        return receipt;
    }
}

app.post('/api/copyright/register', upload.single('file'), async (req, res) => {
    const { privateKey, title, description, metadata } = req.body;
    const fileBuffer = fs.readFileSync(req.file.path);
    const platform = new CopyrightPlatform(
        process.env.RPC_URL,
        process.env.COPYRIGHT_ADDRESS
    );
    const contentHash = platform.calculateFileHash(fileBuffer);
    const receipt = await platform.register(privateKey, title, description, metadata, contentHash);
    fs.unlinkSync(req.file.path);
    res.json({ contentHash, receipt });
});

app.post('/api/copyright/verify', async (req, res) => {
    const { contentHash } = req.body;
    const platform = new CopyrightPlatform(
        process.env.RPC_URL,
        process.env.COPYRIGHT_ADDRESS
    );
    const result = await platform.contract.verifyCopyright(contentHash);
    res.json({
        registered: result[0],
        creator: result[1],
        timestamp: result[2].toNumber()
    });
});

app.post('/api/copyright/license', async (req, res) => {
    const { privateKey, contentHash, licensee, licenseType, durationDays, fee } = req.body;
    const platform = new CopyrightPlatform(
        process.env.RPC_URL,
        process.env.COPYRIGHT_ADDRESS
    );
    const receipt = await platform.grantLicense(
        privateKey, contentHash, licensee, licenseType, durationDays, fee
    );
    res.json(receipt);
});

app.listen(3009, () => {
    console.log('Copyright Registry API running on port 3009');
});