Quickstart

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

interface IDelphAI {
    function createMarket(
        string memory question,
        string memory description,
        string[] memory possibleOutcomes,
        uint256 resolutionTimestamp
    ) external payable returns (uint256);

    function getMarket(uint256 marketId) external view returns (Market memory);
    function marketCreationFee() external view returns (uint256);
}

struct Market {
    uint256 id;
    address creator;
    string question;
    string description;
    string[] possibleOutcomes;
    uint256 createdAt;
    uint256 resolutionTimestamp;
    MarketStatus status;
    uint256 outcomeIndex;
    string resolutionData;
    string[] resolutionSources;
    uint8 resolutionConfidence;
    bytes proofData;
    uint256 resolvedAt;
    address resolvedBy;
}

enum MarketStatus { Open, Resolved, Cancelled }

contract PredictionMarket {
    IDelphAI public immutable delphAI;

    struct MarketData {
        uint256 delphAIMarketId;
        mapping(address => mapping(uint256 => uint256)) bets;
        uint256 totalPool;
    }

    mapping(uint256 => MarketData) public markets;

    constructor(address _delphAI) {
        delphAI = IDelphAI(_delphAI);
    }

    function createMarket(
        string memory question,
        string memory description,
        string[] memory outcomes,
        uint256 resolutionTime
    ) external payable returns (uint256) {
        // Get creation fee and create market on delphAI
        uint256 marketId = delphAI.createMarket{value: msg.value}(
            question,
            description,
            outcomes,
            resolutionTime
        );

        // Store market ID for later
        markets[marketId].delphAIMarketId = marketId;

        return marketId;
    }

    function placeBet(uint256 marketId, uint256 outcome)
        external
        payable
    {
        Market memory market = delphAI.getMarket(marketId);
        require(market.status == MarketStatus.Open, "Market not open");
        require(block.timestamp < market.resolutionTimestamp, "Market closed");

        markets[marketId].bets[msg.sender][outcome] += msg.value;
        markets[marketId].totalPool += msg.value;
    }

    function claimWinnings(uint256 marketId) external {
        Market memory market = delphAI.getMarket(marketId);
        require(market.status == MarketStatus.Resolved, "Not resolved");

        uint256 winningOutcome = market.outcomeIndex;
        uint256 userBet = markets[marketId].bets[msg.sender][winningOutcome];
        require(userBet > 0, "No winning bet");

        // Your payout logic here
        // Calculate and transfer winnings
        markets[marketId].bets[msg.sender][winningOutcome] = 0;
    }

    function getWinningOutcome(uint256 marketId)
        external
        view
        returns (string memory)
    {
        Market memory market = delphAI.getMarket(marketId);
        require(market.status == MarketStatus.Resolved, "Not resolved");

        return market.possibleOutcomes[market.outcomeIndex];
    }
}