预测市场设计

文档信息

• 版本: v1.0

• 创建日期: 2026-02-13

• 产品名称: [待定] Prediction Market on L2

• 参考: Polymarket, Augur, Kalshi

---

1. 产品概述

1.1 什么是预测市场？

核心概念: 预测市场是一个让用户对未来事件结果下注的平台。价格代表市场对事件发生概率的共识。

示例:

市场: "比特币在 2026 年底是否突破 $100,000?"

YES 价格: $0.65 → 市场认为有 65% 概率
NO 价格: $0.35 → 市场认为有 35% 概率

用户买入 YES @ $0.65:
  - 如果事件发生: 获得 $1.00 (利润 $0.35)
  - 如果事件不发生: 失去 $0.65

1.2 为什么选择预测市场？

市场机会:

1. Polymarket 验证了需求: 2024 年交易量 >$1B, 用户 >100K

2. 信息价值: 预测市场是最准确的概率估算工具

3. 娱乐性强: 选举、体育、加密货币等话题吸引眼球

4. 与 AXBlade 协同: 共享用户, 共享流动性

我们的优势:

• [YES] 原生 Oracle: 自动化结算, 无需人工裁决 (部分场景)

• [YES] 低成本: L2 Gas 费极低, 支持小额下注

• [YES] 快速结算: ZK Rollup 快速提款

• [YES] 与 DeFi 集成: AXBlade 用户可用同一账户

---

2. Polymarket 分析

2.1 Polymarket 架构

核心组件:

┌─────────────────────────────────────────────────────────┐
│                   Polygon (链)                           │
│  ┌──────────────────────────────────────────────────┐   │
│  │  CTF (Conditional Tokens Framework) 合约         │   │
│  │  - ERC-1155 代币 (YES/NO)                         │   │
│  │  - 条件拆分/合并                                  │   │
│  └──────────────────────────────────────────────────┘   │
│                           ↑                              │
│  ┌──────────────────────────────────────────────────┐   │
│  │  CLOB (Central Limit Order Book) 链下撮合        │   │
│  │  - Rust 撮合引擎                                  │   │
│  │  - 签名订单 (EIP-712)                            │   │
│  └──────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘
                           ↑
                   前端 (Next.js)

关键特性:

1. Conditional Tokens: ERC-1155 代表 YES/NO 头寸

2. 链下订单簿: Gas-free 下单, 成交时上链

3. UMA Oracle: 人工裁决事件结果

4. USDC 结算: 所有市场用 USDC

2.2 Polymarket 的问题

问题	影响	我们的解决方案
结算慢	UMA 人工裁决需 48-72 小时	自动化 Oracle (价格类事件)
Polygon Gas	虽然便宜但仍有成本	L2 更低 Gas
争议多	主观事件容易有争议	混合方案: 自动化 + UMA
流动性分散	长尾市场流动性差	AMM + 订单簿混合

---

3. 技术架构设计

3.1 整体架构

┌─────────────────────────────────────────────────────────┐
│                    Frontend (Next.js)                   │
│  - 市场浏览                                              │
│  - 下注界面                                              │
│  - 持仓管理                                              │
└─────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────┐
│                Backend (Rust + PostgreSQL)              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │ 订单簿引擎    │  │ 市场创建     │  │ 结算服务     │  │
│  │ (CLOB)       │  │ (Events)     │  │ (Oracle)     │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────┐
│              L2 Smart Contracts                         │
│  ┌──────────────────────────────────────────────────┐   │
│  │  PredictionMarket.sol (核心合约)                  │   │
│  │  - 市场创建                                       │   │
│  │  - 头寸铸造/合并                                  │   │
│  │  - 结算与赔付                                     │   │
│  └──────────────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────────────┐   │
│  │  OracleHub.sol (原生 Oracle)                     │   │
│  │  - 价格 Oracle (BTC, ETH, etc.)                  │   │
│  │  - 事件 Oracle (UMA 集成)                        │   │
│  └──────────────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────────────┐   │
│  │  MarketAMM.sol (自动做市商)                      │   │
│  │  - 提供初始流动性                                 │   │
│  │  - LS-LMSR 算法                                  │   │
│  └──────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘

3.2 市场类型

3.2.1 二元市场 (Binary)

示例: "比特币在 2026-03-01 是否 >$100K?"

代币:

• YES Token: 事件发生时价值 $1

• NO Token: 事件不发生时价值 $1

用户操作:

用户 Alice 花 $100 USDC 买入 YES @ $0.65
  ↓
Alice 获得 153.8 YES Tokens ($100 / $0.65)
  ↓
