第一幕：绿洲——元宇宙区块链的终极形态

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract HallidayKeys is ERC721, Ownable {
    uint256 public constant COPPER_KEY = 1;
    uint256 public constant JADE_KEY = 2;
    uint256 public constant CRYSTAL_KEY = 3;
    
    mapping(uint256 => bool) public keyFound;
    mapping(address => mapping(uint256 => bool)) public hasCompletedQuest;
    
    event QuestCompleted(address indexed player, uint256 keyType, string questName);
    event EasterEggRevealed(address indexed player, string eggMessage);
    
    constructor() ERC721("HallidayKeys", "HKEY") Ownable(msg.sender) {}
    
    // 第一关：竞速赛——逆向思维
    function completeRaceQuest(address player) external onlyOwner {
        require(!hasCompletedQuest[player][COPPER_KEY], "Quest already completed");
        hasCompletedQuest[player][COPPER_KEY] = true;
        _safeMint(player, COPPER_KEY);
        emit QuestCompleted(player, COPPER_KEY, "Backwards Race");
    }
    
    // 第二关：恐怖迷宫——直面恐惧
    function completeHorrorQuest(address player) external onlyOwner {
        require(hasCompletedQuest[player][COPPER_KEY], "Must complete first quest");
        require(!hasCompletedQuest[player][JADE_KEY], "Quest already completed");
        hasCompletedQuest[player][JADE_KEY] = true;
        _safeMint(player, JADE_KEY);
        emit QuestCompleted(player, JADE_KEY, "The Shining Maze");
    }
    
    // 第三关：寻宝游戏——享受过程
    function completeAdventureQuest(address player, string memory eggMessage) 
        external onlyOwner {
        require(hasCompletedQuest[player][JADE_KEY], "Must complete second quest");
        require(!hasCompletedQuest[player][CRYSTAL_KEY], "Quest already completed");
        hasCompletedQuest[player][CRYSTAL_KEY] = true;
        _safeMint(player, CRYSTAL_KEY);
        emit EasterEggRevealed(player, eggMessage);
        emit QuestCompleted(player, CRYSTAL_KEY, "Adventure Game");
    }
    
    // 验证是否拥有全部三把钥匙
    function hasAllKeys(address player) public view returns (bool) {
        return balanceOf(player) >= 3;
    }
}

"""
绿洲经济系统模拟器
分析Play-to-Earn模型的收益分配与可持续性
"""

import numpy as np
import pandas as pd
from dataclasses import dataclass
from typing import List, Dict
import matplotlib.pyplot as plt

@dataclass
class Player:
    address: str
    level: int
    play_time: float  # 日均游戏时长（小时）
    skill_multiplier: float  # 技能倍率
    equipment_value: float  # 装备价值（金币）
    
    def daily_earnings(self, base_rate: float = 10.0) -> Dict[str, float]:
        """计算玩家的日均收益"""
        base = base_rate * self.play_time
        skill_bonus = base * (self.skill_multiplier - 1)
        equipment_bonus = base * (self.equipment_value / 10000)
        
        total = base + skill_bonus + equipment_bonus
        
        return {
            "base_earnings": round(base, 2),
            "skill_bonus": round(skill_bonus, 2),
            "equipment_bonus": round(equipment_bonus, 2),
            "total_earnings": round(total, 2)
        }

class OasisEconomy:
    """绿洲经济模型——模拟Play-to-Earn的供需平衡"""
    
    def __init__(self, initial_supply: float = 1_000_000):
        self.total_supply = initial_supply
        self.circulating_supply = 0
        self.transaction_volume = 0
        self.players: List[Player] = []
        self.gold_price = 1.0  # 1金币=1美元
        
    def add_player(self, player: Player) -> None:
        """添加玩家到经济系统"""
        self.players.append(player)
        
    def simulate_day(self) -> Dict[str, float]:
        """模拟一天的经济活动"""
        total_earned = 0
        total_spent = 0
        
        for player in self.players:
            earnings = player.daily_earnings()
            total_earned += earnings["total_earnings"]
            
            # 玩家消费（购买装备、升级等）
            spend_rate = np.random.beta(2, 5)  # Beta分布模拟消费习惯
            spent = earnings["total_earnings"] * spend_rate
            total_spent += spent
            
        # 更新经济指标
        self.circulating_supply += total_earned - total_spent
        self.transaction_volume += total_earned + total_spent
        
        # 通胀/通缩模型
        if self.circulating_supply > self.total_supply * 0.6:
            self.gold_price *= 0.98  # 通胀压力
        elif self.circulating_supply < self.total_supply * 0.2:
            self.gold_price *= 1.02  # 通缩压力
            
        return {
            "total_earned": round(total_earned, 2),
            "total_spent": round(total_spent, 2),
            "circulating_supply": round(self.circulating_supply, 2),
            "transaction_volume": round(self.transaction_volume, 2),
            "gold_price": round(self.gold_price, 4)
        }
    
    def simulate(self, days: int = 365) -> pd.DataFrame:
        """运行长期模拟"""
        history = []
        for day in range(days):
            daily_data = self.simulate_day()
            daily_data["day"] = day + 1
            history.append(daily_data)
        return pd.DataFrame(history)


