Contract Address Details

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {IGrailMarket} from "./interfaces/IGrailMarket.sol";
import {Currency} from "./types/Currency.sol";
import {MarketId} from "./types/MarketId.sol";
import {Market} from "./libraries/Market.sol";
import {BaseMarket} from "./base/BaseMarket.sol";
import {BaseMarketConfig} from "./base/BaseMarketConfig.sol";

contract GrailMarket is IGrailMarket, BaseMarket, BaseMarketConfig {
    constructor(address _owner, address _pyth, Currency _currency) BaseMarketConfig(_owner, _pyth, _currency) {}

    /// @inheritdoc IGrailMarket
    function resolve(MarketId id, uint256 roundId, bytes calldata priceUpdate) external payable override {
        Market.MarketInfo storage market = markets[id];
        Market.Round storage round = market.rounds[roundId];

        // ensure round status can be setlled
        if (round.status != Market.RoundStatus.LIVE) revert InvalidRoundStatus();

        // ensure the timing is right
        if (round.closingTime > block.timestamp) revert ActionTooEarly();

        (int64 closingPrice,) =
            _fetchAssetPrice(market.oracleId, priceUpdate, round.closingTime, round.closingTime + MAX_SECONDS_OFFSET);

        // lock the following n + 1 round
        _lockMarketRound(market, id, roundId + 1, closingPrice);
        // start another n + 2 round
        _startNextRound(market, id);

        // only collect protocol fee when position exists on both sides
        bool isRefunding;
        uint256 winningSide;

        if (round.bearShares > 0 && round.bullShares > 0) {
            // calculate protocol fee
            uint128 protocolFee = (round.totalShares * config.protocolFeeBps) / BASIS_POINT;
            // calculate incentive fee
            uint128 incentiveFee = (protocolFee * config.incentiveFeeBps) / BASIS_POINT;
            uint128 netProtocolFee = protocolFee - incentiveFee;
            round.rewardPool = round.totalShares - protocolFee;

            // account for fee
            unchecked {
                protocolFeesAccrued += netProtocolFee;
            }

            // if closing price greater than locked price, market was bullish, the bulls wins
            if (closingPrice > round.priceMark) {
                round.winningShares = round.bullShares;
                winningSide = 1;
                // if closing price less than locked price, market was bearish, the bears wins
            } else if (closingPrice < round.priceMark) {
                round.winningShares = round.bearShares;
            }

            round.status = Market.RoundStatus.RESOLVED;
            round.closingPrice = closingPrice;
            // transfer the resolver fee
            _tryCredit(msg.sender, incentiveFee);
        } else {
            // we should probably refund as we are not interested in the protocol winning
            isRefunding = true;
            round.status = Market.RoundStatus.REFUNDING;
            round.closingPrice = closingPrice;
        }

        emit Resolve(id, roundId, round.rewardPool, round.winningShares, closingPrice, winningSide, isRefunding);
    }

    /// @inheritdoc IGrailMarket
    function setResolverFee(uint16 fee) external override onlyOwner {
        // ensure fee is moderate
        if (fee > MAX_PROTOCOL_FEE) revert FeeTooLarge(fee);

        config.incentiveFeeBps = fee;
        emit SetProtocolFee(fee);
    }
}
        

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

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}
          

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

import "./PythStructs.sol";
import "./IPythEvents.sol";