事件结果:
  - BTC >$100K: Alice 赔付 153.8 USDC (利润 $53.8)
  - BTC <$100K: Alice 失去 $100

3.2.2 分类市场 (Categorical)

示例: "2026 年美国总统是谁?"

选项:

• Option A: 候选人 A (40%)

• Option B: 候选人 B (35%)

• Option C: 候选人 C (25%)

代币:

• A Token, B Token, C Token

• 胜出选项价值 $1, 其他价值 $0

3.2.3 标量市场 (Scalar)

示例: "BTC 在 2026-12-31 的价格是多少?"

范围: $50K - $150K

赔付公式:

价格 = $120K (实际)
用户预测 $115K:
  相对位置 = (115 - 50) / (150 - 50) = 0.65
  实际位置 = (120 - 50) / (150 - 50) = 0.70
  赔付比例 = 1 - |0.70 - 0.65| / 0.35 = 0.857
  赔付 = 投入 × 0.857

复杂度: 高, 不推荐初期实现

---

4. 智能合约设计

4.1 核心合约: PredictionMarket.sol

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IOracleHub.sol";

/**
 * @title PredictionMarket
 * @notice Polymarket-style prediction market on L2
 * @dev Uses ERC-1155 for outcome tokens
 */
contract PredictionMarket is ERC1155, AccessControl, ReentrancyGuard {
    bytes32 public constant MARKET_CREATOR_ROLE = keccak256("MARKET_CREATOR_ROLE");
    bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");

    IERC20 public immutable collateralToken;  // USDC
    IOracleHub public immutable oracleHub;

    // ==================== 数据结构 ====================

    enum MarketType {
        Binary,       // YES/NO
        Categorical,  // 多选一
        Scalar        // 数值范围
    }

    enum MarketStatus {
        Active,       // 开放交易
        Closed,       // 停止交易, 等待结算
        Resolved,     // 已结算
        Canceled      // 已取消 (退款)
    }

    struct Market {
        bytes32 marketId;
        string question;          // 问题描述
        MarketType marketType;
        MarketStatus status;
        uint256 endTime;          // 市场关闭时间
        uint256 resolutionTime;   // 预计结算时间
        uint256 createdAt;
        address creator;

        // Outcome tokens
        uint256[] outcomeTokenIds;  // [YES, NO] or [A, B, C, ...]
        string[] outcomeNames;      // ["YES", "NO"] or ["Alice", "Bob", ...]

        // Resolution
        uint256 winningOutcome;     // 胜出选项 index
        bytes32 oracleCondition;    // Oracle 条件 (如 "BTC/USD > 100000")

        // Stats
        uint256 totalVolume;        // 总交易量
        uint256 totalLiquidity;     // 总流动性
    }

    struct Position {
        address user;
        bytes32 marketId;
        uint256 outcomeIndex;
        uint256 shares;             // 持有的 outcome tokens
        uint256 avgPrice;           // 平均买入价
    }

    // ==================== 状态变量 ====================

    // marketId => Market
    mapping(bytes32 => Market) public markets;
    bytes32[] public allMarketIds;

    // 下一个 token ID
    uint256 public nextTokenId = 1;

    // tokenId => marketId
    mapping(uint256 => bytes32) public tokenToMarket;

    // user => marketId => outcomeIndex => shares
    mapping(address => mapping(bytes32 => mapping(uint256 => uint256))) public userShares;

    // 手续费率 (basis points, 20 = 0.2%)
    uint256 public feeRate = 20;
    address public feeRecipient;

    // ==================== 事件 ====================

    event MarketCreated(
        bytes32 indexed marketId,
        string question,
        MarketType marketType,
        uint256 endTime,
        uint256[] outcomeTokenIds
    );

    event SharesPurchased(
        bytes32 indexed marketId,
        address indexed user,
        uint256 outcomeIndex,
        uint256 shares,
        uint256 cost
    );

    event SharesSold(
        bytes32 indexed marketId,
        address indexed user,
        uint256 outcomeIndex,
        uint256 shares,
        uint256 payout
    );

    event MarketResolved(
        bytes32 indexed marketId,
        uint256 winningOutcome,
        uint256 timestamp
    );

    event WinningsClaimed(
        bytes32 indexed marketId,
        address indexed user,
        uint256 payout
    );

    // ==================== 构造函数 ====================

    constructor(
        address _collateralToken,
        address _oracleHub,
        address _feeRecipient
    ) ERC1155("https://api.prediction.market/token/{id}.json") {
        collateralToken = IERC20(_collateralToken);
        oracleHub = IOracleHub(_oracleHub);
        feeRecipient = _feeRecipient;

        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MARKET_CREATOR_ROLE, msg.sender);
        _grantRole(RESOLVER_ROLE, msg.sender);
    }

    // ==================== 市场创建 ====================

    /**
     * @notice 创建二元预测市场
     * @param question 问题描述
     * @param endTime 市场结束时间
     * @param resolutionTime 预计结算时间
     * @param oracleCondition Oracle 条件 (如 "BTC/USD>100000@2026-12-31")
     */
    function createBinaryMarket(
        string calldata question,
        uint256 endTime,
        uint256 resolutionTime,
        bytes32 oracleCondition
    ) external onlyRole(MARKET_CREATOR_ROLE) returns (bytes32 marketId) {
        require(endTime > block.timestamp, "Invalid end time");
        require(resolutionTime >= endTime, "Resolution before end");

        marketId = keccak256(abi.encodePacked(
            question,
            endTime,
            block.timestamp
        ));

        require(markets[marketId].createdAt == 0, "Market exists");

        // 创建 YES/NO token IDs
        uint256 yesTokenId = nextTokenId++;
        uint256 noTokenId = nextTokenId++;

        uint256[] memory outcomeTokenIds = new uint256[](2);
        outcomeTokenIds[0] = yesTokenId;
        outcomeTokenIds[1] = noTokenId;

        string[] memory outcomeNames = new string[](2);
        outcomeNames[0] = "YES";
        outcomeNames[1] = "NO";

        markets[marketId] = Market({
            marketId: marketId,
            question: question,
            marketType: MarketType.Binary,
            status: MarketStatus.Active,
            endTime: endTime,
            resolutionTime: resolutionTime,
            createdAt: block.timestamp,
            creator: msg.sender,
            outcomeTokenIds: outcomeTokenIds,
            outcomeNames: outcomeNames,
            winningOutcome: 0,
            oracleCondition: oracleCondition,
            totalVolume: 0,
            totalLiquidity: 0
        });

        allMarketIds.push(marketId);

        tokenToMarket[yesTokenId] = marketId;
        tokenToMarket[noTokenId] = marketId;

        emit MarketCreated(
            marketId,
            question,
            MarketType.Binary,
            endTime,
            outcomeTokenIds
        );

        return marketId;
    }

    /**
     * @notice 创建分类市场
     * @param question 问题
     * @param outcomeNames 选项名称 (e.g., ["Alice", "Bob", "Charlie"])
     * @param endTime 结束时间
     * @param resolutionTime 结算时间
     */
    function createCategoricalMarket(
        string calldata question,
        string[] calldata outcomeNames,
        uint256 endTime,
        uint256 resolutionTime
    ) external onlyRole(MARKET_CREATOR_ROLE) returns (bytes32 marketId) {
        require(outcomeNames.length >= 2 && outcomeNames.length <= 10, "Invalid outcomes");
        require(endTime > block.timestamp, "Invalid end time");

        marketId = keccak256(abi.encodePacked(
            question,
            endTime,
            block.timestamp
        ));

        // 创建 outcome tokens
        uint256[] memory outcomeTokenIds = new uint256[](outcomeNames.length);
        for (uint256 i = 0; i < outcomeNames.length; i++) {
            outcomeTokenIds[i] = nextTokenId++;
            tokenToMarket[outcomeTokenIds[i]] = marketId;
        }

        markets[marketId] = Market({
            marketId: marketId,
            question: question,
            marketType: MarketType.Categorical,
            status: MarketStatus.Active,
            endTime: endTime,
            resolutionTime: resolutionTime,
            createdAt: block.timestamp,
            creator: msg.sender,
            outcomeTokenIds: outcomeTokenIds,
            outcomeNames: outcomeNames,
            winningOutcome: 0,
            oracleCondition: bytes32(0),
            totalVolume: 0,
            totalLiquidity: 0
        });

        allMarketIds.push(marketId);

        emit MarketCreated(
            marketId,
            question,
            MarketType.Categorical,
            endTime,
            outcomeTokenIds
        );

        return marketId;
    }

    // ==================== 交易功能 ====================

    /**
     * @notice 买入 shares (铸造 outcome tokens)
     * @param marketId 市场 ID
     * @param outcomeIndex 选项索引 (0 = YES, 1 = NO)
     * @param amount 投入金额 (USDC)
     * @param minShares 最少获得 shares (滑点保护)
     */
    function buyShares(
        bytes32 marketId,
        uint256 outcomeIndex,
        uint256 amount,
        uint256 minShares
    ) external nonReentrant returns (uint256 shares) {
        Market storage market = markets[marketId];
        require(market.status == MarketStatus.Active, "Market not active");
        require(block.timestamp < market.endTime, "Market ended");
        require(outcomeIndex < market.outcomeTokenIds.length, "Invalid outcome");

        // 收取手续费
        uint256 fee = (amount * feeRate) / 10000;
        uint256 netAmount = amount - fee;

        // 转移 USDC
        collateralToken.transferFrom(msg.sender, address(this), amount);
        if (fee > 0) {
            collateralToken.transfer(feeRecipient, fee);
        }

        // 计算 shares (简化: 1 USDC = 1 share, 实际应该用 AMM 定价)
        // TODO: 集成 AMM 或订单簿定价
        shares = netAmount;

        require(shares >= minShares, "Slippage exceeded");

        // 铸造 outcome tokens
        uint256 tokenId = market.outcomeTokenIds[outcomeIndex];
        _mint(msg.sender, tokenId, shares, "");

        // 更新用户持仓
        userShares[msg.sender][marketId][outcomeIndex] += shares;

        // 更新市场统计
        market.totalVolume += amount;

        emit SharesPurchased(marketId, msg.sender, outcomeIndex, shares, amount);

        return shares;
    }

    /**
     * @notice 卖出 shares (销毁 outcome tokens)
     * @param marketId 市场 ID
     * @param outcomeIndex 选项索引
     * @param shares 卖出数量
     * @param minPayout 最少获得 USDC (滑点保护)
     */
    function sellShares(
        bytes32 marketId,
        uint256 outcomeIndex,
        uint256 shares,
        uint256 minPayout
    ) external nonReentrant returns (uint256 payout) {
        Market storage market = markets[marketId];
        require(market.status == MarketStatus.Active, "Market not active");
        require(block.timestamp < market.endTime, "Market ended");

        uint256 tokenId = market.outcomeTokenIds[outcomeIndex];

        // 销毁 outcome tokens
        _burn(msg.sender, tokenId, shares);

        // 计算赔付 (简化: 1 share = 1 USDC, 实际应该用 AMM)
        // TODO: 集成 AMM 定价
        payout = shares;

        uint256 fee = (payout * feeRate) / 10000;
        uint256 netPayout = payout - fee;

        require(netPayout >= minPayout, "Slippage exceeded");

        // 转账
        collateralToken.transfer(msg.sender, netPayout);
        if (fee > 0) {
            collateralToken.transfer(feeRecipient, fee);
        }

        // 更新持仓
        userShares[msg.sender][marketId][outcomeIndex] -= shares;

        emit SharesSold(marketId, msg.sender, outcomeIndex, shares, netPayout);

        return netPayout;
    }

    // ==================== 结算功能 ====================

    /**
     * @notice 自动结算 (基于 Oracle)
     * @dev 仅适用于价格类市场
     */
    function resolveMarketWithOracle(bytes32 marketId) external {
        Market storage market = markets[marketId];
        require(market.status == MarketStatus.Active || market.status == MarketStatus.Closed, "Invalid status");
        require(block.timestamp >= market.resolutionTime, "Too early");
        require(market.oracleCondition != bytes32(0), "No oracle condition");

        // 解析 Oracle 条件: "BTC/USD>100000@timestamp"
        (string memory symbol, uint256 targetPrice, bool isGreaterThan) =
            _parseOracleCondition(market.oracleCondition);

        // 从 Oracle Hub 读取价格
        (uint256 actualPrice, ) = oracleHub.getLatestPrice(symbol);

        // 判断结果
        bool condition = isGreaterThan
            ? actualPrice >= targetPrice
            : actualPrice < targetPrice;

        uint256 winningOutcome = condition ? 0 : 1;  // 0 = YES, 1 = NO

        _resolveMarket(marketId, winningOutcome);
    }

    /**
     * @notice 人工结算 (需要 RESOLVER 权限)
     * @dev 适用于主观事件或 Oracle 失败
     */
    function resolveMarketManually(bytes32 marketId, uint256 winningOutcome)
        external
        onlyRole(RESOLVER_ROLE)
    {
        Market storage market = markets[marketId];
        require(market.status == MarketStatus.Active || market.status == MarketStatus.Closed, "Invalid status");
        require(block.timestamp >= market.resolutionTime, "Too early");
        require(winningOutcome < market.outcomeTokenIds.length, "Invalid outcome");

        _resolveMarket(marketId, winningOutcome);
    }

    function _resolveMarket(bytes32 marketId, uint256 winningOutcome) private {
        Market storage market = markets[marketId];

        market.status = MarketStatus.Resolved;
        market.winningOutcome = winningOutcome;

        emit MarketResolved(marketId, winningOutcome, block.timestamp);
    }

    /**
     * @notice 领取赢家奖金
     * @param marketId 市场 ID
     */
    function claimWinnings(bytes32 marketId) external nonReentrant {
        Market storage market = markets[marketId];
        require(market.status == MarketStatus.Resolved, "Not resolved");

        uint256 winningTokenId = market.outcomeTokenIds[market.winningOutcome];
        uint256 shares = balanceOf(msg.sender, winningTokenId);

        require(shares > 0, "No winning shares");

        // 销毁 winning tokens
        _burn(msg.sender, winningTokenId, shares);

        // 赔付: 1 share = 1 USDC
        uint256 payout = shares;

        collateralToken.transfer(msg.sender, payout);

        emit WinningsClaimed(marketId, msg.sender, payout);
    }

    /**
     * @notice 取消市场 (退款)
     * @dev 仅限紧急情况
     */
    function cancelMarket(bytes32 marketId)
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
    {
        Market storage market = markets[marketId];
        require(market.status != MarketStatus.Resolved, "Already resolved");

        market.status = MarketStatus.Canceled;

        // 用户可以销毁 shares 获得退款 (1:1)
        // TODO: 实现退款逻辑
    }

    // ==================== 查询功能 ====================

    function getMarket(bytes32 marketId) external view returns (Market memory) {
        return markets[marketId];
    }

    function getAllMarkets() external view returns (bytes32[] memory) {
        return allMarketIds;
    }

    function getUserPosition(address user, bytes32 marketId, uint256 outcomeIndex)
        external
        view
        returns (uint256 shares)
    {
        Market storage market = markets[marketId];
        uint256 tokenId = market.outcomeTokenIds[outcomeIndex];
        return balanceOf(user, tokenId);
    }

    // ==================== 内部函数 ====================

    function _parseOracleCondition(bytes32 condition)
        private
        pure
        returns (string memory symbol, uint256 targetPrice, bool isGreaterThan)
    {
        // 简化实现, 实际应该更健壮
        // "BTC/USD>100000" 编码为 bytes32
        // TODO: 实现完整的解析逻辑

        symbol = "BTC/USD";
        targetPrice = 100000 * 1e18;
        isGreaterThan = true;

        return (symbol, targetPrice, isGreaterThan);
    }

    // ==================== 管理功能 ====================

    function setFeeRate(uint256 newFeeRate) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(newFeeRate <= 500, "Fee too high");  // Max 5%
        feeRate = newFeeRate;
    }

    function setFeeRecipient(address newRecipient) external onlyRole(DEFAULT_ADMIN_ROLE) {
        feeRecipient = newRecipient;
    }
}

