Address

• PulseMarket.sol

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

contract PulseMarket {
    address public immutable TREASURY;
    address public owner;
    uint256 public constant FEE_BPS = 200; // 2%

    bool private _locked;

    struct Market {
        string title;
        uint256 deadline; // unix seconds UTC
        bool resolved;
        bool outcome; // true = YES
        uint256 totalYes;
        uint256 totalNo;
    }

    Market[] public markets;
    mapping(uint256 => mapping(address => uint256)) public yesBets;
    mapping(uint256 => mapping(address => uint256)) public noBets;
    mapping(uint256 => mapping(address => bool)) public claimed;

    event MarketCreated(uint256 indexed id, string title, uint256 deadline);
    event BetPlaced(uint256 indexed id, address indexed user, bool yesBet, uint256 amount);
    event MarketResolved(uint256 indexed id, bool outcome);
    event Claimed(uint256 indexed id, address indexed user, uint256 payout);

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    modifier nonReentrant() {
        require(!_locked, "reentrancy");
        _locked = true;
        _;
        _locked = false;
    }

    constructor(address treasury) {
        require(treasury != address(0), "treasury zero");
        TREASURY = treasury;
        owner = msg.sender;

        // Seed 10 PulseChain related markets with fixed UTC deadlines (2025)
        _create("Will PulseX 24h volume exceed 50M USD by Nov 30 2025", 1764547199);
        _create("Will PLS price be above $0.001 on Nov 30 2025",           1764547199);
        _create("Will LibertySwap 24h volume exceed 10M USD by Nov 20 2025", 1763596800);
        _create("Will any PulseChain token enter top 100 by Dec 31 2025",   1767225599);
        _create("Will an official PulseChain AMA be hosted by Nov 25 2025", 1764028800);
        _create("Will PulseChain daily active addresses exceed 150k by Dec 10 2025", 1765324800);
        _create("Will PulseX introduce v3 incentives by Dec 15 2025",       1765756800);
        _create("Will total PLS burned exceed 5B by Dec 20 2025",           1766188800);
        _create("Will x402 style bridge integration go live on PulseChain by Dec 25 2025", 1766620800);
        _create("Will Pump.tires list 2000+ tokens by Nov 15 2025",         1763164800);
    }

    function _create(string memory title, uint256 deadline) internal {
        require(deadline > block.timestamp, "past deadline");
        markets.push(Market(title, deadline, false, false, 0, 0));
        emit MarketCreated(markets.length - 1, title, deadline);
    }

    function marketsLength() external view returns (uint256) {
        return markets.length;
    }

    function placeBet(uint256 id, bool betYes) external payable nonReentrant {
        Market storage m = markets[id];
        require(block.timestamp < m.deadline, "closed");
        require(msg.value > 0, "zero value");

        uint256 fee = (msg.value * FEE_BPS) / 10_000;
        uint256 stake = msg.value - fee;

        (bool okTreasury, ) = TREASURY.call{value: fee}("");
        require(okTreasury, "treasury transfer failed");

        if (betYes) {
            yesBets[id][msg.sender] += stake;
            m.totalYes += stake;
        } else {
            noBets[id][msg.sender] += stake;
            m.totalNo += stake;
        }

        emit BetPlaced(id, msg.sender, betYes, stake);
    }

    function resolveMarket(uint256 id, bool winYes) external onlyOwner nonReentrant {
        Market storage m = markets[id];
        require(block.timestamp >= m.deadline, "deadline not reached");
        require(!m.resolved, "already");
        m.resolved = true;
        m.outcome = winYes;
        emit MarketResolved(id, winYes);
    }

    function claim(uint256 id) external nonReentrant {
        Market storage m = markets[id];
        require(m.resolved, "not resolved");
        require(!claimed[id][msg.sender], "claimed");

        uint256 userStake = m.outcome ? yesBets[id][msg.sender] : noBets[id][msg.sender];
        require(userStake > 0, "no winning bet");

        uint256 winners = m.outcome ? m.totalYes : m.totalNo;
        require(winners > 0, "no winners");

        uint256 pool = m.totalYes + m.totalNo;
        uint256 payout = (pool * userStake) / winners;

        claimed[id][msg.sender] = true;
        (bool ok, ) = msg.sender.call{value: payout}("");
        require(ok, "payout failed");

        emit Claimed(id, msg.sender, payout);
    }

    function sweepIfNoWinners(uint256 id) external onlyOwner nonReentrant {
        Market storage m = markets[id];
        require(m.resolved, "not resolved");
        uint256 winners = m.outcome ? m.totalYes : m.totalNo;
        require(winners == 0, "has winners");
        uint256 pool = m.totalYes + m.totalNo;
        m.totalYes = 0;
        m.totalNo = 0;
        (bool ok, ) = TREASURY.call{value: pool}("");
        require(ok, "sweep failed");
    }

    function transferOwnership(address n) external onlyOwner {
        require(n != address(0), "zero");
        owner = n;
    }

    receive() external payable {}
}