UNISUPPLYPM

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

address constant UNI = 0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984;
address constant PAMM = 0x000000000071176401AdA1f2CD7748e28E173FCa;

interface IPAMM {
    function createMarket(
        string calldata description,
        address resolver,
        uint72 close,
        bool canClose,
        uint256 seedYes,
        uint256 seedNo
    ) external returns (uint256 marketId, uint256 noId);

    function closeMarket(uint256 marketId) external;
    function resolve(uint256 marketId, bool outcome) external;
}

/// @notice Bet on UNI supply. Forever on Ethereum.
/// @dev Markets resolve early if threshold is met.
contract UNISUPPLYPM {
    error Unknown();
    error Pending();

    mapping(uint256 marketId => Bet) public bets;

    struct Bet { uint184 amount; uint72 deadline; }
    
    function totalSupply() public view returns (uint256) {
        return UNISUPPLYPM(UNI).totalSupply();
    }

    function makeBet(uint184 amount, uint72 deadline, uint256 seedYes, uint256 seedNo) public returns (uint256 marketId, uint256 noId) {
        string memory description = string(
            abi.encodePacked(
                "UNI totalSupply() > ",
                _toString(amount),
                " tokens (wei) by ",
                _toString(deadline),
                " Unix epoch time. ",
                "Note: market may close early once threshold is reached."
            )
        );
        (marketId, noId) = IPAMM(PAMM).createMarket(description, address(this), deadline, true, seedYes, seedNo);
        bets[marketId] = Bet(amount, deadline);
    }

    function makeBetAnyMint(uint72 deadline, uint256 seedYes, uint256 seedNo) public returns (uint256 marketId, uint256 noId) {
        return makeBet(uint184(totalSupply()), deadline, seedYes, seedNo);
    }

    function resolveBet(uint256 marketId) public {
        Bet memory b = bets[marketId];
        if (b.deadline == 0) revert Unknown();

        if (totalSupply() > b.amount) {
            if (block.timestamp < b.deadline) IPAMM(PAMM).closeMarket(marketId);
            IPAMM(PAMM).resolve(marketId, true);
            delete bets[marketId];
            return;
        }

        if (block.timestamp < b.deadline) revert Pending();
        IPAMM(PAMM).resolve(marketId, false);
        delete bets[marketId];
    }

    function _toString(uint256 value) internal pure returns (string memory result) {
        assembly ("memory-safe") {
            result := add(mload(0x40), 0x80)
            mstore(0x40, add(result, 0x20))
            mstore(result, 0)
            let end := result
            let w := not(0)
            for { let temp := value } 1 {} {
                result := add(result, w)
                mstore8(result, add(48, mod(temp, 10)))
                temp := div(temp, 10)
                if iszero(temp) { break }
            }
            let n := sub(end, result)
            result := sub(result, 0x20)
            mstore(result, n)
        }
    }
}