Untitled

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

contract OverlookHotel {
    // 酒店的所有房间，映射到存储的历史数据
    mapping(uint256 => Room) public rooms;
    // 闪灵能力持有者
    mapping(address => bool) public hasShining;
    // 酒店白名单（看管人权限）
    mapping(address => bool) public isWhitelisted;
    // 酒店管理员
    address public immutable overseer;
    // 状态树根
    bytes32 public stateRoot;
    
    struct Room {
        uint256 roomNumber;
        string historicalData;    // 房间存储的历史数据
        bytes32 dataHash;         // 数据的哈希验证
        uint256 timestamp;        // 最后写入时间
        bool isCorrupted;         // 数据是否被腐败
    }
    
    struct Ghost {
        uint256 blockHeight;
        string vision;
        address indexed witness;
    }
    
    // 幽灵事件 - 历史状态的回放
    event GhostAppearance(uint256 indexed roomNumber, string vision, uint256 blockHeight);
    // 数据腐败事件
    event DataCorruption(uint256 indexed roomNumber, address corruptedBy);
    // 闪灵读取事件
    event ShiningVision(address indexed viewer, string vision);
    
    constructor() {
        overseer = msg.sender;
        // 初始化237个房间，每个房间存储历史数据
        for (uint256 i = 1; i <= 237; i++) {
            rooms[i] = Room({
                roomNumber: i,
                historicalData: "",
                dataHash: bytes32(0),
                timestamp: 0,
                isCorrupted: false
            });
        }
        // 给丹尼闪灵能力
        hasShining[0xDanisAddress] = true;
        stateRoot = keccak256(abi.encodePacked(block.timestamp, "Overlook Initialized"));
    }
    
    // 闪灵数据检索协议 - 读取历史状态
    function shine(uint256 roomNumber, address viewer) 
        external 
        view 
        returns (string memory vision) 
    {
        require(hasShining[viewer] || isWhitelisted[viewer], 
                "Shining: Access denied - no psychic ability detected");
        require(roomNumber > 0 && roomNumber <= 237, 
                "Shining: Room does not exist");
        
        Room storage room = rooms[roomNumber];
        require(!room.isCorrupted, 
                "Shining: Data corrupted - vision may be unsafe");
        
        vision = room.historicalData;
        emit ShiningVision(viewer, vision);
    }
    
    // 写入历史数据（仅看管人权限）
    function writeHistory(uint256 roomNumber, string calldata data) 
        external 
    {
        require(isWhitelisted[msg.sender], 
                "Write: Only whitelisted caretakers can write");
        require(roomNumber > 0 && roomNumber <= 237, 
                "Write: Room does not exist");
        
        Room storage room = rooms[roomNumber];
        room.historicalData = data;
        room.dataHash = keccak256(abi.encodePacked(data));
        room.timestamp = block.timestamp;
        
        // 更新状态树根
        stateRoot = keccak256(abi.encodePacked(
            stateRoot, 
            roomNumber, 
            room.dataHash
        ));
        
        // 触发幽灵事件
        emit GhostAppearance(roomNumber, data, block.number);
    }
    
    // 杰克的重写攻击 - 所有工作没有娱乐
    function jackTorranceAttack(uint256 roomNumber, string calldata corruptedData) 
        external 
    {
        require(isWhitelisted[msg.sender], 
                "Attack: Only caretakers can corrupt data");
        require(keccak256(abi.encodePacked(corruptedData)) == 
                keccak256(abi.encodePacked("All work and no play makes Jack a dull boy")),
                "Attack: Invalid corruption pattern");
        
        Room storage room = rooms[roomNumber];
        room.isCorrupted = true;
        room.historicalData = corruptedData;
        
        emit DataCorruption(roomNumber, msg.sender);
    }
    
    // 验证梅克尔证明（迷宫路径验证）
    function verifyMazeProof(bytes32 root, bytes32 leaf, bytes32[] calldata proof) 
        external 
        pure 
        returns (bool) 
    {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash < proofElement) {
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        return computedHash == root;
    }
}

import hashlib
import json
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from enum import Enum

class ShiningLevel(Enum):
    """闪灵能力等级"""
    DANY = "full_vision"
    JACK = "partial_vision" 
    HALLORANN = "remote_viewing"
    NONE = "no_shining"

@dataclass
class RoomState:
    """房间状态 - 存储分片"""
    room_number: int
    historical_data: str
    data_hash: str
    timestamp: int
    is_corrupted: bool
    ghost_count: int

@dataclass
class MerkleProof:
    """梅克尔证明 - 迷宫路径"""
    leaf: str
    proof_nodes: List[str]
    root: str
    path_direction: List[bool]  # True = left, False = right