4.2 AMM 合约 (LS-LMSR)

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

/**
 * @title MarketAMM
 * @notice Logarithmic Market Scoring Rule (LMSR) AMM for prediction markets
 * @dev Provides liquidity and pricing for prediction markets
 */
contract MarketAMM {
    // b 参数: 流动性参数, 越大则价格变化越平滑
    uint256 public constant B = 100 * 1e18;

    struct PoolState {
        bytes32 marketId;
        uint256[] outcomeShares;  // 每个 outcome 的 shares 总量
        uint256 liquidity;        // LP 提供的流动性
    }

    mapping(bytes32 => PoolState) public pools;

    /**
     * @notice 计算买入 shares 的成本 (LS-LMSR)
     * @param marketId 市场 ID
     * @param outcomeIndex 选项索引
     * @param sharesToBuy 要买入的 shares
     * @return cost 成本 (USDC)
     */
    function calculateBuyCost(
        bytes32 marketId,
        uint256 outcomeIndex,
        uint256 sharesToBuy
    ) external view returns (uint256 cost) {
        PoolState storage pool = pools[marketId];
        require(outcomeIndex < pool.outcomeShares.length, "Invalid outcome");

        // LMSR 公式: cost = b * ln(exp(q_new / b) - exp(q_old / b))
        // 其中 q_new = q_old + sharesToBuy

        uint256 qOld = pool.outcomeShares[outcomeIndex];
        uint256 qNew = qOld + sharesToBuy;

        // 简化计算 (实际应该用 math 库处理 ln/exp)
        // cost ≈ sharesToBuy * currentPrice
        uint256 currentPrice = getPrice(marketId, outcomeIndex);
        cost = (sharesToBuy * currentPrice) / 1e18;

        return cost;
    }

    /**
     * @notice 获取当前价格
     * @dev price = exp(q_i / b) / sum(exp(q_j / b))
     */
    function getPrice(bytes32 marketId, uint256 outcomeIndex)
        public
        view
        returns (uint256 price)
    {
        PoolState storage pool = pools[marketId];

        // 简化: 假设二元市场
        if (pool.outcomeShares.length == 2) {
            uint256 qYes = pool.outcomeShares[0];
            uint256 qNo = pool.outcomeShares[1];

            // price_YES = exp(q_YES / b) / (exp(q_YES / b) + exp(q_NO / b))
            // 简化为: price_YES = q_YES / (q_YES + q_NO)
            if (outcomeIndex == 0) {
                price = (qYes * 1e18) / (qYes + qNo);
            } else {
                price = (qNo * 1e18) / (qYes + qNo);
            }
        }

        return price;
    }

    /**
     * @notice LP 添加流动性
     */
    function addLiquidity(bytes32 marketId, uint256 amount) external {
        // TODO: 实现 LP 逻辑
        // LP 提供初始流动性, 赚取交易手续费
    }
}