/// @title Consume prices from the Pyth Network (https://pyth.network/).
/// @dev Please refer to the guidance at https://docs.pyth.network/documentation/pythnet-price-feeds/best-practices for how to consume prices safely.
/// @author Pyth Data Association
interface IPyth is IPythEvents {
    /// @notice Returns the price of a price feed without any sanity checks.
    /// @dev This function returns the most recent price update in this contract without any recency checks.
    /// This function is unsafe as the returned price update may be arbitrarily far in the past.
    ///
    /// Users of this function should check the `publishTime` in the price to ensure that the returned price is
    /// sufficiently recent for their application. If you are considering using this function, it may be
    /// safer / easier to use `getPriceNoOlderThan`.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getPriceUnsafe(
        bytes32 id
    ) external view returns (PythStructs.Price memory price);

    /// @notice Returns the price that is no older than `age` seconds of the current time.
    /// @dev This function is a sanity-checked version of `getPriceUnsafe` which is useful in
    /// applications that require a sufficiently-recent price. Reverts if the price wasn't updated sufficiently
    /// recently.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getPriceNoOlderThan(
        bytes32 id,
        uint age
    ) external view returns (PythStructs.Price memory price);

    /// @notice Returns the exponentially-weighted moving average price of a price feed without any sanity checks.
    /// @dev This function returns the same price as `getEmaPrice` in the case where the price is available.
    /// However, if the price is not recent this function returns the latest available price.
    ///
    /// The returned price can be from arbitrarily far in the past; this function makes no guarantees that
    /// the returned price is recent or useful for any particular application.
    ///
    /// Users of this function should check the `publishTime` in the price to ensure that the returned price is
    /// sufficiently recent for their application. If you are considering using this function, it may be
    /// safer / easier to use either `getEmaPrice` or `getEmaPriceNoOlderThan`.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getEmaPriceUnsafe(
        bytes32 id
    ) external view returns (PythStructs.Price memory price);

    /// @notice Returns the exponentially-weighted moving average price that is no older than `age` seconds
    /// of the current time.
    /// @dev This function is a sanity-checked version of `getEmaPriceUnsafe` which is useful in
    /// applications that require a sufficiently-recent price. Reverts if the price wasn't updated sufficiently
    /// recently.
    /// @return price - please read the documentation of PythStructs.Price to understand how to use this safely.
    function getEmaPriceNoOlderThan(
        bytes32 id,
        uint age
    ) external view returns (PythStructs.Price memory price);

    /// @notice Update price feeds with given update messages.
    /// This method requires the caller to pay a fee in wei; the required fee can be computed by calling
    /// `getUpdateFee` with the length of the `updateData` array.
    /// Prices will be updated if they are more recent than the current stored prices.
    /// The call will succeed even if the update is not the most recent.
    /// @dev Reverts if the transferred fee is not sufficient or the updateData is invalid.
    /// @param updateData Array of price update data.
    function updatePriceFeeds(bytes[] calldata updateData) external payable;

    /// @notice Wrapper around updatePriceFeeds that rejects fast if a price update is not necessary. A price update is
    /// necessary if the current on-chain publishTime is older than the given publishTime. It relies solely on the
    /// given `publishTimes` for the price feeds and does not read the actual price update publish time within `updateData`.
    ///
    /// This method requires the caller to pay a fee in wei; the required fee can be computed by calling
    /// `getUpdateFee` with the length of the `updateData` array.
    ///
    /// `priceIds` and `publishTimes` are two arrays with the same size that correspond to senders known publishTime
    /// of each priceId when calling this method. If all of price feeds within `priceIds` have updated and have
    /// a newer or equal publish time than the given publish time, it will reject the transaction to save gas.
    /// Otherwise, it calls updatePriceFeeds method to update the prices.
    ///
    /// @dev Reverts if update is not needed or the transferred fee is not sufficient or the updateData is invalid.
    /// @param updateData Array of price update data.
    /// @param priceIds Array of price ids.
    /// @param publishTimes Array of publishTimes. `publishTimes[i]` corresponds to known `publishTime` of `priceIds[i]`
    function updatePriceFeedsIfNecessary(
        bytes[] calldata updateData,
        bytes32[] calldata priceIds,
        uint64[] calldata publishTimes
    ) external payable;

    /// @notice Returns the required fee to update an array of price updates.
    /// @param updateData Array of price update data.
    /// @return feeAmount The required fee in Wei.
    function getUpdateFee(
        bytes[] calldata updateData
    ) external view returns (uint feeAmount);

    /// @notice Parse `updateData` and return price feeds of the given `priceIds` if they are all published
    /// within `minPublishTime` and `maxPublishTime`.
    ///
    /// You can use this method if you want to use a Pyth price at a fixed time and not the most recent price;
    /// otherwise, please consider using `updatePriceFeeds`. This method may store the price updates on-chain, if they
    /// are more recent than the current stored prices.
    ///
    /// This method requires the caller to pay a fee in wei; the required fee can be computed by calling
    /// `getUpdateFee` with the length of the `updateData` array.
    ///
    ///
    /// @dev Reverts if the transferred fee is not sufficient or the updateData is invalid or there is
    /// no update for any of the given `priceIds` within the given time range.
    /// @param updateData Array of price update data.
    /// @param priceIds Array of price ids.
    /// @param minPublishTime minimum acceptable publishTime for the given `priceIds`.
    /// @param maxPublishTime maximum acceptable publishTime for the given `priceIds`.
    /// @return priceFeeds Array of the price feeds corresponding to the given `priceIds` (with the same order).
    function parsePriceFeedUpdates(
        bytes[] calldata updateData,
        bytes32[] calldata priceIds,
        uint64 minPublishTime,
        uint64 maxPublishTime
    ) external payable returns (PythStructs.PriceFeed[] memory priceFeeds);

    /// @notice Similar to `parsePriceFeedUpdates` but ensures the updates returned are
    /// the first updates published in minPublishTime. That is, if there are multiple updates for a given timestamp,
    /// this method will return the first update. This method may store the price updates on-chain, if they
    /// are more recent than the current stored prices.
    ///
    ///
    /// @dev Reverts if the transferred fee is not sufficient or the updateData is invalid or there is
    /// no update for any of the given `priceIds` within the given time range and uniqueness condition.
    /// @param updateData Array of price update data.
    /// @param priceIds Array of price ids.
    /// @param minPublishTime minimum acceptable publishTime for the given `priceIds`.
    /// @param maxPublishTime maximum acceptable publishTime for the given `priceIds`.
    /// @return priceFeeds Array of the price feeds corresponding to the given `priceIds` (with the same order).
    function parsePriceFeedUpdatesUnique(
        bytes[] calldata updateData,
        bytes32[] calldata priceIds,
        uint64 minPublishTime,
        uint64 maxPublishTime
    ) external payable returns (PythStructs.PriceFeed[] memory priceFeeds);
}
          

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

