多链生态与内容分发：从单一链到跨链互操作

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

contract CrossChainContentDistributor {
    address public owner;
    mapping(uint256 => Content) public contents;
    mapping(uint256 => mapping(uint256 => bool)) public contentOnChain;
    uint256 public contentCounter;

    struct Content {
        uint256 contentId;
        address creator;
        string title;
        string contentURI;
        uint256 originalChainId;
        uint256[] distributedChains;
        uint256 createdAt;
        bool isActive;
    }

    struct ChainInfo {
        string chainName;
        uint256 chainId;
        address bridgeContract;
        bool isSupported;
    }

    mapping(uint256 => ChainInfo) public supportedChains;
    uint256 public chainCounter;

    event ContentCreated(uint256 indexed contentId, address indexed creator, string title);
    event ContentDistributed(uint256 indexed contentId, uint256 indexed chainId);

    constructor() { owner = msg.sender; }

    function addChain(uint256 chainId, string calldata chainName, address bridgeContract) external {
        require(msg.sender == owner, "Not owner");
        chainCounter++;
        supportedChains[chainId] = ChainInfo(chainName, chainId, bridgeContract, true);
    }

    function createContent(string calldata title, string calldata contentURI, uint256 originalChainId) external returns (uint256) {
        contentCounter++;
        contents[contentCounter] = Content(contentCounter, msg.sender, title, contentURI, originalChainId, new uint256[](0), block.timestamp, true);
        emit ContentCreated(contentCounter, msg.sender, title);
        return contentCounter;
    }

    function distributeContent(uint256 contentId, uint256 targetChainId) external {
        Content storage c = contents[contentId];
        require(c.creator == msg.sender, "Not creator");
        require(supportedChains[targetChainId].isSupported, "Not supported");
        require(!contentOnChain[contentId][targetChainId], "Already distributed");
        contentOnChain[contentId][targetChainId] = true;
        c.distributedChains.push(targetChainId);
        emit ContentDistributed(contentId, targetChainId);
    }

    function getContent(uint256 contentId) external view returns (Content memory) {
        return contents[contentId];
    }
}

from enum import Enum

class ChainType(Enum):
    ETH = "ethereum"
    SOL = "solana"
    POLY = "polygon"

class CrossChainRouter:
    def __init__(self):
        self.chains = {}
        self.bridges = {}

    def add_chain(self, chain, config):
        self.chains[chain] = config

    def add_bridge(self, a, b, cfg):
        self.bridges[(a, b)] = cfg

    def find_route(self, src, tgt):
        if src == tgt:
            return {"route": [src], "latency": 0}
        visited = {src}
        q = [(src, [src], 0)]
        while q:
            cur, path, lat = q.pop(0)
            for (a, b), br in self.bridges.items():
                nxt = None
                if a == cur and b not in visited: nxt = b
                elif b == cur and a not in visited: nxt = a
                if nxt:
                    if nxt == tgt:
                        return {"route": path + [nxt], "latency": lat + br["latency"]}
                    visited.add(nxt)
                    q.append((nxt, path + [nxt], lat + br["latency"]))
        return None

router = CrossChainRouter()
router.add_bridge(ChainType.ETH, ChainType.POLY, {"latency": 30})
router.add_bridge(ChainType.POLY, ChainType.SOL, {"latency": 20})
r = router.find_route(ChainType.ETH, ChainType.SOL)
print(r)

class MultiChainBrowser {
  constructor() {
    this.chains = new Map();
    this.contents = new Map();
  }

  registerChain(id, name, rpc) {
    this.chains.set(id, { name, rpc, contents: [] });
  }

  async fetchFromChain(chainId, contentId) {
    const c = this.chains.get(chainId);
    if (!c) throw new Error("Chain not found");
    const content = { id: contentId, chainId, chainName: c.name };
    this.contents.set(chainId + ":" + contentId, content);
    return content;
  }

  async crossChainQuery(contentId, src, tgt) {
    console.log("Cross-chain query: " + contentId + " " + src + " -> " + tgt);
    const s = await this.fetchFromChain(src, contentId);
    const t = await this.fetchFromChain(tgt, contentId);
    return { source: s, target: t };
  }

  getStats() {
    return { chains: this.chains.size, contents: this.contents.size };
  }
}

const b = new MultiChainBrowser();
b.registerChain(1, "Ethereum", "https://eth-mainnet.g.alchemy.com");
b.registerChain(137, "Polygon", "https://polygon-rpc.com");
b.crossChainQuery("content_001", 1, 137);