---

5. 后端服务设计

5.1 订单簿引擎 (CLOB)

Rust 实现 (复用 AXBlade 代码):

// backend/src/services/prediction/orderbook.rs

pub struct PredictionOrderBook {
    market_id: String,
    outcome_index: usize,
    bids: BTreeMap<Decimal, VecDeque<Order>>,  // Price => Orders
    asks: BTreeMap<Decimal, VecDeque<Order>>,
}

pub struct Order {
    pub order_id: Uuid,
    pub user_id: Uuid,
    pub market_id: String,
    pub outcome_index: usize,
    pub side: OrderSide,       // Buy/Sell
    pub price: Decimal,        // 0.01 - 0.99
    pub size: Decimal,         // shares
    pub filled: Decimal,
    pub status: OrderStatus,
    pub signature: String,     // EIP-712 签名
}

impl PredictionOrderBook {
    pub fn match_order(&mut self, order: Order) -> Vec<Trade> {
        let mut trades = Vec::new();

        match order.side {
            OrderSide::Buy => {
                // 买单: 匹配 asks (卖单)
                while order.filled < order.size {
                    if let Some((best_ask_price, ask_orders)) = self.asks.first_entry() {
                        if *best_ask_price > order.price {
                            break;  // 没有合适的卖单
                        }

                        if let Some(mut ask_order) = ask_orders.pop_front() {
                            let trade_size = (order.size - order.filled).min(ask_order.size - ask_order.filled);

                            trades.push(Trade {
                                market_id: self.market_id.clone(),
                                outcome_index: self.outcome_index,
                                maker_order_id: ask_order.order_id,
                                taker_order_id: order.order_id,
                                price: *best_ask_price,
                                size: trade_size,
                                timestamp: Utc::now(),
                            });

                            order.filled += trade_size;
                            ask_order.filled += trade_size;

                            if ask_order.filled < ask_order.size {
                                ask_orders.push_front(ask_order);
                            }
                        }

                        if ask_orders.is_empty() {
                            self.asks.remove(best_ask_price);
                        }
                    } else {
                        break;  // 没有卖单了
                    }
                }

                // 未完全成交的买单加入订单簿
                if order.filled < order.size {
                    self.bids.entry(order.price).or_insert_with(VecDeque::new).push_back(order);
                }
            }
            OrderSide::Sell => {
                // 卖单: 匹配 bids (买单)
                // (类似逻辑, 省略)
            }
        }

        trades
    }
}

