《楚门的世界》与链上预言机：谁在操控你的数据来源？

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

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

/// @title TrumanOracleConsumer
/// @notice 楚门预言机消费者合约——验证链上数据是否来自"真实世界"
/// @dev 模拟多机位拍摄系统，聚合多个数据源并验证数据真实性
contract TrumanOracleConsumer is VRFConsumerBaseV2 {
    struct DataSource {
        string name;           // 数据源名称（如"摄像机A"）
        address oracleAddress; // 预言机合约地址
        uint256 lastUpdate;    // 最后更新时间
        bool isActive;         // 是否在线
    }

    struct ConsensusResult {
        int256 value;          // 共识值
        uint256 confidence;    // 置信度（0-100）
        uint256 sourceCount;   // 参与共识的数据源数量
        bool isVerified;       // 是否通过验证
    }

    AggregatorV3Interface internal priceFeed;
    VRFCoordinatorV2Interface internal vrfCoordinator;
    
    mapping(uint256 => DataSource) public dataSources;
    uint256 public sourceCount;
    
    // VRF参数
    uint64 private s_subscriptionId;
    bytes32 private s_keyHash;
    uint32 private callbackGasLimit = 100000;
    
    // 事件：数据源状态变化
    event SourceStatusChanged(uint256 indexed sourceId, string name, bool isActive);
    event ConsensusReached(int256 value, uint256 confidence);
    event DataTamperingDetected(uint256 indexed sourceId, string reason);

    constructor(
        address _priceFeed,
        address _vrfCoordinator,
        uint64 _subscriptionId,
        bytes32 _keyHash
    ) VRFConsumerBaseV2(_vrfCoordinator) {
        priceFeed = AggregatorV3Interface(_priceFeed);
        vrfCoordinator = VRFCoordinatorV2Interface(_vrfCoordinator);
        s_subscriptionId = _subscriptionId;
        s_keyHash = _keyHash;
    }

    /// @notice 注册新的数据源（相当于增加一台摄像机）
    function registerDataSource(string calldata name, address oracleAddr) external {
        sourceCount++;
        dataSources[sourceCount] = DataSource({
            name: name,
            oracleAddress: oracleAddr,
            lastUpdate: block.timestamp,
            isActive: true
        });
        emit SourceStatusChanged(sourceCount, name, true);
    }

    /// @notice 从多个数据源获取共识数据
    /// @dev 相当于导播台对比多个机位的画面信号
    function getConsensusData() external view returns (ConsensusResult memory) {
        require(sourceCount >= 3, "TrumanOracle: 至少需要3个数据源才能形成共识");
        
        int256[] memory values = new int256[](sourceCount);
        uint256 validCount = 0;
        int256 sum = 0;

        for (uint256 i = 1; i <= sourceCount; i++) {
            if (!dataSources[i].isActive) continue;
            
            try priceFeed.latestRoundData() returns (
                uint80, int256 answer, uint256, uint256 updatedAt, uint80
            ) {
                // 验证数据新鲜度：不超过30分钟
                if (block.timestamp - updatedAt <= 1800) {
                    values[validCount] = answer;
                    sum += answer;
                    validCount++;
                } else {
                    emit DataTamperingDetected(i, "数据过期，镜头信号超时");
                }
            } catch {
                emit DataTamperingDetected(i, "数据源异常，镜头信号丢失");
            }
        }

        require(validCount >= 3, "TrumanOracle: 可用数据源不足，无法形成共识");
        
        int256 average = sum / int256(validCount);
        uint256 confidence = (validCount * 100) / sourceCount;

        return ConsensusResult({
            value: average,
            confidence: confidence,
            sourceCount: validCount,
            isVerified: confidence >= 70
        });
    }

    /// @notice 验证单个数据源是否可信
    /// @dev 相当于楚门验证某个路人的话是否可信
    function verifyDataSource(uint256 sourceId) external view returns (bool, string memory) {
        DataSource memory source = dataSources[sourceId];
        require(source.isActive, "TrumanOracle: 数据源已下线");
        
        uint256 timeSinceLastUpdate = block.timestamp - source.lastUpdate;
        
        if (timeSinceLastUpdate > 3600) {
            return (false, "数据源长时间未更新，可能已被克里斯托夫控制");
        }
        
        // 验证数据源的一致性
        try priceFeed.latestRoundData() returns (
            uint80, int256, uint256, uint256 updatedAt, uint80
        ) {
            if (updatedAt < source.lastUpdate) {
                return (false, "数据源时间戳异常，可能被篡改");
            }
            return (true, "数据源可信");
        } catch {
            return (false, "数据源通信失败");
        }
    }

    /// @notice 请求可验证随机数——打破克里斯托夫的"剧本"
    /// @dev 使用Chainlink VRF生成不可预测的随机数
    function requestRandomNumber() external returns (uint256 requestId) {
        return vrfCoordinator.requestRandomWords(
            s_keyHash,
            s_subscriptionId,
            3, // minimumConfirmations
            callbackGasLimit,
            1 // numWords
        );
    }

    /// @notice VRF回调函数——接收可验证的随机数
    function fulfillRandomWords(uint256, uint256[] memory randomWords) internal override {
        uint256 randomNumber = randomWords[0];
        // 使用随机数选择一个"信任"的数据源
        uint256 trustedSourceId = (randomNumber % sourceCount) + 1;
        // 这个随机选择过程相当于楚门随机选择一扇门走出去
        emit SourceStatusChanged(trustedSourceId, dataSources[trustedSourceId].name, true);
    }
}

