PredictionMarket.sol

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

/**
 * @title PredictionMarket
 * @dev A flexible prediction market contract for binary outcome events
 * Supports oracle-based resolution, time locks, and easy event management
 */
contract PredictionMarket {
    
    // Structs
    struct Market {
        string question;
        string description;
        uint256 endTime;
        uint256 resolutionTime;
        bool resolved;
        bool outcome; // true = YES, false = NO
        uint256 totalYesShares;
        uint256 totalNoShares;
        uint256 totalPool;
        address oracle;
        bool canceled;
    }
    
    struct Position {
        uint256 yesShares;
        uint256 noShares;
        bool claimed;
    }
    
    // State variables
    mapping(uint256 => Market) public markets;
    mapping(uint256 => mapping(address => Position)) public positions;
    mapping(address => bool) public authorizedOracles;
    
    uint256 public marketCount;
    address public owner;
    uint256 public platformFee = 20; // 2% fee (out of 1000)
    uint256 public constant FEE_DENOMINATOR = 1000;
    
    // Events
    event MarketCreated(
        uint256 indexed marketId,
        string question,
        uint256 endTime,
        uint256 resolutionTime,
        address oracle
    );
    
    event SharesPurchased(
        uint256 indexed marketId,
        address indexed buyer,
        bool prediction,
        uint256 shares,
        uint256 cost
    );
    
    event MarketResolved(
        uint256 indexed marketId,
        bool outcome,
        address resolver
    );
    
    event WinningsClaimed(
        uint256 indexed marketId,
        address indexed claimer,
        uint256 amount
    );
    
    event MarketCanceled(
        uint256 indexed marketId
    );
    
    event OracleAuthorized(address indexed oracle);
    event OracleRevoked(address indexed oracle);
    
    // Modifiers
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner");
        _;
    }
    
    modifier onlyAuthorizedOracle(uint256 marketId) {
        require(
            authorizedOracles[msg.sender] || msg.sender == markets[marketId].oracle || msg.sender == owner,
            "Not authorized oracle"
        );
        _;
    }
    
    modifier marketExists(uint256 marketId) {
        require(marketId < marketCount, "Market does not exist");
        _;
    }
    
    modifier marketActive(uint256 marketId) {
        require(!markets[marketId].resolved, "Market resolved");
        require(!markets[marketId].canceled, "Market canceled");
        require(block.timestamp < markets[marketId].endTime, "Market ended");
        _;
    }
    
    modifier marketEnded(uint256 marketId) {
        require(block.timestamp >= markets[marketId].endTime, "Market still active");
        _;
    }
    
    modifier canResolve(uint256 marketId) {
        require(block.timestamp >= markets[marketId].resolutionTime, "Resolution time not reached");
        require(!markets[marketId].resolved, "Already resolved");
        require(!markets[marketId].canceled, "Market canceled");
        _;
    }
    
    // Constructor
    constructor() {
        owner = msg.sender;
        authorizedOracles[msg.sender] = true;
    }
    
    /**
     * @dev Create a new prediction market
     * @param question The question being predicted
     * @param description Additional context
     * @param endTime Timestamp when betting closes
     * @param resolutionTime Timestamp when oracle can resolve
     * @param oracle Address authorized to resolve this market
     */
    function createMarket(
        string memory question,
        string memory description,
        uint256 endTime,
        uint256 resolutionTime,
        address oracle
    ) external onlyOwner returns (uint256) {
        require(endTime > block.timestamp, "End time must be in future");
        require(resolutionTime >= endTime, "Resolution time must be after end time");
        require(oracle != address(0), "Invalid oracle address");
        
        uint256 marketId = marketCount++;
        
        markets[marketId] = Market({
            question: question,
            description: description,
            endTime: endTime,
            resolutionTime: resolutionTime,
            resolved: false,
            outcome: false,
            totalYesShares: 0,
            totalNoShares: 0,
            totalPool: 0,
            oracle: oracle,
            canceled: false
        });
        
        emit MarketCreated(marketId, question, endTime, resolutionTime, oracle);
        
        return marketId;
    }
    
    /**
     * @dev Buy shares in a prediction (YES or NO)
     * @param marketId The market to bet on
     * @param predictYes true for YES, false for NO
     */
    function buyShares(uint256 marketId, bool predictYes) 
        external 
        payable 
        marketExists(marketId)
        marketActive(marketId)
    {
        require(msg.value > 0, "Must send ETH");
        
        Market storage market = markets[marketId];
        Position storage position = positions[marketId][msg.sender];
        
        // Calculate shares (1:1 with ETH for simplicity, can implement AMM pricing)
        uint256 shares = msg.value;
        
        if (predictYes) {
            position.yesShares += shares;
            market.totalYesShares += shares;
        } else {
            position.noShares += shares;
            market.totalNoShares += shares;
        }
        
        market.totalPool += msg.value;
        
        emit SharesPurchased(marketId, msg.sender, predictYes, shares, msg.value);
    }
    
    /**
     * @dev Resolve a market (oracle function)
     * @param marketId The market to resolve
     * @param outcome true for YES, false for NO
     */
    function resolveMarket(uint256 marketId, bool outcome)
        external
        marketExists(marketId)
        marketEnded(marketId)
        canResolve(marketId)
        onlyAuthorizedOracle(marketId)
    {
        Market storage market = markets[marketId];
        
        market.resolved = true;
        market.outcome = outcome;
        
        emit MarketResolved(marketId, outcome, msg.sender);
    }
    
    /**
     * @dev Claim winnings after market resolution
     * @param marketId The market to claim from
     */
    function claimWinnings(uint256 marketId) 
        external 
        marketExists(marketId)
    {
        Market storage market = markets[marketId];
        Position storage position = positions[marketId][msg.sender];
        
        require(market.resolved || market.canceled, "Market not resolved or canceled");
        require(!position.claimed, "Already claimed");
        
        uint256 payout = 0;
        
        if (market.canceled) {
            // Refund in case of cancellation
            payout = position.yesShares + position.noShares;
        } else {
            // Calculate winnings
            uint256 winningShares = market.outcome ? position.yesShares : position.noShares;
            uint256 totalWinningShares = market.outcome ? market.totalYesShares : market.totalNoShares;
            
            if (winningShares > 0 && totalWinningShares > 0) {
                // Winner gets proportional share of the pool minus platform fee
                uint256 fee = (market.totalPool * platformFee) / FEE_DENOMINATOR;
                uint256 payoutPool = market.totalPool - fee;
                payout = (payoutPool * winningShares) / totalWinningShares;
            }
        }
        
        position.claimed = true;
        
        if (payout > 0) {
            (bool success, ) = msg.sender.call{value: payout}("");
            require(success, "Transfer failed");
            
            emit WinningsClaimed(marketId, msg.sender, payout);
        }
    }
    
    /**
     * @dev Cancel a market (emergency function)
     * @param marketId The market to cancel
     */
    function cancelMarket(uint256 marketId) 
        external 
        onlyOwner 
        marketExists(marketId)
    {
        require(!markets[marketId].resolved, "Already resolved");
        
        markets[marketId].canceled = true;
        
        emit MarketCanceled(marketId);
    }
    
    /**
     * @dev Authorize an oracle address
     * @param oracle Address to authorize
     */
    function authorizeOracle(address oracle) external onlyOwner {
        authorizedOracles[oracle] = true;
        emit OracleAuthorized(oracle);
    }
    
    /**
     * @dev Revoke oracle authorization
     * @param oracle Address to revoke
     */
    function revokeOracle(address oracle) external onlyOwner {
        authorizedOracles[oracle] = false;
        emit OracleRevoked(oracle);
    }
    
    /**
     * @dev Update platform fee
     * @param newFee New fee (out of 1000, e.g., 20 = 2%)
     */
    function setPlatformFee(uint256 newFee) external onlyOwner {
        require(newFee <= 100, "Fee too high"); // Max 10%
        platformFee = newFee;
    }
    
    /**
     * @dev Withdraw accumulated fees
     */
    function withdrawFees() external onlyOwner {
        uint256 balance = address(this).balance;
        uint256 lockedFunds = 0;
        
        // Calculate funds locked in active markets
        for (uint256 i = 0; i < marketCount; i++) {
            if (!markets[i].resolved && !markets[i].canceled) {
                lockedFunds += markets[i].totalPool;
            }
        }
        
        uint256 withdrawable = balance > lockedFunds ? balance - lockedFunds : 0;
        require(withdrawable > 0, "No fees to withdraw");
        
        (bool success, ) = owner.call{value: withdrawable}("");
        require(success, "Withdrawal failed");
    }
    
    /**
     * @dev Get market details
     */
    function getMarket(uint256 marketId) 
        external 
        view 
        marketExists(marketId)
        returns (
            string memory question,
            string memory description,
            uint256 endTime,
            uint256 resolutionTime,
            bool resolved,
            bool outcome,
            uint256 totalYesShares,
            uint256 totalNoShares,
            uint256 totalPool,
            bool canceled
        )
    {
        Market storage market = markets[marketId];
        return (
            market.question,
            market.description,
            market.endTime,
            market.resolutionTime,
            market.resolved,
            market.outcome,
            market.totalYesShares,
            market.totalNoShares,
            market.totalPool,
            market.canceled
        );
    }
    
    /**
     * @dev Get user position in a market
     */
    function getPosition(uint256 marketId, address user)
        external
        view
        marketExists(marketId)
        returns (uint256 yesShares, uint256 noShares, bool claimed)
    {
        Position storage position = positions[marketId][user];
        return (position.yesShares, position.noShares, position.claimed);
    }
    
    /**
     * @dev Calculate potential payout for a position
     */
    function calculatePayout(uint256 marketId, address user, bool assumeOutcome)
        external
        view
        marketExists(marketId)
        returns (uint256)
    {
        Market storage market = markets[marketId];
        Position storage position = positions[marketId][user];
        
        if (market.canceled) {
            return position.yesShares + position.noShares;
        }
        
        uint256 winningShares = assumeOutcome ? position.yesShares : position.noShares;
        uint256 totalWinningShares = assumeOutcome ? market.totalYesShares : market.totalNoShares;
        
        if (winningShares == 0 || totalWinningShares == 0) {
            return 0;
        }
        
        uint256 fee = (market.totalPool * platformFee) / FEE_DENOMINATOR;
        uint256 payoutPool = market.totalPool - fee;
        
        return (payoutPool * winningShares) / totalWinningShares;
    }
    
    /**
     * @dev Transfer ownership
     */
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Invalid address");
        owner = newOwner;
    }
}