5.2 市场创建服务

// backend/src/services/prediction/market_creator.rs

pub struct MarketCreator {
    contract: PredictionMarketContract,
    db: DatabasePool,
}

impl MarketCreator {
    pub async fn create_market(&self, request: CreateMarketRequest) -> Result<MarketId> {
        // 1. 验证请求
        self.validate_market_request(&request)?;

        // 2. 调用智能合约创建市场
        let tx = self.contract
            .create_binary_market(
                request.question,
                request.end_time,
                request.resolution_time,
                request.oracle_condition,
            )
            .send()
            .await?;

        let receipt = tx.await?;
        let market_id = self.parse_market_id_from_receipt(&receipt)?;

        // 3. 保存到数据库
        self.db.insert_market(Market {
            market_id: market_id.clone(),
            question: request.question,
            market_type: MarketType::Binary,
            status: MarketStatus::Active,
            end_time: request.end_time,
            resolution_time: request.resolution_time,
            created_at: Utc::now(),
        }).await?;

        // 4. 初始化订单簿
        self.init_orderbook(&market_id).await?;

        // 5. (可选) 添加初始流动性
        if let Some(initial_liquidity) = request.initial_liquidity {
            self.add_initial_liquidity(&market_id, initial_liquidity).await?;
        }

        Ok(market_id)
    }