# 模拟绿洲经济生态系统
oasis = OasisEconomy(initial_supply=10_000_000)

# 添加不同类型的玩家
for i in range(1000):
    player = Player(
        address=f"0x{i:040x}",
        level=np.random.randint(1, 100),
        play_time=np.random.exponential(4),  # 平均每天4小时
        skill_multiplier=np.random.lognormal(0, 0.3),
        equipment_value=np.random.exponential(5000)
    )
    oasis.add_player(player)

# 运行365天模拟
simulation_results = oasis.simulate(365)

# 计算关键经济指标
avg_daily_earnings = simulation_results["total_earned"].mean()
final_gold_price = simulation_results["gold_price"].iloc[-1]
print(f"绿洲经济模拟结果（365天）")
print(f"平均每日总收益: ${avg_daily_earnings:,.2f}")
print(f"最终金币价格: ${final_gold_price:.4f}")
print(f"最终流通量: {simulation_results['circulating_supply'].iloc[-1]:,.0f}")

// 去中心化绿洲登录系统
// 使用以太坊钱包作为身份验证凭证

const ethers = require('ethers');
const { createCanvas, loadImage } = require('canvas');

class OasisLogin {
  constructor() {
    this.users = new Map();
    this.sessionTokens = new Map();
    this.avatars = new Map();
  }

  // 生成挑战信息（类似绿洲的登录界面）
  generateChallenge(address) {
    const timestamp = Date.now();
    const nonce = ethers.hexlify(ethers.randomBytes(32));
    const message = `欢迎来到绿洲，冒险者！\n地址: ${address}\n时间戳: ${timestamp}\nNonce: ${nonce}\n\n签署此消息以证明你拥有此地址的私钥。`;
    
    return {
      message,
      timestamp,
      nonce,
      // 绿洲风格HTML登录提示
      html: `<div class="oasis-login">
        <h2>🔑 绿洲去中心化认证</h2>
        <p>请使用你的钱包签署此消息以登录</p>
        <code>${message.substring(0, 50)}...</code>
      </div>`
    };
  }