/// @title IPythEvents contains the events that Pyth contract emits.
/// @dev This interface can be used for listening to the updates for off-chain and testing purposes.
interface IPythEvents {
    /// @dev Emitted when the price feed with `id` has received a fresh update.
    /// @param id The Pyth Price Feed ID.
    /// @param publishTime Publish time of the given price update.
    /// @param price Price of the given price update.
    /// @param conf Confidence interval of the given price update.
    event PriceFeedUpdate(
        bytes32 indexed id,
        uint64 publishTime,
        int64 price,
        uint64 conf
    );
}
          

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

contract PythStructs {
    // A price with a degree of uncertainty, represented as a price +- a confidence interval.
    //
    // The confidence interval roughly corresponds to the standard error of a normal distribution.
    // Both the price and confidence are stored in a fixed-point numeric representation,
    // `x * (10^expo)`, where `expo` is the exponent.
    //
    // Please refer to the documentation at https://docs.pyth.network/documentation/pythnet-price-feeds/best-practices for how
    // to how this price safely.
    struct Price {
        // Price
        int64 price;
        // Confidence interval around the price
        uint64 conf;
        // Price exponent
        int32 expo;
        // Unix timestamp describing when the price was published
        uint publishTime;
    }

    // PriceFeed represents a current aggregate price from pyth publisher feeds.
    struct PriceFeed {
        // The price ID.
        bytes32 id;
        // Latest available price
        Price price;
        // Latest available exponentially-weighted moving average price
        Price emaPrice;
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {IBaseMarket} from "../interfaces/IBaseMarket.sol";
import {ICommonEvents} from "../interfaces/ICommonEvents.sol";
import {MarketId} from "../types/MarketId.sol";
import {Currency} from "../types/Currency.sol";

import {Option, OptionLibrary} from "../libraries/Option.sol";
import {Position} from "../libraries/Position.sol";
import {Market} from "../libraries/Market.sol";

import {Ownable} from "solady/auth/Ownable.sol";

abstract contract BaseMarket is IBaseMarket, ICommonEvents, Ownable {
    using OptionLibrary for Option;

    Currency public immutable currency;
    // @dev keeps track of total value locked to aid token recovery
    uint256 public tvl;

    /// @dev keeps track of each markets data
    mapping(MarketId id => Market.MarketInfo) public markets;

    constructor(Currency _currency) {
        currency = _currency;
    }

    /// @inheritdoc IBaseMarket
    function bullish(MarketId id, uint256 roundId, uint256 stake) external payable override {
        bytes32 positionId = _takePosition(id, roundId, msg.sender, uint128(stake), Option.wrap(1));
        // try debiting the user
        _tryDebit(msg.sender, stake, msg.value);
        emit Bullish(id, roundId, msg.sender, positionId, stake);
    }

    /// @inheritdoc IBaseMarket
    function bearish(MarketId id, uint256 roundId, uint256 stake) external payable override {
        bytes32 positionId = _takePosition(id, roundId, msg.sender, uint128(stake), Option.wrap(0));
        // try debiting the user
        _tryDebit(msg.sender, stake, msg.value);
        emit Bearish(id, roundId, msg.sender, positionId, stake);
    }

    /// @inheritdoc IBaseMarket
    function settle(MarketId id, uint256 roundId) external override {
        uint256 reward = _settle(id, roundId, msg.sender);
        // credit the user
        _tryCredit(msg.sender, reward);
    }

    /// @inheritdoc IBaseMarket
    function settleFor(MarketId id, uint256 roundId, address account) external override {
        uint256 reward = _settle(id, roundId, account);
        // credit the user
        _tryCredit(account, reward);
    }

    /// @inheritdoc IBaseMarket
    function settleBatch(MarketId id, uint256[] calldata roundIds) external override {
        uint256 len = roundIds.length;
        uint256 reward;

        for (uint256 i = 0; i < len;) {
            reward = _settle(id, roundIds[i], msg.sender);

            unchecked {
                ++i;
            }
        }

        // credit the user
        _tryCredit(msg.sender, reward);
    }

    /// @inheritdoc IBaseMarket
    function claimRefund(MarketId id, uint256 roundId) external override {
        Market.MarketInfo storage market = markets[id];
        Market.Round storage round = market.rounds[roundId];

        bytes32 positionId = Position.toId(id, roundId, msg.sender);
        Position.State storage position = market.positions[positionId];

        // ensure the round is refunding
        if (round.status != Market.RoundStatus.REFUNDING) revert InvalidRoundStatus();
        // ensure the user has not claimed before
        if (position.settled) revert RewardClaimed();

        position.settled = true;

        // credit user stake
        _tryCredit(msg.sender, position.stake);
        emit ClaimRefund(id, roundId, msg.sender, positionId, position.stake);
    }

    /// @inheritdoc IBaseMarket
    function recoverToken(Currency token, address recipient, uint256 amount) external override onlyOwner {
        token.transfer(recipient, amount);

        /// @notice ensure recovery will not have negative impact on the total value locked
        uint256 balanceAfter = token.balanceOfSelf();
        if (token == currency && balanceAfter < tvl) revert InsufficientBalance();

        emit RecoverToken(token, recipient, amount);
    }

    /// @inheritdoc IBaseMarket
    function getRoundInfo(MarketId id, uint256 roundId, address account)
        external
        view
        override
        returns (Market.Round memory r, Position.State memory p)
    {
        Market.MarketInfo storage market = markets[id];
        r = market.rounds[roundId];

        bytes32 positionId = Position.toId(id, roundId, account);
        p = market.positions[positionId];
    }

    /// @inheritdoc IBaseMarket
    function getPositionInfo(MarketId id, uint256 roundId, address account)
        external
        view
        returns (Position.State memory r)
    {
        Market.MarketInfo storage market = markets[id];
        bytes32 positionId = Position.toId(id, roundId, account);
        r = market.positions[positionId];
    }

    /**
     * ============================== Private/Internal functions =================================
     */
    function _takePosition(MarketId id, uint256 roundId, address account, uint128 stake, Option option)
        private
        returns (bytes32 positionId)
    {
        Market.MarketInfo storage market = markets[id];
        Market.Round storage round = market.rounds[roundId];

        // ensure market is initialized
        if (market.oracleId == bytes32(0)) revert MarketDoesNotExist();
        // ensure round entry is open
        if (round.status != Market.RoundStatus.OPEN) revert EntryNotAllowed();
        // ensure stake is not zero
        if (stake == 0) revert CannotStakeZeroAmount();

        positionId = Position.toId(id, roundId, account);
        Position.State storage position = market.positions[positionId];

        // ensure user has no previous position
        if (position.stake > 0) revert PositionAlreadyExist();

        // if all checks well, open position
        // probably not going to overflow, even if Elon Musk stakes all his wealth, LOL!
        unchecked {
            round.totalShares += stake;

            if (option.isBullish()) {
                round.bullShares += stake;
            } else {
                round.bearShares += stake;
            }
        }

        position.stake = stake;
        position.option = option;
    }

    function _settle(MarketId id, uint256 roundId, address account) private returns (uint256 reward) {
        Market.MarketInfo storage market = markets[id];
        Market.Round storage round = market.rounds[roundId];

        bytes32 positionId = Position.toId(id, roundId, account);
        Position.State storage position = market.positions[positionId];

        // ensure round has been settled
        if (round.status != Market.RoundStatus.RESOLVED) revert InvalidRoundStatus();
        // ensure user has a valid position
        if (position.stake == 0) revert PositionNotFound();
        // ensure user has not claimed reward already
        if (position.settled) revert RewardClaimed();

        // tag claimed to avoid reentrancy
        position.settled = true;
        bool isRewardable;

        if (position.option.isBullish()) {
            isRewardable = round.closingPrice > round.priceMark;
        } else {
            isRewardable = round.closingPrice < round.priceMark;
        }

        if (isRewardable) {
            reward = ((position.stake * round.rewardPool) / round.winningShares);
        } else {
            revert SorryNoReward();
        }

        emit Settle(id, roundId, account, positionId, reward);
    }

    /**
     * @dev allow transfer or crediting user balance
     *
     * @param account the address of user debit from
     * @param amount the amount to debit
     */
    function _tryCredit(address account, uint256 amount) internal {
        unchecked {
            tvl -= amount;
        }
        currency.transfer(account, amount);
    }

    /**
     * @dev allow pulling or debiting user balance
     *
     * @param account the address of user debit from
     * @param amount the amount to debit
     * @param value the original message value
     */
    function _tryDebit(address account, uint256 amount, uint256 value) internal {
        unchecked {
            tvl += amount;
        }

        if (currency.isNative()) {
            if (amount != value) revert InsufficientFee();
        } else {
            currency.safeTransferFrom(account, address(this), amount);
        }
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {IBaseMarketConfig} from "../interfaces/IBaseMarketConfig.sol";
import {IPyth} from "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import {Currency} from "../types/Currency.sol";
import {MarketId} from "../types/MarketId.sol";

import {Market} from "../libraries/Market.sol";
import {PythStructs} from "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

import {BaseMarket} from "./BaseMarket.sol";

abstract contract BaseMarketConfig is IBaseMarketConfig, BaseMarket {
    uint16 public constant MAX_PROTOCOL_FEE = 1000; // 10%
    uint16 public constant BASIS_POINT = 10_000;
    uint8 public constant MAX_SECONDS_OFFSET = 10;
    uint256 public constant CAN_CANCEL_AFTER = 15 minutes;

    IPyth public immutable pyth;

    uint256 public protocolFeesAccrued;
    Market.Config public config;

    constructor(address _owner, address _pyth, Currency _currency) BaseMarket(_currency) {
        _initializeOwner(_owner);

        pyth = IPyth(_pyth);

        config.duration = uint48(5 minutes);
        config.incentiveFeeBps = 500; // 5%
        config.protocolFeeBps = 500; // 5%
    }

    /// @inheritdoc IBaseMarketConfig
    function createMarket(MarketId id, bytes calldata priceUpdate) external payable override {
        Market.MarketInfo storage market = markets[id];
        bytes32 oracleId = MarketId.unwrap(id);

        // ensure market does not exist already
        if (market.oracleId != bytes32(0)) revert MarketAlreadyExist();

        uint64 minPublishTime = uint64(block.timestamp - 5 minutes);
        // no use for the price, just to ascertain a priceFeed exists on-chain
        (int64 price,) = _fetchAssetPrice(oracleId, priceUpdate, minPublishTime, uint64(block.timestamp));

        market.oracleId = MarketId.unwrap(id);

        emit CreateMarket(id, msg.sender);

        // start and lock the genesis round
        _startNextRound(market, id);
        // lock the genesis round
        _lockMarketRound(market, id, 1, price);
        // start n + 2 round
        _startNextRound(market, id);
    }

    /// @inheritdoc IBaseMarketConfig
    function collectProtocolFee(address recipient, uint256 amount) external override onlyOwner {
        uint256 amountCollected;

        amountCollected = (amount == 0) ? protocolFeesAccrued : amount;
        protocolFeesAccrued -= amountCollected;

        // credit the recipient
        _tryCredit(recipient, amountCollected);
        emit CollectFee(currency, msg.sender, recipient, amountCollected);
    }

    /// @inheritdoc IBaseMarketConfig
    function setProtocolFee(uint16 fee) external override onlyOwner {
        // ensure fee is moderate
        if (fee > MAX_PROTOCOL_FEE) revert FeeTooLarge(fee);

        config.protocolFeeBps = fee;
        emit SetProtocolFee(fee);
    }

    /// @inheritdoc IBaseMarketConfig
    function setMarketDuration(uint32 duration) external override onlyOwner {
        config.duration = duration;
        emit SetMarketDuration(duration);
    }

    /// @inheritdoc IBaseMarketConfig
    function setMinStakeAmount(uint256 minStakeAmount) external override onlyOwner {
        config.minStakeAmount = uint176(minStakeAmount);
        emit SetMinStakeAmount(minStakeAmount);
    }

    /// @inheritdoc IBaseMarketConfig
    function cancelRound(MarketId id, uint256 roundId, bytes calldata priceUpdate) external payable override {
        Market.MarketInfo storage market = markets[id];
        Market.Round storage round = market.rounds[roundId];

        // ensure the round status allows cancellation
        if (round.status != Market.RoundStatus.LIVE) revert InvalidRoundStatus();

        // ensure users can only cancel when round cannot be locked/settled
        if (round.closingTime + CAN_CANCEL_AFTER > block.timestamp) revert ActionTooEarly();

        round.status = Market.RoundStatus.REFUNDING;

        // fetch asset price
        (int64 price,) =
            _fetchAssetPrice(market.oracleId, priceUpdate, uint64(block.timestamp - 1 minutes), uint64(block.timestamp));

        /// @dev we should also maintain the loop by
        // locking n + 1 round
        _lockMarketRound(market, id, roundId + 1, price);
        // start n + 2 round
        _startNextRound(market, id);

        emit CancelRound(id, roundId);
    }

    /**
     * ============================ Internal functions ==================================
     */
    function _fetchAssetPrice(
        bytes32 priceFeedId,
        bytes calldata priceUpdateData,
        uint64 minPublishTime,
        uint64 maxPublishTime
    ) internal returns (int64 latestPrice, uint256 publishTime) {
        bytes32[] memory priceFeedIds = new bytes32[](1);
        priceFeedIds[0] = priceFeedId;

        bytes[] memory updateData = new bytes[](1);
        updateData[0] = priceUpdateData;

        uint256 updateFee = pyth.getUpdateFee(updateData);
        if (msg.value < updateFee) revert InsufficientFee();

        PythStructs.PriceFeed[] memory priceFeeds =
            pyth.parsePriceFeedUpdates{value: updateFee}(updateData, priceFeedIds, minPublishTime, maxPublishTime);

        PythStructs.PriceFeed memory priceFeed = priceFeeds[0];
        PythStructs.Price memory price = priceFeed.price;

        latestPrice = price.price;
        publishTime = price.publishTime;
    }

    function _startNextRound(Market.MarketInfo storage market, MarketId id) internal {
        uint256 roundId = ++market.roundId;

        uint64 openingTime = uint64(block.timestamp);
        uint64 closingTime = uint64(openingTime + (config.duration * 2));

        Market.Round storage round = market.rounds[roundId];
        round.status = Market.RoundStatus.OPEN;
        round.openingTime = openingTime;
        round.closingTime = closingTime;

        emit NewRound(id, roundId, openingTime, closingTime);
    }

    function _lockMarketRound(Market.MarketInfo storage market, MarketId id, uint256 roundId, int64 price) internal {
        Market.Round storage round = market.rounds[roundId];
        uint64 closingTime = uint64(block.timestamp + config.duration);
        round.status = Market.RoundStatus.LIVE;
        round.closingTime = closingTime;
        round.priceMark = price;

        emit SetRoundPriceMark(id, roundId, price, closingTime);
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {Currency} from "../types/Currency.sol";
import {MarketId} from "../types/MarketId.sol";
import {Market} from "../libraries/Market.sol";
import {Position} from "../libraries/Position.sol";

interface IBaseMarket {
    /// @notice Revert when trying to spend more than your available balance
    error InsufficientBalance();

    /// @notice Revert when caller provides insufficient fee for Pyth calls
    error InsufficientFee();

    /// @notice Revert when it is too early to perform an action
    error ActionTooEarly();

    /// @notice Revert if market already exist
    error MarketAlreadyExist();

    /// @notice Revert if round status does not meet action requirement
    error InvalidRoundStatus();

    /// @notice Revert if reward has been claimed
    error RewardClaimed();

    /// @notice Revert if no reward to claim
    error SorryNoReward();

    /// @notice Revert when trying to interact with non-existing market
    error MarketDoesNotExist();

    /// @notice Revert when a round entry is no longer allowed
    error EntryNotAllowed();

    /// @notice Revert when trying to open a position double position
    error PositionAlreadyExist();

    /// @notice Revert if the position has no stake
    error PositionNotFound();

    /// @notice Revert when stake is zero
    error CannotStakeZeroAmount();

    /// @notice Revert when trying to recover accepted token in cross-chain pools
    error CannotRecoverCurrency();

    /**
     * @notice Called to place a bullish bet on a market
     *
     * @param id the identifier of market to open position in
     * @param roundId the unique id of the active round
     * @param stake the amount staked as wager for position
     */
    function bullish(MarketId id, uint256 roundId, uint256 stake) external payable;

    /**
     * @notice Called to place a bearish bet on a market
     *
     * @param id the identifier of market to open position in
     * @param roundId the unique id of the active round
     * @param stake the amount staked as wager for position
     */
    function bearish(MarketId id, uint256 roundId, uint256 stake) external payable;

    /**
     * @dev Allows owner to settle a position, more like claiming rewards accrued in `roundId`
     *
     * @param id market identifier
     * @param roundId round identifier
     */
    function settle(MarketId id, uint256 roundId) external;

    /**
     * @dev Allows anyone to settle a position, more like claiming rewards accrued in `roundId`
     * @notice Anyone can claim onbehalf of someone else, opening door for automating claiming to improve UX
     *
     * @param id market identifier
     * @param roundId round identifier
     * @param account the position owner
     */
    function settleFor(MarketId id, uint256 roundId, address account) external;

    /**
     * @dev Allows anyone to settle positions, more like claiming rewards accrued in `roundIds`
     * @notice Only the position owner can claim batch reward
     *
     * @param id market identifier
     * @param roundIds array of round identifiers
     */
    function settleBatch(MarketId id, uint256[] calldata roundIds) external;

    /**
     * @dev Allows anyone to claim refund of cancelled round
     * @notice Can be called by onyone on behalf of someone else
     *
     * @param id market identifier
     * @param roundId round identifier
     */
    function claimRefund(MarketId id, uint256 roundId) external;

    /**
     * @notice useful for recovering native/local tokens sent to the contract by mistake
     *
     * @param currency address of token to withdraw
     * @param recipient address of token receiver
     * @param amount amount of token to withdraw
     */
    function recoverToken(Currency currency, address recipient, uint256 amount) external;

    /**
     * @dev Returns market round info
     *
     * @param id market identifier
     * @param roundId round identifier
     * @param account address to fetch position for
     *
     */
    function getRoundInfo(MarketId id, uint256 roundId, address account)
        external
        view
        returns (Market.Round memory r, Position.State memory p);

    /**
     * @dev Returns market round info
     *
     * @param id market identifier
     * @param roundId round identifier
     * @return market market info
     *
     */
    function getPositionInfo(MarketId id, uint256 roundId, address account)
        external
        view
        returns (Position.State memory);
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {Currency} from "../types/Currency.sol";
import {MarketId} from "../types/MarketId.sol";

interface IBaseMarketConfig {
    /// @notice Revert when protocol fee exceeds maximum allowed
    error FeeTooLarge(uint16 fee);

    /**
     * @dev Emitted when the protocol manager collects accrued fees
     */
    event CollectFee(Currency indexed currency, address indexed collector, address indexed recipient, uint256 amount);

    /**
     * @dev Emitted when a new protocol fee is set for market
     */
    event SetProtocolFee(uint16 newFee);

    /**
     * @dev Emitted when a new resolver fee is set
     */
    event SetResolverFee(uint16 newFee);

    /**
     * @dev Emitted when the market duration is updated
     */
    event SetMarketDuration(uint32 duration);

    /**
     * @notice Emitted when the minimum stake for a market is updated
     */
    event SetMinStakeAmount(uint256 minStakeAmount);

    /**
     * @dev Allows anyone to initialize a new market if it's not yet existing
     *
     * @param id Pyth oracle price feed identifier
     * @param priceUpdate pyth price update data
     */
    function createMarket(MarketId id, bytes calldata priceUpdate) external payable;

    /**
     * @dev Allows protocol managers to collect accrued fee
     *
     * @param recipient address to forward fund to
     * @param amount amount
     */
    function collectProtocolFee(address recipient, uint256 amount) external;

    /**
     * @dev Allows protocol managers to set fee for market
     *
     * @param fee the fee in BPS
     */
    function setProtocolFee(uint16 fee) external;

    /**
     * @dev Allow managers to adjust how long a round lasts
     *
     * @param duration the new duration in seconds
     */
    function setMarketDuration(uint32 duration) external;

    /**
     * @dev Allows protocol managers to set minimum stake amount
     * for market
     *
     * @param minStakeAmount the minimum allowed stake
     */
    function setMinStakeAmount(uint256 minStakeAmount) external;

    /**
     * @dev Allows anyone to cancel round to allow users claim refund of stakes
     * @notice Calling this function will cancel round with `roundId`, locks round
     * with id roundId + 1 and equally starts a new round with id of roundId + 2
     *
     * @param id market identifier
     * @param roundId id of round to cancel
     * @param priceUpdate pyth price update data
     */
    function cancelRound(MarketId id, uint256 roundId, bytes calldata priceUpdate) external payable;
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {Currency} from "../types/Currency.sol";
import {MarketId} from "../types/MarketId.sol";

interface ICommonEvents {
    /**
     * @dev Emitted when a new prediction round is started
     */
    event NewRound(MarketId indexed id, uint256 indexed roundId, uint256 openingTime, uint256 closingTime);

    /**
     * @dev Emitted when a round's price mark is locked
     */
    event SetRoundPriceMark(MarketId indexed id, uint256 indexed roundId, int256 priceMark, uint256 closingTime);

    /**
     * @dev Emitted when a round is resolved
     */
    event Resolve(
        MarketId indexed id,
        uint256 indexed roundId,
        uint256 rewardPool,
        uint256 totalWinningStake,
        int256 closingPrice,
        uint256 winningSide,
        bool isRefunding
    );

    /**
     * @dev Emitted when a round is cancelled for any reason
     */
    event CancelRound(MarketId indexed id, uint256 indexed roundId);

    /**
     * @dev Emitted whenever a new market is created successfully
     */
    event CreateMarket(MarketId indexed id, address creator);

    /**
     * @dev Emiited when a user opens a bearish position on a market
     */
    event Bearish(
        MarketId indexed id, uint256 indexed roundId, address indexed account, bytes32 positionId, uint256 stake
    );

    /**
     * @dev Emitted when a user opens a bullish position on a market
     */
    event Bullish(
        MarketId indexed id, uint256 indexed roundId, address indexed account, bytes32 positionId, uint256 stake
    );

    /**
     * @dev Emitted when a user settles a position
     */
    event Settle(
        MarketId indexed id, uint256 indexed roundId, address indexed account, bytes32 positionId, uint256 reward
    );

    /**
     * @dev Emitted when a user claims refund refund from a cancelled round
     */
    event ClaimRefund(
        MarketId indexed id, uint256 indexed roundId, address indexed account, bytes32 positionId, uint256 stake
    );

    /// @notice Emitted when native/local tokens are recovered from the contract
    event RecoverToken(Currency indexed currency, address indexed recipient, uint256 amount);
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {MarketId} from "../types/MarketId.sol";

interface IGrailMarket {
    /**
     * @dev Allows anyone to resolve a prediction round
     *
     * @param id market identifier
     * @param roundId id of round to finalize
     * @param priceUpdate pyth price update data
     */
    function resolve(MarketId id, uint256 roundId, bytes calldata priceUpdate) external payable;

    /**
     * @dev Allows protocol managers to set incentive fee for market round resolvers
     *
     * @notice As a permissionless decentralized protocol, we have resorted to incentivize
     * market resolvers. Anyone who successfully resolves a round, is entitled
     * to earn a rebate percentage of accrued protocol fee in that round.
     *
     * @param fee the fee in BPS
     */
    function setResolverFee(uint16 fee) external;
}
          

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

/**
 * @title IERC20
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {MarketId} from "../types/MarketId.sol";
import {Position} from "./Position.sol";

library Market {
    /// @dev possible state of a round
    enum RoundStatus {
        NOT_OPEN,
        OPEN,
        LIVE,
        RESOLVED,
        REFUNDING
    }

    /**
     * @notice A structure defining a market uniquely
     */
    struct Config {
        /// the minimum amount that can be staked
        uint176 minStakeAmount;
        /// the duration of each market round in seconds
        uint48 duration;
        /// the incentive fee rewarded by this market for settling a round
        uint16 incentiveFeeBps;
        /// the protocol fee charged on this market
        uint16 protocolFeeBps;
    }

    /// @dev structure for market prediction round
    struct Round {
        /// unix timestamp of when market round opens
        uint64 openingTime;
        /// unix timestamp of when market round is due for finaliztion
        uint64 closingTime;
        /// asset closing price as obtained from the oracle
        int64 closingPrice;
        /// round locked price
        int64 priceMark;
        /// sum of all stakes in this round
        uint128 totalShares;
        /// sum of all bullish positions stakes
        uint128 bullShares;
        /// sum of all bearish positions stakes
        uint128 bearShares;
        /// total amount available for disbursment as reward
        uint128 rewardPool;
        /// total winning stakes
        uint128 winningShares;
        /// the status describing the round state
        RoundStatus status;
    }

    struct MarketInfo {
        /// keeps track of market last round id
        uint256 roundId;
        /// Pyth Network oracle price feed identifier
        bytes32 oracleId;
        /// keeps track of users positions in this market
        mapping(bytes32 positionId => Position.State) positions;
        /// keeps track of market rounds
        mapping(uint256 roundId => Round) rounds;
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

type Option is uint8;

library OptionLibrary {
    using OptionLibrary for Option;

    Option public constant BEARISH = Option.wrap(0);
    Option public constant BULLISH = Option.wrap(1);

    function isBearish(Option option) internal pure returns (bool) {
        return Option.unwrap(option) == Option.unwrap(BEARISH);
    }

    function isBullish(Option option) internal pure returns (bool) {
        return Option.unwrap(option) == Option.unwrap(BULLISH);
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {MarketId} from "../types/MarketId.sol";
import {Option, OptionLibrary} from "./Option.sol";

library Position {
    using OptionLibrary for Option;

    /**
     * @dev State represents a structure for users current
     * prediction
     */
    struct State {
        // The amount staked as wager for position
        uint240 stake;
        // The user's choice of either `Bearish` or `Bullish`
        Option option;
        // True if the option has been exercised or position reward claimed
        bool settled;
    }

    /**
     * @dev Returns true if a users position won otherwise false
     *
     * @param position The user position
     * @param closingPrice the market closing price
     * @param markPrice the prediction round mark price
     * @return rewardable true if position expired in the money
     */
    function isRewardable(State memory position, int64 closingPrice, int64 markPrice)
        internal
        pure
        returns (bool rewardable)
    {
        if (position.option.isBullish()) {
            rewardable = closingPrice > markPrice;
        } else {
            rewardable = closingPrice < markPrice;
        }
    }

    /**
     * @dev Abi encoded `marketId`, `sequenceId` and `owner`
     *
     * @param id unique market identifier
     * @param sequenceId incremented sequence Id
     * @param owner address of Postion taker
     *
     * @return positionId Unique id for the users position in round
     */
    function toId(MarketId id, uint256 sequenceId, address owner) internal pure returns (bytes32 positionId) {
        positionId = keccak256(abi.encodePacked(id, sequenceId, owner));
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

import {IERC20} from "../interfaces/external/IERC20.sol";

type Currency is address;

using {equals as ==} for Currency global;
using CurrencyLibrary for Currency global;

function equals(Currency currency, Currency other) pure returns (bool) {
    return Currency.unwrap(currency) == Currency.unwrap(other);
}

/**
 * @title CurrencyLibrary
 * @dev This library allows for transferring and holding native tokens and ERC20 tokens
 */
library CurrencyLibrary {
    /**
     * @notice Thrown when native transfer fails
     */
    error NativeTransferFailed();

    /// @notice Thrown when an ERC20 transfer fails
    error ERC20TransferFailed();

    /**
     * @notice Thrown when an ERC20 TrasnaferFrom fails
     */
    error ERC20TransferFromFailed();

    /// @notice A constant to represent the native currency
    Currency public constant ADDRESS_ZERO = Currency.wrap(address(0));

    function nativeTransfer(address to, uint256 amount) internal {
        bool success;

        assembly ("memory-safe") {
            // Transfer the ETH and revert if it fails.
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }
        // revert with NativeTransferFailed
        if (!success) revert NativeTransferFailed();
    }

    function tokenTransfer(Currency currency, address to, uint256 amount) internal {
        bool success;

        assembly ("memory-safe") {
            // Get a pointer to some free memory.
            let fmp := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(fmp, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
            mstore(add(fmp, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(fmp, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success :=
                and(
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                    // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                    // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                    // Counterintuitively, this call must be positioned second to the or() call in the
                    // surrounding and() call or else returndatasize() will be zero during the computation.
                    call(gas(), currency, 0, fmp, 68, 0, 32)
                )

            // Now clean the memory we used
            mstore(fmp, 0) // 4 byte `selector` and 28 bytes of `to` were stored here
            mstore(add(fmp, 0x20), 0) // 4 bytes of `to` and 28 bytes of `amount` were stored here
            mstore(add(fmp, 0x40), 0) // 4 bytes of `amount` were stored here
        }
        // revert with ERC20TransferFailed
        if (!success) revert ERC20TransferFailed();
    }

    function transfer(Currency currency, address to, uint256 amount) internal {
        // altered from https://github.com/transmissions11/solmate/blob/44a9963d4c78111f77caa0e65d677b8b46d6f2e6/src/utils/SafeTransferLib.sol
        // modified custom error selectors

        if (currency.isNative()) {
            nativeTransfer(to, amount);
        } else {
            tokenTransfer(currency, to, amount);
        }
    }

    function safeTransferFrom(Currency currency, address from, address to, uint256 amount) internal {
        bool success;
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.
            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
            success :=
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), currency, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }

        // revert with ERC20TransferFromFailed
        if (!success) revert ERC20TransferFromFailed();
    }

    function balanceOfSelf(Currency currency) internal view returns (uint256) {
        if (currency.isNative()) {
            return address(this).balance;
        } else {
            return IERC20(Currency.unwrap(currency)).balanceOf(address(this));
        }
    }

    function isNative(Currency currency) internal pure returns (bool) {
        return Currency.unwrap(currency) == Currency.unwrap(ADDRESS_ZERO);
    }
}
          

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.0;

type MarketId is bytes32;

function equals(MarketId id, MarketId otherId) pure returns (bool) {
    return MarketId.unwrap(id) == MarketId.unwrap(otherId);
}

function notEquals(MarketId id, MarketId otherId) pure returns (bool) {
    return MarketId.unwrap(id) == MarketId.unwrap(otherId);
}

using { equals as ==, notEquals as != } for MarketId global;