    async fn init_orderbook(&self, market_id: &str) -> Result<()> {
        // 为 YES 和 NO 分别创建订单簿
        let yes_orderbook = PredictionOrderBook::new(market_id.to_string(), 0);
        let no_orderbook = PredictionOrderBook::new(market_id.to_string(), 1);

        // 保存到内存/Redis
        ORDERBOOK_CACHE.insert((market_id.to_string(), 0), yes_orderbook);
        ORDERBOOK_CACHE.insert((market_id.to_string(), 1), no_orderbook);

        Ok(())
    }
}

5.3 自动结算服务

// backend/src/services/prediction/resolver.rs

pub struct MarketResolver {
    contract: PredictionMarketContract,
    oracle_client: OracleClient,
    db: DatabasePool,
}

impl MarketResolver {
    pub async fn run_resolution_loop(&self) -> Result<()> {
        loop {
            // 1. 查询所有待结算的市场
            let markets = self.db.get_markets_to_resolve().await?;

            for market in markets {
                match self.resolve_market(&market).await {
                    Ok(_) => {
                        log::info!("Market {} resolved successfully", market.market_id);
                    }
                    Err(e) => {
                        log::error!("Failed to resolve market {}: {}", market.market_id, e);
                    }
                }
            }

            // 每分钟检查一次
            tokio::time::sleep(Duration::from_secs(60)).await;
        }
    }