  // 验证签名（类似绿洲验证身份）
  async authenticate(address, signature, challenge) {
    try {
      // 恢复签名者地址
      const recoveredAddress = ethers.verifyMessage(
        challenge.message, 
        signature
      );
      
      if (recoveredAddress.toLowerCase() !== address.toLowerCase()) {
        throw new Error('身份验证失败：签名不匹配');
      }

      // 生成会话令牌（类似绿洲的"登录令牌"）
      const sessionToken = ethers.hexlify(ethers.randomBytes(16));
      const expiration = Date.now() + 24 * 60 * 60 * 1000; // 24小时

      // 存储会话信息
      this.sessionTokens.set(sessionToken, {
        address,
        loginTime: Date.now(),
        expiration,
        // 初始化玩家数据
        playerData: {
          level: 1,
          experience: 0,
          coins: 100,
          inventory: []
        }
      });

      return {
        success: true,
        sessionToken,
        expiration,
        message: `欢迎回来，${address.substring(0, 6)}...${address.substring(38)}！`
      };
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }

  // 验证会话（类似绿洲的"持续连接"）
  verifySession(sessionToken) {
    const session = this.sessionTokens.get(sessionToken);
    if (!session) {
      return { valid: false, reason: '无效的会话令牌' };
    }
    if (Date.now() > session.expiration) {
      this.sessionTokens.delete(sessionToken);
      return { valid: false, reason: '会话已过期，请重新登录' };
    }
    return { valid: true, ...session };
  }

  // 数字资产转移（绿洲中的物品交易）
  async transferNFT(fromSession, toAddress, tokenId) {
    const fromSessionData = this.verifySession(fromSession);
    if (!fromSessionData.valid) {
      throw new Error('发送者未认证');
    }

    // 从去中心化存储中加载NFT数据
    const nftData = await this.loadNFTData(tokenId);
    if (!nftData) {
      throw new Error('NFT不存在');
    }

    // 记录转移
    console.log(`[绿洲交易] ${fromSessionData.address} 将 ${nftData.name} 转移至 ${toAddress}`);
    
    return {
      txHash: ethers.hexlify(ethers.randomBytes(32)),
      from: fromSessionData.address,
      to: toAddress,
      tokenId,
      timestamp: new Date().toISOString()
    };
  }

  async loadNFTData(tokenId) {
    // 模拟从链上读取NFT数据
    const nftDatabase = {
      'copper_key': { name: '铜钥匙', rarity: '稀有', power: 100 },
      'jade_key': { name: '玉钥匙', rarity: '史诗', power: 500 },
      'crystal_key': { name: '水晶钥匙', rarity: '传说', power: 9999 },
      'delorean': { name: '德罗宁飞行器', rarity: '史诗', power: 750 }
    };
    return nftDatabase[tokenId] || null;
  }
}

// 使用示例
async function oasisLoginDemo() {
  const oasis = new OasisLogin();
  const playerAddress = '0x1234567890abcdef1234567890abcdef12345678';
  
  // 1. 生成登录挑战
  const challenge = oasis.generateChallenge(playerAddress);
  console.log(challenge.html);
  
  // 2. 模拟用户签名（实际中由钱包完成）
  const fakeSignature = '0x...'; // 钱包签名结果
  
  // 3. 验证登录
  const authResult = await oasis.authenticate(
    playerAddress, 
    fakeSignature, 
    challenge
  );
  
  if (authResult.success) {
    console.log('✅ 登录成功！');
    // 进入绿洲主界面...
  }
}

oasisLoginDemo();

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

contract OasisDAO {
    // ========== 数据结构 ==========
    
    struct Proposal {
        uint256 id;
        string description;
        address proposer;
        uint256 forVotes;
        uint256 againstVotes;
        uint256 startTime;
        uint256 endTime;
        bool executed;
        ProposalStatus status;
    }
    
    enum ProposalStatus { Pending, Active, Passed, Rejected, Executed }
    
    // ========== 状态变量 ==========
    
    address public immutable hallidayAddress;  // 哈利迪的地址（创始地址）
    uint256 public proposalCount;
    uint256 public minimumVotingPeriod = 7 days;
    uint256 public quorum = 1000;  // 最低投票人数
    
    IKeyNFT public keyNFT;  // 钥匙NFT（投票凭证）
    mapping(uint256 => Proposal) public proposals;
    mapping(address => uint256) public votingPower;  // 根据持有的钥匙计算投票权重
    mapping(uint256 => mapping(address => bool)) public hasVoted;
    
    // ========== 事件 ==========
    
    event ProposalCreated(uint256 indexed id, string description, address proposer);
    event Voted(uint256 indexed proposalId, address voter, bool support, uint256 weight);
    event ProposalExecuted(uint256 indexed id);
    
    // ========== 修饰器 ==========
    
    modifier onlyKeyHolder() {
        require(keyNFT.balanceOf(msg.sender) > 0, "必须持有钥匙才能创建提案");
        _;
    }
    
    modifier onlyActiveProposal(uint256 proposalId) {
        require(proposalId < proposalCount, "提案不存在");
        require(
            block.timestamp >= proposals[proposalId].startTime && 
            block.timestamp <= proposals[proposalId].endTime,
            "提案未处于活跃期"
        );
        _;
    }
    
    // ========== 核心函数 ==========
    
    constructor(address _halliday, address _keyNFT) {
        hallidayAddress = _halliday;
        keyNFT = IKeyNFT(_keyNFT);
    }
    
    // 创建提案（类似公会会议）
    function createProposal(string memory description) external onlyKeyHolder {
        uint256 proposalId = proposalCount++;
        
        Proposal storage proposal = proposals[proposalId];
        proposal.id = proposalId;
        proposal.description = description;
        proposal.proposer = msg.sender;
        proposal.startTime = block.timestamp;
        proposal.endTime = block.timestamp + minimumVotingPeriod;
        proposal.status = ProposalStatus.Active;
        
        emit ProposalCreated(proposalId, description, msg.sender);
    }
    
    // 投票（根据钥匙数量加权）
    function vote(uint256 proposalId, bool support) external onlyActiveProposal(proposalId) {
        require(!hasVoted[proposalId][msg.sender], "已经投过票了");
        
        uint256 weight = calculateVotingWeight(msg.sender);
        require(weight > 0, "没有投票资格");
        
        hasVoted[proposalId][msg.sender] = true;
        
        if (support) {
            proposals[proposalId].forVotes += weight;
        } else {
            proposals[proposalId].againstVotes += weight;
        }
        
        emit Voted(proposalId, msg.sender, support, weight);
    }
    
    // 计算投票权重：一把钥匙=1票，三把钥匙=10票
    function calculateVotingWeight(address voter) public view returns (uint256) {
        uint256 keyCount = keyNFT.balanceOf(voter);
        if (keyCount == 0) return 0;
        if (keyCount >= 3) return 10;
        return keyCount;
    }
    
    // 执行提案（类似哈利迪的遗嘱执行）
    function executeProposal(uint256 proposalId) external {
        Proposal storage proposal = proposals[proposalId];
        require(block.timestamp > proposal.endTime, "提案仍在投票中");
        require(!proposal.executed, "提案已执行");
        require(
            proposal.forVotes + proposal.againstVotes >= quorum,
            "未达到法定人数"
        );
        require(proposal.forVotes > proposal.againstVotes, "提案被否决");
        
        proposal.executed = true;
        proposal.status = ProposalStatus.Executed;
        
        emit ProposalExecuted(proposalId);
    }
}

interface IKeyNFT {
    function balanceOf(address owner) external view returns (uint256);
}