去中心化存储与内容分发：CDN的链上替代方案

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

contract DecentralizedCDN {
    struct Content {
        bytes32 contentHash;
        address publisher;
        string cid;
        uint256 size;
        uint256 replicas;
        uint256 timestamp;
        bool active;
        uint256 totalDownloads;
    }

    struct Node {
        address nodeAddress;
        uint256 storageCapacity;
        uint256 usedSpace;
        uint256 bandwidth;
        uint256 reputation;
        bool active;
    }

    mapping(bytes32 => Content) public contents;
    mapping(address => Node) public nodes;
    mapping(bytes32 => address[]) public contentNodes;

    event ContentPublished(bytes32 hash, address publisher, string cid);
    event ContentDownloaded(bytes32 hash, address user);
    event NodeRegistered(address node, uint256 capacity);

    function publishContent(string calldata cid, uint256 size, uint256 replicas) 
        external returns (bytes32) {
        bytes32 hash = keccak256(abi.encodePacked(cid, msg.sender, block.timestamp));
        contents[hash] = Content({
            contentHash: hash,
            publisher: msg.sender,
            cid: cid,
            size: size,
            replicas: replicas,
            timestamp: block.timestamp,
            active: true,
            totalDownloads: 0
        });
        emit ContentPublished(hash, msg.sender, cid);
        return hash;
    }

    function registerNode(uint256 capacity) external {
        nodes[msg.sender] = Node({
            nodeAddress: msg.sender,
            storageCapacity: capacity,
            usedSpace: 0,
            bandwidth: 0,
            reputation: 100,
            active: true
        });
        emit NodeRegistered(msg.sender, capacity);
    }

    function downloadContent(bytes32 hash) external {
        Content storage c = contents[hash];
        require(c.active, "Content not active");
        c.totalDownloads++;
        emit ContentDownloaded(hash, msg.sender);
    }
}

import json
import random
from typing import Dict, List

class CDNAnalyzer:
    def simulate_network(self, n_nodes: int = 50, n_contents: int = 100) -> Dict:
        nodes = [{'id': i, 'capacity': random.randint(100, 1000), 'bandwidth': random.randint(10, 100)} 
                 for i in range(n_nodes)]
        contents = [{'id': i, 'size': random.randint(1, 100), 'downloads': random.randint(0, 1000)} 
                    for i in range(n_contents)]
        total_capacity = sum(n['capacity'] for n in nodes)
        total_bandwidth = sum(n['bandwidth'] for n in nodes)
        return {
            'total_nodes': n_nodes,
            'total_capacity': total_capacity,
            'total_bandwidth': total_bandwidth,
            'total_downloads': sum(c['downloads'] for c in contents),
            'avg_speed': total_bandwidth / n_nodes
        }


analyzer = CDNAnalyzer()
result = analyzer.simulate_network()
print(json.dumps(result, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const app = express();
app.use(express.json());

const CDN_ABI = [
    "function publishContent(string cid, uint256 size, uint256 replicas) external returns (bytes32)",
    "function registerNode(uint256 capacity) external",
    "function downloadContent(bytes32 hash) external",
    "event ContentPublished(bytes32 hash, address publisher, string cid)",
    "event NodeRegistered(address node, uint256 capacity)"
];

class DecentralizedCDNManager {
    constructor(providerUrl, cdnAddress) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.cdn = new ethers.Contract(cdnAddress, CDN_ABI, this.provider);
    }

    async publishContent(privateKey, cid, size, replicas) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const cdn = this.cdn.connect(wallet);
        const tx = await cdn.publishContent(cid, size, replicas);
        return await tx.wait();
    }
}

app.post('/api/cdn/publish', async (req, res) => {
    const { privateKey, cid, size, replicas } = req.body;
    const manager = new DecentralizedCDNManager(process.env.RPC_URL, process.env.CDN_ADDRESS);
    const receipt = await manager.publishContent(privateKey, cid, size, replicas);
    res.json(receipt);
});

app.listen(3021, () => {
    console.log('Decentralized CDN API running on port 3021');
});