    async fn resolve_market(&self, market: &Market) -> Result<()> {
        // 检查是否到达结算时间
        if Utc::now() < market.resolution_time {
            return Ok(());
        }

        // 如果有 Oracle 条件, 使用自动结算
        if let Some(oracle_condition) = &market.oracle_condition {
            return self.resolve_with_oracle(market, oracle_condition).await;
        }

        // 否则等待人工结算
        log::info!("Market {} requires manual resolution", market.market_id);
        Ok(())
    }

    async fn resolve_with_oracle(
        &self,
        market: &Market,
        oracle_condition: &OracleCondition,
    ) -> Result<()> {
        // 解析条件: "BTC/USD>100000@timestamp"
        let (symbol, target_price, is_greater_than) = parse_oracle_condition(oracle_condition)?;

        // 从 Oracle Hub 读取价格
        let actual_price = self.oracle_client.get_price(&symbol).await?;

        // 判断结果
        let condition_met = if is_greater_than {
            actual_price >= target_price
        } else {
            actual_price < target_price
        };

        let winning_outcome = if condition_met { 0 } else { 1 };  // 0=YES, 1=NO

        // 调用合约结算
        let tx = self.contract
            .resolve_market_with_oracle(market.market_id.clone())
            .send()
            .await?;

        tx.await?;

        // 更新数据库
        self.db.update_market_status(
            &market.market_id,
            MarketStatus::Resolved,
            Some(winning_outcome),
        ).await?;

        log::info!(
            "Market {} resolved: {} (price: {}, target: {})",
            market.market_id,
            if winning_outcome == 0 { "YES" } else { "NO" },
            actual_price,
            target_price
        );

        Ok(())
    }
}

struct OracleCondition {
    symbol: String,         // "BTC/USD"
    target_price: Decimal,  // 100000
    is_greater_than: bool,  // true
    timestamp: DateTime<Utc>,
}

fn parse_oracle_condition(condition: &str) -> Result<(String, Decimal, bool)> {
    // "BTC/USD>100000@2026-12-31"
    // TODO: 实现完整的解析逻辑
    Ok(("BTC/USD".to_string(), Decimal::from(100000), true))
}

---

6. 前端设计

6.1 市场列表页

// frontend/src/pages/Markets.tsx

export function MarketsPage() {
  const { data: markets } = useQuery({
    queryKey: ['markets'],
    queryFn: () => api.getMarkets({ status: 'active' }),
  });

  return (
    <div className="markets-page">
      <h1>Prediction Markets</h1>

      {/* 分类过滤 */}
      <div className="categories">
        <button>All</button>
        <button>Crypto</button>
        <button>Politics</button>
        <button>Sports</button>
        <button>Entertainment</button>
      </div>

      {/* 市场列表 */}
      <div className="markets-grid">
        {markets?.map((market) => (
          <MarketCard key={market.marketId} market={market} />
        ))}
      </div>
    </div>
  );
}