"""
楚门数据追踪器
验证链上数据的来源和真实性
相当于电影片场的"数字场记"系统
"""

import hashlib
import json
import time
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
from enum import Enum
import requests
from collections import Counter


class DataSourceType(Enum):
    """数据源类型——相当于摄像机机位类型"""
    CENTRALIZED_API = "中心化API"  # 克里斯托夫的单机位
    DECENTRALIZED_NODE = "去中心化节点"  # 独立摄像机
    TLS_PROVEN = "TLS证明"  # 带防伪标识的摄像机
    CONSENSUS_AGGREGATED = "共识聚合"  # 多机位合成信号


@dataclass
class DataProvenance:
    """数据溯源记录——相当于每帧画面的"场记单" """
    source_id: str
    source_type: DataSourceType
    data_hash: str
    timestamp: int
    tls_certificate: Optional[str] = None
    signature: Optional[str] = None
    is_verified: bool = False


class TrumanDataTracker:
    """
    楚门数据追踪器
    验证数据来源是否真实，防止"克里斯托夫"式的数据操纵
    """
    
    def __init__(self, name: str = "海景镇数据监控中心"):
        self.name = name
        self.provenance_chain: List[DataProvenance] = []
        self.data_sources: Dict[str, dict] = {}
        self.verification_log: List[str] = []
        self.consensus_threshold = 0.7  # 70%共识阈值
        
    def register_source(self, source_id: str, source_type: DataSourceType, 
                       endpoint: str, reliability: float = 0.9) -> dict:
        """注册数据源——相当于安装一台新的摄像机"""
        source = {
            "source_id": source_id,
            "type": source_type.value,
            "endpoint": endpoint,
            "reliability": reliability,
            "registered_at": int(time.time()),
            "status": "active"
        }
        self.data_sources[source_id] = source
        self._log(f"📹 数据源注册: [{source_id}] 类型={source_type.value}, 端点={endpoint}")
        return source
    
    def fetch_data(self, source_id: str, data_key: str) -> Optional[DataProvenance]:
        """从指定数据源获取数据并记录溯源信息"""
        if source_id not in self.data_sources:
            self._log(f"❌ 数据源 [{source_id}] 未注册")
            return None
        
        source = self.data_sources[source_id]
        record = None
        
        try:
            if source["type"] == DataSourceType.CENTRALIZED_API.value:
                # 模拟中心化数据源——克里斯托夫模式
                response = requests.get(f"{source['endpoint']}?key={data_key}", timeout=5)
                data = response.json()
                
                # 计算数据指纹
                data_hash = hashlib.sha256(
                    json.dumps(data, sort_keys=True).encode()
                ).hexdigest()
                
                record = DataProvenance(
                    source_id=source_id,
                    source_type=DataSourceType.CENTRALIZED_API,
                    data_hash=data_hash,
                    timestamp=int(time.time()),
                    is_verified=True  # 中心化源默认"可信"（但可能被操纵）
                )
                
                self._log(f"📡 从 [{source_id}] 获取数据: {str(data)[:50]}...")
                
            elif source["type"] == DataSourceType.DECENTRALIZED_NODE.value:
                # 模拟去中心化节点——独立摄像机模式
                response = requests.get(f"{source['endpoint']}?key={data_key}", timeout=5)
                data = response.json()
                
                # 生成签名
                data_hash = hashlib.sha256(
                    json.dumps(data, sort_keys=True).encode()
                ).hexdigest()
                
                record = DataProvenance(
                    source_id=source_id,
                    source_type=DataSourceType.DECENTRALIZED_NODE,
                    data_hash=data_hash,
                    timestamp=int(time.time()),
                    signature=self._generate_signature(data_hash, source_id),
                    is_verified=True
                )
                
                self._log(f"🔗 从去中心化节点 [{source_id}] 获取数据")
                
            elif source["type"] == DataSourceType.TLS_PROVEN.value:
                # 模拟TLS证明——带防伪标识的摄像机
                # TLS证明确保数据确实来自声明的源
                response = requests.get(f"{source['endpoint']}?key={data_key}&tls=true", timeout=5)
                data = response.json()
                
                data_hash = hashlib.sha256(
                    json.dumps(data, sort_keys=True).encode()
                ).hexdigest()
                
                # TLS证书验证
                tls_cert = data.get("tls_certificate", "tls_v1.3_verified")
                
                record = DataProvenance(
                    source_id=source_id,
                    source_type=DataSourceType.TLS_PROVEN,
                    data_hash=data_hash,
                    timestamp=int(time.time()),
                    tls_certificate=tls_cert,
                    signature=self._generate_signature(data_hash, source_id),
                    is_verified=True
                )
                
                self._log(f"🔒 TLS证明数据源 [{source_id}] 验证通过")
            
            # 记录溯源信息
            self.provenance_chain.append(record)
            return record
            
        except requests.RequestException as e:
            self._log(f"⚠️ 数据源 [{source_id}] 通信失败: {str(e)}")
            return None
    
    def consensus_check(self, data_key: str, sources: List[str]) -> dict:
        """
        多数据源共识检查
        相当于楚门向多个路人验证同一个信息
        """
        self._log(f"\n--- 开始共识检查: {data_key} ---")
        
        results = []
        hashes = []
        
        for source_id in sources:
            record = self.fetch_data(source_id, data_key)
            if record:
                results.append({
                    "source_id": source_id,
                    "data_hash": record.data_hash,
                    "timestamp": record.timestamp,
                    "has_tls": record.tls_certificate is not None,
                    "has_signature": record.signature is not None
                })
                hashes.append(record.data_hash)
        
        if len(results) < 3:
            return {
                "status": "FAILED",
                "message": "可用数据源不足3个，无法形成共识",
                "sources_available": len(results),
                "sources_required": 3
            }
        
        # 统计哈希频率——相当于对比不同路人的说法
        hash_counts = Counter(hashes)
        most_common_hash, count = hash_counts.most_common(1)[0]
        consensus_ratio = count / len(hashes)
        
        # 检测异常数据源——相当于发现"克里斯托夫的路人演员"
        anomalous_sources = []
        for result in results:
            if result["data_hash"] != most_common_hash:
                anomalous_sources.append(result["source_id"])
        
        self._log(f"📊 共识率: {consensus_ratio:.1%} ({count}/{len(hashes)})")
        
        if anomalous_sources:
            self._log(f"⚠️ 异常数据源: {', '.join(anomalous_sources)}")
            self._log(f"   → 这些数据源可能被克里斯托夫控制")
        
        is_trusted = consensus_ratio >= self.consensus_threshold
        
        # 生成共识报告
        report = {
            "status": "VERIFIED" if is_trusted else "SUSPICIOUS",
            "data_key": data_key,
            "consensus_hash": most_common_hash,
            "consensus_ratio": consensus_ratio,
            "sources_checked": len(results),
            "anomalous_sources": anomalous_sources,
            "is_trusted": is_trusted,
            "message": (
                "✅ 数据可信：多个数据源一致性验证通过"
                if is_trusted else
                "⚠️ 数据存疑：部分数据源存在异常，建议进行人工复核"
            ),
            "timestamp": int(time.time())
        }
        
        self._log(report["message"])
        return report
    
    def simulate_truman_revelation(self):
        """
        模拟楚门的"觉醒"过程
        对应数据溯源中的"发现源头被操纵"
        """
        self._log("\n" + "="*60)
        self._log("🎬 楚门觉醒模拟：当数据源被操纵")
        self._log("="*60)
        
        # 注册数据源
        self.register_source("TV_News", DataSourceType.CENTRALIZED_API, 
                           "https://truman-show.news/api", 0.95)
        self.register_source("Radio_Broadcast", DataSourceType.CENTRALIZED_API, 
                           "https://truman-show.radio/api", 0.90)
        self.register_source("Street_Pedestrian", DataSourceType.DECENTRALIZED_NODE, 
                           "https://truman-show.pedestrian/api", 0.70)
        self.register_source("Independent_Observer", DataSourceType.TLS_PROVEN, 
                           "https://truman-show.observer/api", 0.99)
        
        self._log("\n📋 楚门试图验证一个信息：'外面的世界是危险的'")
        self._log("  克里斯托夫让所有中心化数据源都给出'危险'的答案")
        self._log("  但独立观察者可能给出不同的答案...\n")
        
        # 使用所有数据源进行共识检查
        result = self.consensus_check(
            "outside_world_safety",
            ["TV_News", "Radio_Broadcast", "Street_Pedestrian", "Independent_Observer"]
        )
        
        if result["status"] == "VERIFIED":
            self._log("\n🎉 楚门找到了真相：多个独立数据源验证了信息的真实性")
        else:
            self._log("\n🔍 楚门发现了异常：部分数据源与其他不一致")
            self._log("  这就像他发现那个路人每天都说同样的话")
        
        return result
    
    def _generate_signature(self, data_hash: str, source_id: str) -> str:
        """生成数据签名"""
        message = f"{data_hash}:{source_id}:{int(time.time())}"
        return hashlib.sha256(message.encode()).hexdigest()
    
    def _log(self, message: str):
        """记录日志"""
        self.verification_log.append(message)
        print(message)