class OverlookStorageClient:
    """全景酒店存储客户端 - 闪灵数据检索协议"""
    
    def __init__(self, address: str, shining_level: ShiningLevel):
        self.address = address
        self.shining_level = shining_level
        self.visions: List[str] = []
        self.state_cache: Dict[int, RoomState] = {}
        self.is_whitelisted = False
        
    def has_access(self, room_number: int) -> bool:
        """检查闪灵访问权限"""
        if self.shining_level == ShiningLevel.DANY:
            return True  # 丹尼可以访问所有房间
        elif self.shining_level == ShiningLevel.JACK:
            return self.is_whitelisted  # 杰克只有白名单权限
        elif self.shining_level == ShiningLevel.HALLORANN:
            return room_number <= 100  # 哈洛兰有限访问
        return False
    
    def retrieve_vision(self, room_number: int, 
                        hotel_storage: Dict[int, RoomState]) -> Optional[str]:
        """闪灵数据检索 - 从存储中读取历史状态"""
        if not self.has_access(room_number):
            print(f"[SHINING] Access denied: {self.address} cannot access room {room_number}")
            return None
        
        if room_number not in hotel_storage:
            print(f"[SHINING] Room {room_number} does not exist in storage")
            return None
        
        room = hotel_storage[room_number]
        
        if room.is_corrupted:
            print(f"[SHINING] WARNING: Room {room_number} data is corrupted!")
            if self.shining_level == ShiningLevel.DANY:
                print("[SHINING] Dany's pure shine can see through corruption")
            else:
                print("[SHINING] Vision may be unsafe")
        
        # 数据检索
        vision = room.historical_data
        self.visions.append(f"Room {room_number}: {vision}")
        
        # 验证数据完整性
        computed_hash = hashlib.sha256(vision.encode()).hexdigest()
        if computed_hash != room.data_hash:
            print(f"[SHINING] Data integrity check FAILED for room {room_number}")
            return None
        
        print(f"[SHINING] Vision retrieved from room {room_number}: {vision[:50]}...")
        return vision
    
    def verify_merkle_path(self, proof: MerkleProof) -> bool:
        """验证梅克尔证明 - 迷宫路径验证"""
        current_hash = proof.leaf
        
        for i, (sibling, is_left) in enumerate(
            zip(proof.proof_nodes, proof.path_direction)):
            if is_left:
                combined = current_hash + sibling
            else:
                combined = sibling + current_hash
            current_hash = hashlib.sha256(combined.encode()).hexdigest()
        
        is_valid = current_hash == proof.root
        print(f"[MERKLE] Maze path verification: {'PASSED' if is_valid else 'FAILED'}")
        return is_valid
    
    def detect_repeated_tx_pattern(self, transactions: List[str]) -> bool:
        """检测重复交易模式 - 杰克的打字机攻击"""
        if not transactions:
            return False
        
        pattern = "All work and no play makes Jack a dull boy"
        pattern_count = sum(1 for tx in transactions if tx == pattern)
        total = len(transactions)
        
        if pattern_count > total * 0.8:
            print(f"[ALERT] Jack Torrance attack detected! "
                  f"{pattern_count}/{total} transactions are duplicate")
            return True
        return False
    
    def retrieve_state_tree(self, block_height: int, 
                           hotel: 'OverlookHotel') -> str:
        """读取历史状态 - 回到某个区块高度"""
        historical_state = hotel.get_state_at_block(block_height)
        print(f"[STATE] Retrieved state at block {block_height}: "
              f"{historical_state[:100]}...")
        return historical_state


class OverlookHotel:
    """全景酒店 - 去中心化存储网络"""
    
    def __init__(self):
        self.rooms: Dict[int, RoomState] = {}
        self.block_height = 0
        self.state_history: Dict[int, bytes] = {}
        self.ghost_events: List[Dict] = []
        self._initialize_hotel()
    
    def _initialize_hotel(self):
        """初始化酒店237个房间"""
        # 1921年舞会数据
        self.rooms[1] = RoomState(
            room_number=1, 
            historical_data="1921: Grand Ballroom - Jazz music and champagne",
            data_hash=hashlib.sha256(
                b"1921: Grand Ballroom - Jazz music and champagne").hexdigest(),
            timestamp=0, ghost_count=42
        )
        # 237号房间 - 特殊存储
        self.rooms[237] = RoomState(
            room_number=237,
            historical_data="The woman in the bathtub - green, decaying",
            data_hash=hashlib.sha256(
                b"The woman in the bathtub - green, decaying").hexdigest(),
            timestamp=0, ghost_count=1
        )
        # 1970年双胞胎事件
        self.rooms[42] = RoomState(
            room_number=42,
            historical_data="1970: Twins Grady - murdered in hallway",
            data_hash=hashlib.sha256(
                b"1970: Twins Grady - murdered in hallway").hexdigest(),
            timestamp=0, ghost_count=2
        )
    
    def get_state_at_block(self, block_height: int) -> str:
        """获取历史区块状态"""
        if block_height in self.state_history:
            return self.state_history[block_height].decode()
        return f"Block {block_height}: State not found in archive"
    
    def simulate_jack_corruption(self, room_numbers: List[int]):
        """模拟杰克的数据腐败攻击"""
        for room_num in room_numbers:
            if room_num in self.rooms:
                self.rooms[room_num].is_corrupted = True
                self.rooms[room_num].historical_data = \
                    "All work and no play makes Jack a dull boy"
                self.rooms[room_num].data_hash = hashlib.sha256(
                    b"All work and no play makes Jack a dull boy").hexdigest()
                print(f"[CORRUPTION] Room {room_num} data corrupted by Jack")