function MarketCard({ market }: { market: Market }) {
  const yesPrice = useMarketPrice(market.marketId, 0);
  const noPrice = useMarketPrice(market.marketId, 1);

  return (
    <div className="market-card">
      <h3>{market.question}</h3>

      <div className="prices">
        <div className="outcome yes">
          <span className="label">YES</span>
          <span className="price">${yesPrice?.toFixed(2)}</span>
          <span className="probability">{(yesPrice * 100).toFixed(0)}%</span>
        </div>

        <div className="outcome no">
          <span className="label">NO</span>
          <span className="price">${noPrice?.toFixed(2)}</span>
          <span className="probability">{(noPrice * 100).toFixed(0)}%</span>
        </div>
      </div>

      <div className="stats">
        <span>Volume: ${formatNumber(market.totalVolume)}</span>
        <span>Ends: {formatDate(market.endTime)}</span>
      </div>

      <button onClick={() => navigate(`/market/${market.marketId}`)}>
        Trade
      </button>
    </div>
  );
}

6.2 交易页面

// frontend/src/pages/MarketDetail.tsx

export function MarketDetailPage() {
  const { marketId } = useParams();
  const { data: market } = useMarket(marketId);
  const [outcome, setOutcome] = useState<0 | 1>(0);  // 0=YES, 1=NO
  const [amount, setAmount] = useState('');

  const { write: buyShares } = useContractWrite({
    address: PREDICTION_MARKET_ADDRESS,
    abi: PREDICTION_MARKET_ABI,
    functionName: 'buyShares',
  });

  const handleBuy = () => {
    buyShares({
      args: [
        marketId,
        outcome,
        parseUnits(amount, 6),  // USDC has 6 decimals
        0,  // minShares (TODO: calculate slippage)
      ],
    });
  };

  return (
    <div className="market-detail">
      {/* 问题 */}
      <h1>{market?.question}</h1>

      {/* 价格图表 */}
      <PriceChart marketId={marketId} />

      {/* 交易面板 */}
      <div className="trade-panel">
        <h2>Trade</h2>

        {/* 选择 YES/NO */}
        <div className="outcome-selector">
          <button
            className={outcome === 0 ? 'active yes' : ''}
            onClick={() => setOutcome(0)}
          >
            YES {(market?.yesPrice * 100).toFixed(0)}%
          </button>
          <button
            className={outcome === 1 ? 'active no' : ''}
            onClick={() => setOutcome(1)}
          >
            NO {(market?.noPrice * 100).toFixed(0)}%
          </button>
        </div>

        {/* 金额输入 */}
        <input
          type="number"
          placeholder="Amount (USDC)"
          value={amount}
          onChange={(e) => setAmount(e.target.value)}
        />

        {/* 预期收益 */}
        <div className="expected-return">
          <span>You'll get:</span>
          <span>
            {calculateShares(amount, outcome === 0 ? market?.yesPrice : market?.noPrice)} shares
          </span>
        </div>

        <div className="payout-scenarios">
          <div>
            If YES wins: <strong>${calculatePayout(amount, market?.yesPrice, true)}</strong>
          </div>
          <div>
            If NO wins: <strong>${calculatePayout(amount, market?.noPrice, false)}</strong>
          </div>
        </div>

        <button onClick={handleBuy}>
          Buy {outcome === 0 ? 'YES' : 'NO'}
        </button>
      </div>

      {/* 订单簿 (可选) */}
      <OrderBook marketId={marketId} outcomeIndex={outcome} />

      {/* 用户持仓 */}
      <UserPosition marketId={marketId} />
    </div>
  );
}

function calculateShares(amount: string, price: number): string {
  if (!amount || !price) return '0';
  return (parseFloat(amount) / price).toFixed(2);
}

function calculatePayout(amount: string, price: number, isWinning: boolean): string {
  if (!amount || !price) return '0';
  if (!isWinning) return '0';
  return (parseFloat(amount) / price).toFixed(2);
}

---

7. 实施路线图

Phase 1: MVP (8 周)

Week 1-2: 智能合约

• PredictionMarket.sol (二元市场)

• 基础测试

Week 3-4: 后端

• 订单簿引擎

• 市场创建 API

• 结算服务 (手动)

Week 5-6: 前端

• 市场列表页

• 交易页面

• 钱包集成

Week 7-8: 测试与部署

• 测试网部署

• 内部测试

• Bug 修复

交付物:

• 可运行的预测市场 (二元, 手动结算)

• 10 个测试市场

Phase 2: 自动化 Oracle (4 周)

Week 9-10: Oracle 集成

• 自动结算逻辑

• 价格类市场创建

Week 11-12: 测试与上线

• 主网部署

• 第一个真实市场

Phase 3: 高级功能 (持续)

• 分类市场

• AMM 流动性池

• 移动端 App

• 社交功能 (分享, 讨论)

---

8. 成功指标

指标	1 个月	3 个月	6 个月
活跃市场数	10	50	200
日活用户	100	500	2000
日交易量	$10K	$100K	$1M
TVL	$50K	$500K	$5M

---

文档版本: v1.0 最后更新: 2026-02-13