# 运行楚门数据验证模拟
if __name__ == "__main__":
    tracker = TrumanDataTracker("海景镇数据监控中心")
    
    print("🎬 《楚门的世界》× 数据溯源验证器")
    print("="*60)
    
    # 模拟楚门觉醒
    result = tracker.simulate_truman_revelation()
    
    print("\n" + "="*60)
    print("📊 验证报告")
    print("="*60)
    print(f"  状态: {result['status']}")
    print(f"  数据键: {result['data_key']}")
    print(f"  共识率: {result['consensus_ratio']:.1%}")
    print(f"  检查源数: {result['sources_checked']}")
    if result['anomalous_sources']:
        print(f"  异常源: {', '.join(result['anomalous_sources'])}")
    print(f"  结论: {result['message']}")
    print("="*60)

/**
 * 楚门预言机前端验证器
 * 模拟从多个预言机节点获取数据并验证共识
 * 相当于观众通过"多机位"验证楚门世界中的"真相"
 */

class TrumanOracleVerifier {
  constructor() {
    this.nodes = new Map();
    this.verificationHistory = [];
    this.consensusThreshold = 0.7;
    this.trustedDataSources = [];
  }

  /**
   * 注册预言机节点
   * 相当于在摄影棚中安装一台新的摄像机
   */
  registerNode(nodeId, endpoint, publicKey, location = 'unknown') {
    const node = {
      nodeId,
      endpoint,
      publicKey,
      location,
      status: 'active',
      registeredAt: Date.now(),
      lastVerified: null,
      reliability: 1.0,
      failedAttempts: 0
    };
    this.nodes.set(nodeId, node);
    console.log(`[注册节点] ${nodeId} | 位置: ${location} | 公钥: ${publicKey.slice(0, 16)}...`);
    return node;
  }