# 闪灵数据检索演示
if __name__ == "__main__":
    hotel = OverlookHotel()
    
    dany = OverlookStorageClient(
        address="0xDany_Overlook",
        shining_level=ShiningLevel.DANY
    )
    
    jack = OverlookStorageClient(
        address="0xJack_Torrance",
        shining_level=ShiningLevel.JACK
    )
    jack.is_whitelisted = True
    
    # 丹尼检索237号房间
    print("=== Dany's Shining Vision ===")
    vision = dany.retrieve_vision(237, hotel.rooms)
    
    # 杰克腐败数据
    print("\n=== Jack's Corruption Attack ===")
    hotel.simulate_jack_corruption([237])
    
    # 检测重复交易模式
    transcripts = ["All work and no play makes Jack a dull boy"] * 100
    jack.detect_repeated_tx_pattern(transcripts)
    
    # 梅克尔证明验证
    print("\n=== Merkle Maze Verification ===")
    proof = MerkleProof(
        leaf="start",
        proof_nodes=["left_hash", "right_hash", "root_hash"],
        root="final_root",
        path_direction=[True, False, True]
    )
    dany.verify_merkle_path(proof)

// 全景酒店去中心化存储 - 前端可视化引擎
const Web3 = require('web3');
const { MerkleTree } = require('merkletreejs');
const SHA256 = require('crypto-js/sha256');

class OverlookVisualizationEngine {
    constructor() {
        this.rooms = new Map();
        this.ghostEvents = [];
        this.stateHistory = [];
        this.blockHeight = 0;
        this.isUnderAttack = false;
        this.merkleTree = null;
        this.initializeHotel();
    }

    initializeHotel() {
        // 初始化237个房间作为存储节点
        for (let i = 1; i <= 237; i++) {
            this.rooms.set(i, {
                roomNumber: i,
                data: `Room ${i}: Empty state`,
                dataHash: SHA256(`Room ${i}: Empty state`).toString(),
                isCorrupted: false,
                timestamp: Date.now(),
                ghostCount: 0
            });
        }

        // 特殊房间数据
        this.rooms.set(237, {
            roomNumber: 237,
            data: 'The woman in the bathtub - 1921 eternal recurrence',
            dataHash: SHA256('237 historical data').toString(),
            isCorrupted: false,
            timestamp: Date.now(),
            ghostCount: 1
        });

        // 构建梅克尔树（迷宫结构）
        this.buildMerkleMaze();
    }

    buildMerkleMaze() {
        // 将房间数据哈希作为叶子节点构建梅克尔树
        const leaves = Array.from(this.rooms.values()).map(room => 
            SHA256(room.data).toString()
        );
        this.merkleTree = new MerkleTree(leaves, SHA256);
        console.log('[MERKLE] Maze constructed with root:', 
                    this.merkleTree.getRoot().toString('hex'));
    }

    // 闪灵数据检索 - 通过房间号读取历史状态
    shiningRetrieval(roomNumber, viewer) {
        const room = this.rooms.get(roomNumber);
        if (!room) {
            return { error: 'Room does not exist in storage network' };
        }

        if (room.isCorrupted) {
            console.warn('[SHINING] WARNING: Data corruption detected in room', roomNumber);
        }

        // 生成梅克尔证明
        const leaf = SHA256(room.data).toString();
        const proof = this.merkleTree.getProof(leaf);
        const root = this.merkleTree.getRoot().toString('hex');

        // 事件日志记录
        this.ghostEvents.push({
            type: 'VISION_RETRIEVED',
            roomNumber,
            viewer,
            blockHeight: this.blockHeight,
            timestamp: new Date().toISOString(),
            dataPreview: room.data.substring(0, 50)
        });

        this.blockHeight++;

        return {
            vision: room.data,
            merkleProof: proof.map(p => p.data.toString('hex')),
            merkleRoot: root,
            isCorrupted: room.isCorrupted,
            blockHeight: this.blockHeight
        };
    }

