《放大》与数据放大：安东尼奥尼的链上数据观

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

contract OnChainDataMagnifier {
    struct DataPoint {
        uint256 id;
        address source;
        string dataType;
        string rawData;
        uint256 timestamp;
        uint256 magnification;
        string[] interpretations;
    }

    struct AnalysisResult {
        uint256 resultId;
        uint256 dataPointId;
        address analyst;
        string finding;
        uint256 confidence;
        string[] evidence;
    }

    mapping(uint256 => DataPoint) public dataPoints;
    mapping(uint256 => AnalysisResult[]) public analysisResults;
    uint256 public dataCounter;
    uint256 public resultCounter;

    event DataRecorded(uint256 indexed dataPointId, address indexed source, string dataType);
    event AnalysisSubmitted(uint256 indexed resultId, uint256 indexed dataPointId, string finding);

    function recordData(string calldata dataType, string calldata rawData) external returns (uint256) {
        dataCounter++;
        dataPoints[dataCounter] = DataPoint(dataCounter, msg.sender, dataType, rawData, block.timestamp, 1, new string[](0));
        emit DataRecorded(dataCounter, msg.sender, dataType);
        return dataCounter;
    }

    function analyzeData(uint256 dataPointId, string calldata finding, uint256 confidence, string[] calldata evidence) external {
        resultCounter++;
        analysisResults[dataPointId].push(AnalysisResult(resultCounter, dataPointId, msg.sender, finding, confidence, evidence));
        emit AnalysisSubmitted(resultCounter, dataPointId, finding);
    }

    function getData(uint256 dataPointId) external view returns (DataPoint memory) {
        return dataPoints[dataPointId];
    }

    function getAnalyses(uint256 dataPointId) external view returns (AnalysisResult[] memory) {
        return analysisResults[dataPointId];
    }
}

class DataMagnifier:
    def __init__(self):
        self.data_points = {}

    def record_tx(self, tx_id, from_addr, to_addr, value, data):
        self.data_points[tx_id] = {"from": from_addr, "to": to_addr, "value": value, "data": data, "analyses": []}

    def magnify(self, tx_id, level):
        dp = self.data_points.get(tx_id)
        if not dp: return None
        if level == 1:
            return {"level": "basic", "info": f"{dp["from"]} -> {dp["to"]}: {dp["value"]}"}
        elif level == 2:
            return {"level": "detailed", "info": dp}
        elif level == 3:
            return {"level": "contextual", "context": "在放大镜下，数据变得更加模糊..."}
        return None

    def add_analysis(self, tx_id, analyst, finding, confidence):
        dp = self.data_points.get(tx_id)
        if dp:
            dp["analyses"].append({"analyst": analyst, "finding": finding, "confidence": confidence})

mag = DataMagnifier()
mag.record_tx("tx_001", "0xPhotographer", "0xPark", 1000, "照片数据")
print(mag.magnify("tx_001", 1))
mag.add_analysis("tx_001", "0xAnalyst", "可能的谋杀证据", 0.6)
print(mag.data_points["tx_001"]["analyses"])

class DataExplorer {
  constructor() {
    this.data = new Map();
    this.zoomLevel = 1;
  }

  addDataPoint(id, source, type, raw) {
    this.data.set(id, { source, type, raw, timestamp: Date.now(), analyses: [] });
  }

  zoomIn(id) {
    const dp = this.data.get(id);
    if (!dp) return null;
    this.zoomLevel++;
    if (this.zoomLevel === 2) return { ...dp, detail: "放大中..." };
    if (this.zoomLevel >= 3) return { ...dp, detail: "像素化，无法辨认" };
    return dp;
  }

  zoomOut() {
    this.zoomLevel = Math.max(1, this.zoomLevel - 1);
    return { zoomLevel: this.zoomLevel };
  }

  addAnalysis(id, analyst, finding, confidence) {
    const dp = this.data.get(id);
    if (dp) dp.analyses.push({ analyst, finding, confidence, timestamp: Date.now() });
  }

  getTruth(id) {
    const dp = this.data.get(id);
    if (!dp) return null;
    const avgConfidence = dp.analyses.reduce((s, a) => s + a.confidence, 0) / (dp.analyses.length || 1);
    return { data: dp.raw, analyses: dp.analyses.length, avgConfidence };
  }
}

const exp = new DataExplorer();
exp.addDataPoint("tx_001", "0xThomas", "photo", "公园照片的链上哈希");
console.log(exp.zoomIn("tx_001"));
console.log(exp.zoomIn("tx_001"));