  /**
   * 从多个预言机节点获取数据
   * 相当于导播台同时接收多个摄像机的信号
   */
  async fetchFromMultipleNodes(dataKey, nodeIds = []) {
    const activeNodes = nodeIds.length > 0 
      ? nodeIds.map(id => this.nodes.get(id)).filter(n => n && n.status === 'active')
      : Array.from(this.nodes.values()).filter(n => n.status === 'active');

    if (activeNodes.length < 3) {
      throw new Error('可用节点不足3个，无法形成可靠共识');
    }

    console.log(`\n[数据请求] 键: ${dataKey} | 请求节点数: ${activeNodes.length}`);

    const responses = [];
    const promises = activeNodes.map(async (node) => {
      try {
        const response = await fetch(`${node.endpoint}?key=${dataKey}&ts=${Date.now()}`);
        
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }

        const data = await response.json();
        
        // 验证签名
        const isValid = this._verifySignature(data, node.publicKey);
        
        if (!isValid) {
          console.warn(`  ⚠️ [${node.nodeId}] 签名验证失败——数据可能被篡改`);
          return null;
        }

        // 验证数据格式
        if (!data.value || !data.timestamp) {
          console.warn(`  ⚠️ [${node.nodeId}] 数据格式异常`);
          return null;
        }

        // 检查数据新鲜度（不超过10分钟）
        const age = (Date.now() - data.timestamp) / 1000;
        if (age > 600) {
          console.warn(`  ⚠️ [${node.nodeId}] 数据过期 (${Math.round(age)}秒前)`);
          return null;
        }

        return {
          nodeId: node.nodeId,
          value: data.value,
          timestamp: data.timestamp,
          signature: data.signature,
          location: node.location,
          delay: age
        };

      } catch (error) {
        console.error(`  ❌ [${node.nodeId}] 请求失败: ${error.message}`);
        node.failedAttempts++;
        if (node.failedAttempts >= 3) {
          node.status = 'suspicious';
          console.warn(`  ⚠️ [${node.nodeId}] 连续失败3次，标记为可疑节点`);
        }
        return null;
      }
    });