    // 杰克的腐败攻击 - 重复写入
    jackTorranceAttack() {
        console.log('[ATTACK] Jack Torrance repeating corruption pattern...');
        this.isUnderAttack = true;

        const corruptedData = 'All work and no play makes Jack a dull boy';
        const attackCount = 237;

        for (let i = 0; i < attackCount; i++) {
            const roomNumber = (i % 237) + 1;
            const room = this.rooms.get(roomNumber);
            if (room) {
                room.isCorrupted = true;
                room.data = corruptedData;
                room.dataHash = SHA256(corruptedData).toString();
                room.timestamp = Date.now();
            }

            // 每笔"交易"都记录
            this.ghostEvents.push({
                type: 'CORRUPTION_TX',
                roomNumber: (i % 237) + 1,
                data: corruptedData,
                blockHeight: this.blockHeight++,
                txIndex: i
            });
        }

        console.log(`[ATTACK] ${attackCount} corruption transactions executed`);
        return {
            attackType: 'REPEATED_TRANSACTION_ATTACK',
            totalTransactions: attackCount,
            pattern: corruptedData,
            blocksAffected: Math.ceil(attackCount / 15) // 假设每区块15笔交易
        };
    }

    // 验证梅克尔证明 - 迷宫路径验证
    verifyMazePath(roomNumber, proof) {
        const room = this.rooms.get(roomNumber);
        if (!room) return false;

        const leaf = SHA256(room.data).toString();
        const root = this.merkleTree.getRoot().toString('hex');

        // 验证证明
        const isValid = this.merkleTree.verify(
            proof.map(p => Buffer.from(p, 'hex')),
            leaf,
            root
        );

        console.log('[MAZE] Path verification for room', roomNumber, ':', 
                    isValid ? 'VALID' : 'INVALID');

        return isValid;
    }

    // 获取历史状态回放
    getStateReplay(fromBlock, toBlock) {
        const events = this.ghostEvents.filter(
            e => e.blockHeight >= fromBlock && e.blockHeight <= toBlock
        );

        return {
            fromBlock,
            toBlock,
            totalEvents: events.length,
            events: events.map(e => ({
                ...e,
                timestamp: e.timestamp
            }))
        };
    }

    // 检测丹尼的闪灵模式
    detectDanyShiningPattern(address) {
        const danyVisions = this.ghostEvents.filter(
            e => e.type === 'VISION_RETRIEVED' && e.viewer === address
        );

        return {
            totalVisions: danyVisions.length,
            uniqueRooms: [...new Set(danyVisions.map(e => e.roomNumber))],
            pattern: danyVisions.length > 10 ? 'REDRUM' : 'NORMAL',
            prediction: danyVisions.length > 20 ? 'Tree_To_Fire_Axe' : 'Unknown'
        };
    }

    // 全景仪表盘
    getDashboard() {
        const corruptedRooms = Array.from(this.rooms.values())
            .filter(r => r.isCorrupted);
        
        return {
            totalRooms: this.rooms.size,
            corruptedRooms: corruptedRooms.length,
            corruptionRate: (corruptedRooms.length / this.rooms.size * 100).toFixed(2),
            ghostEventsTotal: this.ghostEvents.length,
            currentBlockHeight: this.blockHeight,
            stateRoot: this.merkleTree.getRoot().toString('hex'),
            isUnderAttack: this.isUnderAttack,
            mazeRoot: this.merkleTree.getRoot().toString('hex'),
            lastEvent: this.ghostEvents[this.ghostEvents.length - 1] || null
        };
    }
}

// 运行全景酒店可视化
const overlook = new OverlookVisualizationEngine();

console.log('=== Overlook Hotel Decentralized Storage Dashboard ===');
console.log('Initial State:', JSON.stringify(overlook.getDashboard(), null, 2));

// 丹尼的闪灵检索
console.log('\n=== Dany Shining Retrieval ===');
const danyVision = overlook.shiningRetrieval(237, '0xDany_Overlook');
console.log('Dany sees:', danyVision.vision);

// 杰克的腐败攻击
console.log('\n=== Jack Corruption Attack ===');
const attackResult = overlook.jackTorranceAttack();
console.log('Attack result:', attackResult);

// 验证梅克尔迷宫路径
console.log('\n=== Merkle Maze Verification ===');
const isValid = overlook.verifyMazePath(42, []);
console.log('Maze path valid:', isValid);

// 最终状态
console.log('\n=== Final Dashboard ===');
console.log(JSON.stringify(overlook.getDashboard(), null, 2));