    const results = await Promise.all(promises);
    const validResponses = results.filter(r => r !== null);

    console.log(`[数据收集] 成功: ${validResponses.length}/${activeNodes.length}`);

    // 共识计算
    const consensus = this._computeConsensus(validResponses);
    
    this.verificationHistory.push({
      dataKey,
      timestamp: Date.now(),
      nodeCount: validResponses.length,
      consensus
    });

    return consensus;
  }

  /**
   * 计算共识——相当于对比多个机位的画面
   */
  _computeConsensus(responses) {
    if (responses.length === 0) {
      return {
        status: 'FAILED',
        message: '所有节点均无响应——摄影棚可能被克里斯托夫控制',
        value: null,
        confidence: 0
      };
    }

    // 统计每个值的出现次数
    const valueCounts = new Map();
    responses.forEach(r => {
      const key = JSON.stringify(r.value);
      valueCounts.set(key, (valueCounts.get(key) || 0) + 1);
    });

    // 找出出现次数最多的值
    let maxCount = 0;
    let consensusValue = null;
    for (const [value, count] of valueCounts) {
      if (count > maxCount) {
        maxCount = count;
        consensusValue = JSON.parse(value);
      }
    }

    const consensusRatio = maxCount / responses.length;
    const isTrusted = consensusRatio >= this.consensusThreshold;

    // 检测异常节点
    const anomalousNodes = responses.filter(r => 
      JSON.stringify(r.value) !== JSON.stringify(consensusValue)
    );

    if (anomalousNodes.length > 0) {
      console.warn(`[异常检测] 发现 ${anomalousNodes.length} 个异常节点:`);
      anomalousNodes.forEach(n => {
        console.warn(`  → ${n.nodeId} (${n.location}): 数据与其他节点不一致`);
      });
    }

    return {
      status: isTrusted ? 'VERIFIED' : 'SUSPICIOUS',
      value: consensusValue,
      confidence: consensusRatio,
      nodeCount: responses.length,
      anomalousNodes: anomalousNodes.map(n => n.nodeId),
      isTrusted,
      message: isTrusted
        ? '✅ 数据可信：多个机位信号一致，共识验证通过'
        : '⚠️ 数据存疑：多个机位信号不一致，可能存在数据操纵'
    };
  }

  /**
   * 验证签名——相当于验证"镜头防伪标识"
   */
  _verifySignature(data, publicKey) {
    // 在实际应用中，这里应该使用ECDSA或Ed25519签名验证
    // 简化实现：检查签名是否存在且格式正确
    if (!data.signature) return false;
    if (data.signature.length < 32) return false;
    
    // 模拟签名验证：检查签名是否与数据内容匹配
    const message = `${data.value}:${data.timestamp}`;
    const expectedPrefix = this._simpleHash(message + publicKey).slice(0, 8);
    return data.signature.startsWith(expectedPrefix);
  }

  /**
   * 简单哈希函数
   */
  _simpleHash(str) {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash;
    }
    let result = Math.abs(hash).toString(16);
    while (result.length < 8) result = '0' + result;
    return result;
  }

  /**
   * 模拟楚门觉醒——发现数据操纵
   */
  async simulateTrumanAwakening() {
    console.log('\n' + '='.repeat(60));
    console.log('🎬 楚门觉醒模拟');
    console.log('='.repeat(60));

    // 注册预言机节点（摄像机）
    this.registerNode('TV_Station', 'https://oracle.truman-tv.com/data', 
      '0x3f8b4a2c9d1e5f7a0b6c3d8e9f2a1b4c5d6e7f8a', '克里斯托夫控制室');
    this.registerNode('Radio_Tower', 'https://oracle.truman-radio.com/data', 
      '0x1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b', '海景镇广播塔');
    this.registerNode('Street_Camera', 'https://oracle.street-cam.com/data', 
      '0x9f8e7d6c5b4a3f2e1d0c9b8a7f6e5d4c3b2a1f0e', '海景镇主干道');
    this.registerNode('Independent_Observer', 'https://oracle.outside-world.com/data', 
      '0x0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b', '真实世界观测站');

    console.log('\n📋 情景：楚门试图验证"外面的世界是否危险"');
    console.log('  克里斯托夫让所有中心化节点回答"危险"');
    console.log('  但独立观察者可能给出不同的答案\n');

    // 模拟：前三个节点被克里斯托夫控制
    const result = await this.fetchFromMultipleNodes('outside_world_safety', [
      'TV_Station', 'Radio_Tower', 'Street_Camera', 'Independent_Observer'
    ]);

    console.log('\n' + '='.repeat(60));
    console.log('📊 验证结果');
    console.log('='.repeat(60));
    console.log(`  状态: ${result.status}`);
    console.log(`  共识值: ${JSON.stringify(result.value)}`);
    console.log(`  置信度: ${(result.confidence * 100).toFixed(1)}%`);
    console.log(`  参与节点: ${result.nodeCount}`);
    if (result.anomalousNodes.length > 0) {
      console.log(`  异常节点: ${result.anomalousNodes.join(', ')}`);
    }
    console.log(`  结论: ${result.message}`);
    console.log('='.repeat(60));

    return result;
  }

  /**
   * 生成验证报告
   */
  generateReport() {
    const lastVerification = this.verificationHistory[this.verificationHistory.length - 1];
    if (!lastVerification) {
      return {
        summary: '暂无验证记录',
        details: null
      };
    }

    return {
      summary: `最后验证: ${lastVerification.dataKey}`,
      details: {
        dataKey: lastVerification.dataKey,
        timestamp: new Date(lastVerification.timestamp).toISOString(),
        nodeCount: lastVerification.nodeCount,
        status: lastVerification.consensus.status,
        confidence: `${(lastVerification.consensus.confidence * 100).toFixed(1)}%`,
        message: lastVerification.consensus.message
      }
    };
  }
}

// 运行模拟
async function main() {
  const verifier = new TrumanOracleVerifier();
  await verifier.simulateTrumanAwakening();
  
  console.log('\n📋 验证报告摘要:');
  console.log(JSON.stringify(verifier.generateReport(), null, 2));
}

main().catch(console.error);