// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {Initializable} from "openzeppelin-contracts-upgradeable/proxy/utils/Initializable.sol";
import {ISellable} from "proof/sellers/interfaces/ISellable.sol";
import {
    AccessControlEnumerableUpgradeable,
    SteerableAccessControlEnumerableUpgradeable
} from "./SteerableAccessControlEnumerableUpgradeable.sol";

/**
 * @notice A base contract for selling content via authorised sellers.
 */
abstract contract BaseSellableUpgradeable is Initializable, ISellable, SteerableAccessControlEnumerableUpgradeable {
    /**
     * @notice Authorised sellers.
     */
    bytes32 public constant AUTHORISED_SELLER_ROLE = keccak256("AUTHORISED_SELLER_ROLE");

    function __BaseSellable_init() internal onlyInitializing {
        __AccessControlEnumerable_init();
        __BaseSellable_init_unchained();
    }

    function __BaseSellable_init_unchained() internal onlyInitializing {
        _setRoleAdmin(AUTHORISED_SELLER_ROLE, DEFAULT_STEERING_ROLE);
    }

    /**
     * @notice Handles the sale of sellable content via an authorised seller.
     * @dev Delegates the implementation to `_handleSale`.
     */
    function handleSale(address to, uint64 num, bytes calldata data)
        external
        payable
        onlyRole(AUTHORISED_SELLER_ROLE)
    {
        _handleSale(to, num, data);
    }

    /**
     * @notice Handles the sale of sellable content.
     */
    function _handleSale(address to, uint64 num, bytes calldata data) internal virtual;

    /**
     * @notice Revokes approval for all sellers.
     */
    function _revokeAllSellers() internal {
        uint256 num = getRoleMemberCount(AUTHORISED_SELLER_ROLE);
        for (uint256 i = 0; i < num; i++) {
            // Akin to a popFront
            address seller = getRoleMember(AUTHORISED_SELLER_ROLE, 0);
            _revokeRole(AUTHORISED_SELLER_ROLE, seller);
        }
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {BitMaps} from "openzeppelin-contracts/utils/structs/BitMaps.sol";
import {ERC4906} from "ethier/erc721/ERC4906.sol";

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

interface MythicEggActivatorEvents {
    /**
     * @notice Emitted when an egg has been activated.
     */
    event EggActivated(uint256 indexed tokenId);
}

/**
 * @title Mythics: Egg activation module
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
abstract contract MythicEggActivator is ERC4906, MythicsEggErrors, MythicEggActivatorEvents {
    using BitMaps for BitMaps.BitMap;

    /**
     * @notice Throws if activating an egg that has already been activated.
     */
    error EggAlreadyActivated(uint256);

    /**
     * @notice Thrown if one tries to activate too many eggs at once.
     */
    error ActivatingTooManyEggs(uint256 requested, uint256 numLeft);

    /**
     * @notice Keeps track of eggs that have already been activated.
     */
    BitMaps.BitMap private _activated;

    /**
     * @notice The maximum number of eggs that can be activated during one day.
     */
    uint32 internal _maxNumActivationsPerDay = 50;

    /**
     * @notice The last day on which an egg was activated.
     */
    uint32 private _lastActivationDay;

    /**
     * @notice The number of eggs that have been activated today.
     * @dev Will be reset to 0 in `_activate` at the start of each day.
     */
    uint32 private _numActivatedToday;

    /**
     * @notice Helper function to get the current day number.
     */
    function _currentDay() private view returns (uint32) {
        return uint32(block.timestamp / (1 days));
    }

    /**
     * @notice Sets the maximum number of activations per day.
     */
    function _setMaxNumActivationsPerDay(uint32 maxNumActivationsPerDay) internal {
        _maxNumActivationsPerDay = maxNumActivationsPerDay;
    }

    /**
     * @notice Activates an array of eggs.
     * @dev Will revert if the number of eggs to activate exceeds the maximum number of activations per day.
     */
    function _activate(uint256[] calldata tokenIds) internal {
        if (_currentDay() > _lastActivationDay) {
            _numActivatedToday = 0;
            _lastActivationDay = _currentDay();
        }

        uint256 numLeft = _maxNumActivationsPerDay - _numActivatedToday;
        if (tokenIds.length > numLeft) {
            revert ActivatingTooManyEggs(tokenIds.length, numLeft);
        }

        for (uint256 i; i < tokenIds.length; ++i) {
            uint256 tokenId = tokenIds[i];

            if (activated(tokenId)) {
                revert EggAlreadyActivated(tokenId);
            }

            if (!_exists(tokenId)) {
                revert NonexistentEgg(tokenId);
            }

            _activated.set(tokenId);
            _refreshMetadata(tokenId);
            emit EggActivated(tokenId);
        }
        _numActivatedToday += uint32(tokenIds.length);
    }

    /**
     * @notice Returns whether an egg has already been activated.
     */
    function activated(uint256 tokenId) public view returns (bool) {
        if (!_exists(tokenId)) {
            revert NonexistentEgg(tokenId);
        }

        return _activated.get(tokenId);
    }

    /**
     * @notice Returns whether a token exists.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool);
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {IEntropyOracle} from "proof/entropy/IEntropyOracle.sol";

import {MythicsEggErrors} from "./MythicsEggErrors.sol";
import {
    StochasticSampler, StochasticSamplerWithCDFStorage, StochasticSamplerWithOracle
} from "./StochasticSampling.sol";

/**
 * @title Mythics: Egg type sampling module
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
abstract contract MythicEggSampler is StochasticSamplerWithCDFStorage, StochasticSamplerWithOracle, MythicsEggErrors {
    /**
     * @notice The different types of eggs.
     */
    enum EggType {
        Stone,
        Runic,
        Legendary
    }

    /**
     * @notice Number of egg types
     */
    uint8 public constant NUM_EGG_TYPES = 3;

    /**
     * @notice Trait ID for the egg type
     */
    uint8 private constant _EGG_TYPE_TRAIT_ID = 0;

    /**
     * @notice Token-specific parameters for sampling the egg type
     * @dev Will be determined at mint.
     * @param revealBlockNumber Number of the block whose entropy will be used to reaveal the egg type.
     * @param distributionVersion The version/index of probability distribution to sample the egg type.
     * @param mixHash Part of the block mixHash to blind the entropy oracle.
     */
    struct SamplingParams {
        uint64 revealBlockNumber;
        uint16 distributionVersion;
        uint128 mixHash;
    }

    /**
     * @notice Egg-type sampling parameters keyed by token ID.
     */
    mapping(uint256 => SamplingParams) private _samplingParams;

    /**
     * @dev Constructor helper function.
     */
    function _numPerTrait() private pure returns (uint256[] memory) {
        uint256[] memory numPerTrait = new uint256[](1);
        numPerTrait[_EGG_TYPE_TRAIT_ID] = NUM_EGG_TYPES;
        return numPerTrait;
    }

    constructor(IEntropyOracle oracle)
        StochasticSamplerWithCDFStorage(_numPerTrait())
        StochasticSamplerWithOracle(oracle)
    {}

    /**
     * @notice Returns the egg-type sampling parameters for a given token ID.
     */
    function samplingParams(uint256 tokenId) public view returns (SamplingParams memory) {
        if (!_exists(tokenId)) {
            revert NonexistentEgg(tokenId);
        }

        return _samplingParams[tokenId];
    }

    /**
     * @inheritdoc StochasticSamplerWithCDFStorage
     * @dev Reads the token-specific parameters.
     */
    function _distributionVersion(uint256 tokenId, uint256 traitId) internal view virtual override returns (uint256) {
        assert(traitId == _EGG_TYPE_TRAIT_ID);
        return _samplingParams[tokenId].distributionVersion;
    }

    /**
     * @inheritdoc StochasticSamplerWithOracle
     * @dev Reads the token-specific parameters.
     */
    function _revealBlockNumber(uint256 tokenId) internal view virtual override returns (uint256) {
        return _samplingParams[tokenId].revealBlockNumber;
    }

    /**
     * @notice Registers a token for egg-type sampling using the currently set probability distribution.
     * @dev Must be called upon token mint.
     */
    function _registerForSampling(uint256 tokenId) internal {
        uint256 revealBlockNumber = block.number;

        _samplingParams[tokenId] = SamplingParams({
            revealBlockNumber: uint64(revealBlockNumber),
            distributionVersion: uint16(_latestDistributionVersion(_EGG_TYPE_TRAIT_ID)),
            // Smearing out single-bit-of-influence from the prevrandao since we're just using 128 bits (mainly to
            // prevent the forge fuzzer from finding breaking runs which would force us to add circular testing logic).
            mixHash: uint128(uint256(keccak256(abi.encode(block.prevrandao))))
        });
        entropyOracle.requestEntropy(revealBlockNumber);
    }

    /**
     * @notice Sets the probability distribution for egg types.
     */
    function _setEggProbabilities(uint64[NUM_EGG_TYPES] memory pdf) internal {
        uint64[] memory p = new uint64[](NUM_EGG_TYPES);
        for (uint256 i = 0; i < NUM_EGG_TYPES; i++) {
            p[i] = pdf[i];
        }
        _pushProbabilities(_EGG_TYPE_TRAIT_ID, p);
    }

    /**
     * @inheritdoc StochasticSamplerWithOracle
     * @dev Mixes the seed with the token-specific parameters to blind the EntropyOracle.
     */
    function _seed(uint256 tokenId)
        internal
        view
        virtual
        override(StochasticSampler, StochasticSamplerWithOracle)
        returns (bytes32, bool)
    {
        (bytes32 seed, bool revealed) = StochasticSamplerWithOracle._seed(tokenId);
        return (keccak256(abi.encode(seed, samplingParams(tokenId))), revealed);
    }

    /**
     * @notice Returns the egg type of a given token ID and a boolean flag to indicate whether it was already revealed.
     */
    function eggType(uint256 tokenId) public view returns (EggType, bool) {
        (uint256 sample, bool revealed) = _sampleTrait(tokenId, _EGG_TYPE_TRAIT_ID);
        return (EggType(sample), revealed);
    }

    /**
     * @notice Returns whether a token exists.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool);
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {Initializable} from "openzeppelin-contracts-upgradeable/proxy/utils/Initializable.sol";
import {UUPSUpgradeable} from "openzeppelin-contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {ERC721Upgradeable} from "openzeppelin-contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import {ERC721RoyaltyUpgradeable} from
    "openzeppelin-contracts-upgradeable/token/ERC721/extensions/ERC721RoyaltyUpgradeable.sol";
import {ERC721PausableUpgradeable} from
    "openzeppelin-contracts-upgradeable/token/ERC721/extensions/ERC721PausableUpgradeable.sol";

import {
    SteerableAccessControlEnumerableUpgradeable,
    AccessControlEnumerableUpgradeable
} from "./SteerableAccessControlEnumerableUpgradeable.sol";

/**
 * @notice Base contract for Mythics implementations.
 * @dev This contract is intended be inherited by all implementations and thus MUST NOT be changed.
 */
contract MythicsBase is
    Initializable,
    SteerableAccessControlEnumerableUpgradeable,
    ERC721Upgradeable,
    ERC721RoyaltyUpgradeable,
    ERC721PausableUpgradeable,
    UUPSUpgradeable
{
    constructor() {
        _disableInitializers();
    }

    function __MythicsBase_init() internal onlyInitializing {
        __AccessControlEnumerable_init();
        __ERC721_init("Moonbirds: Mythics", "MYTHICS");
        __ERC721Royalty_init();
        __ERC721Pausable_init();
        __UUPSUpgradeable_init();
    }

    function __MythicsBase_init_unchained() internal onlyInitializing {}

    /**
     * @notice Only the admin is authorised to upgrade the implementation.
     */
    function _authorizeUpgrade(address newImplementation) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}

    /**
     * @dev Needed for inheritance resolution.
     */
    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
        internal
        virtual
        override(ERC721Upgradeable, ERC721PausableUpgradeable)
    {
        ERC721PausableUpgradeable._beforeTokenTransfer(from, to, firstTokenId, batchSize);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721Upgradeable, AccessControlEnumerableUpgradeable, ERC721RoyaltyUpgradeable)
        returns (bool)
    {
        return ERC721Upgradeable.supportsInterface(interfaceId)
            || ERC721RoyaltyUpgradeable.supportsInterface(interfaceId)
            || AccessControlEnumerableUpgradeable.supportsInterface(interfaceId);
    }

    function _burn(uint256 tokenId) internal virtual override(ERC721Upgradeable, ERC721RoyaltyUpgradeable) {
        ERC721RoyaltyUpgradeable._burn(tokenId);
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {ERC721A, ERC721ACommon, BaseTokenURI, ERC721ACommonBaseTokenURI} from "ethier/erc721/BaseTokenURI.sol";
import {OperatorFilterOS} from "ethier/erc721/OperatorFilterOS.sol";
import {ERC4906} from "ethier/erc721/ERC4906.sol";

import {IEntropyOracle} from "proof/entropy/IEntropyOracle.sol";
import {RedeemableERC721ACommon} from "proof/redemption/voucher/RedeemableERC721ACommon.sol";
import {SellableERC721ACommon} from "proof/sellers/sellable/SellableERC721ACommon.sol";

import {MythicEggSampler} from "./MythicEggSampler.sol";
import {MythicEggActivator} from "./MythicEggActivator.sol";

/**
 * @title Mythics: Egg
 * @notice A redeemable token claimable by all diamond nested Moonbirds.
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
contract MythicsEgg is
    ERC721ACommonBaseTokenURI,
    OperatorFilterOS,
    SellableERC721ACommon,
    RedeemableERC721ACommon,
    MythicEggSampler,
    MythicEggActivator
{
    constructor(address admin, address steerer, address payable secondaryReceiver, IEntropyOracle oracle)
        ERC721ACommon(admin, steerer, "Mythics: Egg", "EGG", secondaryReceiver, 500)
        BaseTokenURI("https://metadata.proof.xyz/mythics/egg/")
        MythicEggSampler(oracle)
    {
        _setEggProbabilities([uint64(0), uint64(40), uint64(60)]);
    }

    // =================================================================================================================
    //                          Information Getter
    // =================================================================================================================

    /**
     * @notice Encodes information about a token.
     * @dev Intended to be used off-chain.
     */
    struct TokenInfo {
        bool revealed;
        EggType eggType;
        bool activated;
    }

    /**
     * @notice Returns information about given egg token.
     * @dev Not optimised, intended to be used off-chain only.
     */
    function tokenInfos(uint256[] calldata tokenIds) external view returns (TokenInfo[] memory) {
        TokenInfo[] memory infos = new TokenInfo[](tokenIds.length);
        for (uint256 i = 0; i < tokenIds.length; i++) {
            (EggType eggT, bool revealed) = eggType(tokenIds[i]);
            infos[i] = TokenInfo({revealed: revealed, eggType: eggT, activated: activated(tokenIds[i])});
        }
        return infos;
    }

    // =================================================================================================================
    //                          Steering
    // =================================================================================================================

    /**
     * @notice Sets the probability distribution for egg types.
     */
    function setEggProbabilities(uint64[NUM_EGG_TYPES] memory pdf) external onlyRole(DEFAULT_STEERING_ROLE) {
        _setEggProbabilities(pdf);
    }

    /**
     * @notice Sets the entropy oracle.
     */
    function setEntropyOracle(IEntropyOracle newOracle) external onlyRole(DEFAULT_STEERING_ROLE) {
        entropyOracle = newOracle;
    }

    /**
     * @notice Sets the maximum number of activations per day.
     */
    function setMaxNumActivationsPerDay(uint32 maxNumActivationsPerDay) external onlyRole(DEFAULT_STEERING_ROLE) {
        _setMaxNumActivationsPerDay(maxNumActivationsPerDay);
    }

    /**
     * @notice Activates an array of eggs.
     */
    function activate(uint256[] calldata tokenIds) external onlyRole(DEFAULT_STEERING_ROLE) {
        _activate(tokenIds);
    }

    // =================================================================================================================
    //                          Inheritance Resolution
    // =================================================================================================================

    /**
     * @inheritdoc SellableERC721ACommon
     * @dev Registers the minted tokens for sampling.
     */
    function _handleSale(address to, uint64 num, bytes calldata data) internal virtual override {
        uint256 startTokenId = _nextTokenId();
        for (uint256 i; i < num; ++i) {
            _registerForSampling(startTokenId + i);
        }

        super._handleSale(to, num, data);
    }

    function _exists(uint256 tokenId)
        internal
        view
        virtual
        override(ERC721A, MythicEggActivator, MythicEggSampler)
        returns (bool)
    {
        return ERC721A._exists(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721ACommon, ERC721ACommonBaseTokenURI, SellableERC721ACommon, RedeemableERC721ACommon, ERC4906)
        returns (bool)
    {
        return RedeemableERC721ACommon.supportsInterface(interfaceId)
            || SellableERC721ACommon.supportsInterface(interfaceId) || ERC4906.supportsInterface(interfaceId)
            || ERC721ACommonBaseTokenURI.supportsInterface(interfaceId);
    }

    function _baseURI() internal view virtual override(ERC721A, ERC721ACommonBaseTokenURI) returns (string memory) {
        return ERC721ACommonBaseTokenURI._baseURI();
    }

    function setApprovalForAll(address operator, bool approved) public virtual override(ERC721A, OperatorFilterOS) {
        OperatorFilterOS.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId) public payable virtual override(ERC721A, OperatorFilterOS) {
        OperatorFilterOS.approve(operator, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId)
        public
        payable
        virtual
        override(ERC721A, OperatorFilterOS)
    {
        OperatorFilterOS.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId)
        public
        payable
        virtual
        override(ERC721A, OperatorFilterOS)
    {
        OperatorFilterOS.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        payable
        virtual
        override(ERC721A, OperatorFilterOS)
    {
        OperatorFilterOS.safeTransferFrom(from, to, tokenId, data);
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

interface MythicsEggErrors {
    /**
     * @notice Thrown if one attempts an action on a nonexistent egg.
     */
    error NonexistentEgg(uint256 tokenId);
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity >=0.8.0 <0.9.0;

import {IRedeemableToken} from "proof/redemption/interfaces/IRedeemableToken.sol";
import {MythicsV1} from "./MythicsV1.sol";
import {MythicsEgg, MythicEggSampler} from "../Egg/MythicsEgg.sol";

import {ISellable, ImmutableSellableCallbacker, SellableCallbacker} from "proof/sellers/base/SellableCallbacker.sol";
import {Seller} from "proof/sellers/base/Seller.sol";
import {RedeemableTokenRedeemer} from "proof/redemption/RedeemableTokenRedeemer.sol";

/**
 * @notice Helper library to encode/decode the purchase payload sent to the Mythics seller interface.
 */
library MythicsEggRedemptionLib {
    struct PurchasePayload {
        uint256 eggId;
        MythicEggSampler.EggType eggType;
    }

    function encode(PurchasePayload[] memory redemptions) internal pure returns (bytes memory) {
        return abi.encode(redemptions);
    }

    function decode(bytes memory data) internal pure returns (PurchasePayload[] memory) {
        return abi.decode(data, (PurchasePayload[]));
    }
}

/**
 * @title Mythics: Egg redeemer
 * @notice Redeems activated mythic eggs for a Mythic (either a token in the case of a stone egg or an open choice for
 * non-stone eggs).
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
contract MythicsEggRedeemer is Seller, ImmutableSellableCallbacker, RedeemableTokenRedeemer {
    using MythicsEggRedemptionLib for MythicsEggRedemptionLib.PurchasePayload[];

    error EggNotActivated(uint256 eggId);
    error EggNotRevealed(uint256 eggId);

    MythicsEgg public immutable eggs;

    constructor(ISellable mythics, MythicsEgg eggs_) ImmutableSellableCallbacker(mythics) {
        eggs = eggs_;
    }

    /**
     * @notice Redeems the given passes and purchases pieces in the Diamond Exhibition.
     */
    function redeem(uint256[] calldata eggIds) external {
        MythicsEggRedemptionLib.PurchasePayload[] memory payloads =
            new MythicsEggRedemptionLib.PurchasePayload[](eggIds.length);

        for (uint256 i = 0; i < eggIds.length; ++i) {
            if (!eggs.activated(eggIds[i])) {
                revert EggNotActivated(eggIds[i]);
            }

            (MythicEggSampler.EggType eggType, bool revealed) = eggs.eggType(eggIds[i]);
            if (!revealed) {
                revert EggNotRevealed(eggIds[i]);
            }

            _redeem(eggs, eggIds[i]);
            payloads[i] = MythicsEggRedemptionLib.PurchasePayload({eggId: eggIds[i], eggType: eggType});
        }

        _purchase(msg.sender, uint64(eggIds.length), /* total cost */ 0, payloads.encode());
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {DefaultOperatorFiltererUpgradeable} from
    "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import {MythicsBase} from "./MythicsBase.sol";
import {
    BaseSellableUpgradeable,
    AccessControlEnumerableUpgradeable,
    SteerableAccessControlEnumerableUpgradeable
} from "./BaseSellableUpgradeable.sol";

import {Oddsoleum} from "../Oddsoleum/Oddsoleum.sol";
import {MythicsEggRedeemer, MythicsEggRedemptionLib} from "./MythicsEggRedeemer.sol";
import {MythicEggSampler} from "../Egg/MythicEggSampler.sol";

library MythicsStorage {
    /**
     * @notice Encodes an open choice that the stored user can submit for a given purchase ID.
     * @dev A zero-address as `chooser` indicates that this choice is no longer available.
     * @param chooser the address of the user that is eligible to submit the choice.
     * @param numChoices the number of choices.
     */
    struct OpenChoice {
        address chooser;
        uint8 numChoices;
    }

    /**
     * @notice Encodes a final choice for a given mythics token ID.
     * @param numChoicesMinusOne the number of choices minus one (optimisation).
     * @param choice the choice submitted by the user
     */
    struct FinalChoice {
        uint8 numChoicesMinusOne;
        uint8 choice;
    }

    bytes32 internal constant STORAGE_SLOT = keccak256("Mythics.storage.location");

    /**
     * @notice This is the storage layout for the Mythics contract.
     * @dev The fields in this struct MUST NOT be removed, renamed, or reordered. Only additionas are allowed to keep
     * the storage layout compatible between upgrades.
     */
    struct Layout {
        /**
         * @notice The number of tokens that have been minted.
         */
        uint256 numMinted;
        /**
         * @notice The base URI for the token metadata.
         */
        string baseTokenURI;
        /**
         * @notice The number of purchases handled by the seller interface.
         * @dev Counter to get sequential purchaseIDs
         */
        uint64 numPurchases;
        /**
         * @notice The MythicsEggRedeemer contract.
         */
        MythicsEggRedeemer eggRedeemer;
        /**
         * @notice Open choices added on purchase.
         * @dev Elements MUST be deleted after locking in a choice.
         */
        mapping(uint256 purchaseId => OpenChoice) openChoices;
        /**
         * @notice Locked-in choices for the given tokenId.
         * @dev Elements MUST and MUST ONLY be added for minted tokens.
         */
        mapping(uint256 tokenId => FinalChoice) finalChoices;
    }

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

interface MythicsV1Events {
    /**
     * @notice Emitted when a Mythic is purchased (not minted) to draw random choices for the buyer off-chain.
     */
    event RandomiseMythics(uint256 indexed purchaseId, address indexed chooser, uint8 indexed numChoices);

    /**
     * @notice Emitted when the Mythics choice was locked in for a given purchase (and the Mythic was minted).
     */
    event MythicChosen(uint256 indexed purchaseId, address indexed chooser, uint256 indexed tokenId, uint8 choice);
}

/**
 * @title Mythics V1
 * @notice Mythics V1 allowing tokens to be purchased by redeeming MythicEgss through the MythicsEggRedeemer or by
 * burning Oddities through the Oddsoleum.
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
contract MythicsV1 is MythicsBase, BaseSellableUpgradeable, DefaultOperatorFiltererUpgradeable, MythicsV1Events {
    /**
     * @notice Thrown if a user attempt to lock in a choice that exceeds the number of available choices.
     */
    error ChoiceOutOfBounds(uint256 purchaseId, uint8 numChoices, uint8 choice);

    /**
     * @notice Thrown if a user attempts to submit a choice for a purchase that was already locked in.
     */
    error PurchaseChoiceAlreadyLockedIn(uint256 purchaseId);

    /**
     * @notice Thrown if the caller attempts to lock in an open choice they are not eligible for.
     */
    error CallerIsNotChooser(uint256 purchaseId, address chooser, address caller);

    struct InitArgsV1 {
        address mainAdmin;
        address secondaryAdmin;
        address steerer;
        string baseTokenURI;
        MythicsEggRedeemer eggRedeemer;
        address royaltyReceiver;
    }

    function initializeV1(InitArgsV1 memory init) public virtual reinitializer(2) {
        __MythicsBase_init();
        __BaseSellable_init();
        __DefaultOperatorFilterer_init();

        _grantRole(DEFAULT_ADMIN_ROLE, init.mainAdmin);
        _grantRole(DEFAULT_ADMIN_ROLE, init.secondaryAdmin);
        _changeAdmin(init.mainAdmin);
        _grantRole(DEFAULT_STEERING_ROLE, init.steerer);

        MythicsStorage.layout().baseTokenURI = init.baseTokenURI;
        MythicsStorage.layout().eggRedeemer = init.eggRedeemer;

        _setDefaultRoyalty(init.royaltyReceiver, 500);
    }

    /**
     * @notice Pauses all ERC721 transfers.
     * @dev This includes mints and hence also purchases throught the Seller interface.
     */
    function pause() public virtual onlyRole(DEFAULT_STEERING_ROLE) {
        _pause();
    }

    /**
     * @notice Unpauses paused ERC721 transfers.
     */
    function unpause() public virtual onlyRole(DEFAULT_STEERING_ROLE) {
        _unpause();
    }

    /**
     * @notice Loads and returns the base URI for the token metadata according to the v1 storage layout.
     */
    function _baseURI() internal view virtual override returns (string memory) {
        return MythicsStorage.layout().baseTokenURI;
    }

    /**
     * @notice Sets the base tokenURI.
     */
    function setBaseTokenURI(string calldata newBaseTokenURI) public virtual onlyRole(DEFAULT_STEERING_ROLE) {
        MythicsStorage.layout().baseTokenURI = newBaseTokenURI;
    }

    /**
     * @notice Returns the total supply of Mythics.
     */
    function totalSupply() public view virtual returns (uint256) {
        return MythicsStorage.layout().numMinted;
    }

    /**
     * @notice Overriding the OZ's minting hook to increment the numMinted counter.
     * @dev Must not be called directly as this would mess with sequential token IDs. Use _mintNextTokenId instead.
     */
    function _mint(address to, uint256 tokenId) internal virtual override {
        unchecked {
            // Impossible to overflow in practice, the amount of gas required to mint more than 2**256 is prohibitive.
            MythicsStorage.layout().numMinted++;
        }
        super._mint(to, tokenId);
    }

    /**
     * @notice Convenience function to mint the next tokenId.
     */
    function _mintNextTokenId(address to) internal virtual returns (uint256) {
        uint256 tokenId = MythicsStorage.layout().numMinted;
        _mint(to, tokenId);
        return tokenId;
    }

    /**
     * @notice Tracks purchases and emits an event to randomise mythic choices off-chain.
     */
    function _trackPurchaseAndRandomiseMythics(address chooser, uint8 numChoices) internal returns (uint256) {
        assert(numChoices > 0);
        MythicsStorage.Layout storage layout = MythicsStorage.layout();
        uint256 purchaseId = layout.numPurchases++;

        // Optimisation: Not tracking the purchase in `openChoices` for `numChoices == 1` since there is only one choice
        // and we will lock it in immediately after this call in `_setChoice` deleting the entry again.
        if (numChoices > 1) {
            layout.openChoices[purchaseId] = MythicsStorage.OpenChoice({chooser: chooser, numChoices: numChoices});
        }
        emit RandomiseMythics(purchaseId, chooser, numChoices);

        return purchaseId;
    }

    /**
     * @notice Locks in a choice for a given purchase and mythic token ID.
     */
    function _setChoice(address chooser, uint256 purchaseId, uint256 tokenId, uint8 numChoices, uint8 choice)
        internal
    {
        assert(numChoices > 0);
        MythicsStorage.Layout storage layout = MythicsStorage.layout();

        if (choice >= numChoices) {
            revert ChoiceOutOfBounds(purchaseId, numChoices, choice);
        }

        if (numChoices > 1) {
            // Optimisation: Not deleting `openChoices` for `numChoices == 1` since we did not store anything in that
            // case. See also `_trackPurchaseAndRandomiseMythics`.
            delete layout.openChoices[purchaseId];
        }

        layout.finalChoices[tokenId] = MythicsStorage.FinalChoice({numChoicesMinusOne: numChoices - 1, choice: choice});
        emit MythicChosen(purchaseId, chooser, tokenId, choice);
    }

    /**
     * @notice Convenience wrapper functions for purchases without choices, i.e. `numChoices = 1`, e.g. used for
     * Oddities and stone eggs.
     */
    function _mintWithoutChoice(address to) internal {
        uint8 numChoices = 1;
        uint256 purchaseId = _trackPurchaseAndRandomiseMythics(to, numChoices);
        uint256 tokenId = _mintNextTokenId(to);
        _setChoice(to, purchaseId, tokenId, numChoices, 0);
    }

    /**
     * @notice Encode as choice submission.
     * @param purchaseId the purchase ID the choice should be submitted for
     * @param choice the chosen Mythic for the given purchase ID
     */
    struct ChoiceSubmission {
        uint256 purchaseId;
        uint8 choice;
    }

    /**
     * @notice Locks in the choice for a given purchase with an open choice and mints the Mythics token.
     * @dev Reverts if the caller is not the stored chooser or if a choice was already submitted for the given purchase.
     */
    function _chooseAndMint(ChoiceSubmission calldata submission) internal {
        MythicsStorage.Layout storage layout = MythicsStorage.layout();
        MythicsStorage.OpenChoice memory openChoice = layout.openChoices[submission.purchaseId];

        if (openChoice.chooser == address(0)) {
            revert PurchaseChoiceAlreadyLockedIn(submission.purchaseId);
        }

        if (msg.sender != openChoice.chooser) {
            revert CallerIsNotChooser(submission.purchaseId, openChoice.chooser, msg.sender);
        }

        uint8 numChoices = openChoice.numChoices;
        uint256 tokenId = _mintNextTokenId(msg.sender);
        _setChoice(msg.sender, submission.purchaseId, tokenId, numChoices, submission.choice);
    }

    /**
     * @notice Locks in choices for given purchases and mints the Mythics tokens.
     */
    function chooseAndMint(ChoiceSubmission[] calldata choices) public whenNotPaused {
        for (uint256 i; i < choices.length; ++i) {
            _chooseAndMint(choices[i]);
        }
    }

    /**
     * @inheritdoc BaseSellableUpgradeable
     * @dev Mints Mythics tokens for standard sales (e.g. through the Oddsoleum) or stone egg redemptions or records
     * open choices for non-stone eggs.
     */
    function _handleSale(address to, uint64 num, bytes calldata data) internal virtual override whenNotPaused {
        if (msg.sender != address(MythicsStorage.layout().eggRedeemer)) {
            for (uint256 i; i < num; ++i) {
                _mintWithoutChoice(to);
            }
            return;
        }

        MythicsEggRedemptionLib.PurchasePayload[] memory payloads = MythicsEggRedemptionLib.decode(data);
        assert(num == payloads.length);

        for (uint256 i; i < num; ++i) {
            MythicEggSampler.EggType eggType = payloads[i].eggType;

            if (eggType == MythicEggSampler.EggType.Stone) {
                _mintWithoutChoice(to);
                continue;
            }

            assert(uint8(eggType) <= 2);
            uint8 numChoices = uint8(eggType) + 1;
            _trackPurchaseAndRandomiseMythics(to, numChoices);
        }
    }

    /**
     * @notice Sets the egg redeemer contract.
     */
    function setEggRedeemer(MythicsEggRedeemer newRedeemer) public onlyRole(DEFAULT_STEERING_ROLE) {
        MythicsStorage.layout().eggRedeemer = newRedeemer;
    }

    /**
     * @notice Returns the egg redeemer contract.
     */
    function eggRedeemer() public view returns (MythicsEggRedeemer) {
        return MythicsStorage.layout().eggRedeemer;
    }

    /**
     * @notice Sets the default royalty receiver and fee in basis points.
     */
    function setDefaultRoyalty(address receiver, uint96 feeBasisPoints)
        public
        virtual
        onlyRole(DEFAULT_STEERING_ROLE)
    {
        _setDefaultRoyalty(receiver, feeBasisPoints);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(MythicsBase, AccessControlEnumerableUpgradeable)
        returns (bool)
    {
        return MythicsBase.supportsInterface(interfaceId);
    }

    // =========================================================================
    //                           Operator filtering
    // =========================================================================

    /**
     * @dev See {IERC721-setApprovalForAll}.
     *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
     */
    function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    /**
     * @dev See {IERC721-approve}.
     *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
     */
    function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

    /**
     * @dev See {IERC721-transferFrom}.
     *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
     */
    function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override
        onlyAllowedOperator(from)
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

/**
 * @notice Module to rate limit a certain action per discrete block of time.
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
contract NonRollingRateLimited {
    /**
     * @notice Thrown if on attempts to exceed the rate limit.
     */
    error ExceedingRateLimit(uint256 requested, uint256 numLeft);

    /**
     * @notice The duration of a period in seconds.
     */
    uint64 private immutable _periodLength;

    /**
     * @notice The index of the last period for which an action has been performed.
     */
    uint64 private _lastPeriod;

    /**
     * @notice The maximum number of actions that can be performed in a period.
     */
    uint64 private __maxActionsPerPeriod;

    /**
     * @notice The number of actions that have been performed in the current period.
     * @dev Will automatically be reset to 0 in `rateLimited` at the start of each period.
     */
    uint64 private __performedCurrentPeriod;

    constructor(uint64 maxActionsPerPeriod, uint64 periodLength) {
        _periodLength = periodLength;
        _setMaxActionsPerPeriod(maxActionsPerPeriod);
    }

    /**
     * @notice Helper function to get the index of the current period.
     */
    function _currentPeriod() private view returns (uint64) {
        return uint64(block.timestamp / _periodLength);
    }

    /**
     * @notice Sets the maximum number of actions per period.
     */
    function _setMaxActionsPerPeriod(uint64 maxActionsPerPeriod) internal {
        __maxActionsPerPeriod = maxActionsPerPeriod;
    }

    /**
     * @notice Returns the maximum number of actions per period.
     */
    function _maxActionsPerPeriod() internal view returns (uint64) {
        return __maxActionsPerPeriod;
    }

    /**
     * @notice Keeps track of the number of performed actions.
     * @dev Reverts if the maximum number of actions per period is exceeded.
     */
    function _checkAndTrackRateLimit(uint64 requested) internal {
        uint64 performed = _performedCurrentPeriod();
        uint64 left = __maxActionsPerPeriod - performed;
        if (requested > left) {
            revert ExceedingRateLimit(requested, left);
        }
        __performedCurrentPeriod = performed + requested;
        _lastPeriod = _currentPeriod();
    }

    /**
     * @notice The number of actions performed in the current period.
     */
    function _performedCurrentPeriod() internal view returns (uint64) {
        if (_currentPeriod() > _lastPeriod) {
            return 0;
        }
        return __performedCurrentPeriod;
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {SettableCallbackerWithAccessControl} from "proof/sellers/presets/CallbackerWithAccessControl.sol";
import {Seller} from "proof/sellers/base/Seller.sol";

import {MythicEggSampler} from "../Egg/MythicEggSampler.sol";
import {NonRollingRateLimited} from "./NonRollingRateLimited.sol";

interface OddsoleumEvents {
    event OdditySacrificed(address indexed owner, uint256 tokenId);

    /**
     * @notice Emitted if a burner attempts to sacrifice an Oddity that is not in the queue or was not approved to be
     * transferred by the Oddsoleum contract.
     * @dev This will likely only happen in the case of a race condition, where Oddity nomination is revoked after
     * selecting it to be burned.
     */
    event CannotBurnIneligibleOddity(uint256 indexed tokenId, bool queued, bool approved);
}

/**
 * @title Oddsoleum
 * @notice Allows Oddities to enter a queue for being sacrificed on the altar of the Oddgod.
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
contract Oddsoleum is Seller, SettableCallbackerWithAccessControl, OddsoleumEvents, NonRollingRateLimited {
    /**
     * @notice The role allowed to burn oddities.
     */
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");

    /**
     * @notice The receiver of burned Oddities.
     * @dev The original Oddities contract does not allow burning, so we send the tokens to the dead address instead.
     */
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    /**
     * @notice The Oddities contract.
     */
    IERC721 public immutable oddities;

    /**
     * @notice Keeps track of Oddities that are in the queue to be sacrificed.
     * @dev Keyed by owner to automatically unqueue Oddities if they are transferred. Consequently, tokens will still
     * be queued after a round-trip, which can't be avoided as it would require a callback from the Oddities contract
     * upon transfer.
     */
    mapping(address owner => mapping(uint256 tokenId => bool)) private _queued;

    constructor(address admin, address steerer, IERC721 oddities_)
        SettableCallbackerWithAccessControl(admin, steerer)
        NonRollingRateLimited(50, 1 days)
    {
        _setRoleAdmin(BURNER_ROLE, DEFAULT_STEERING_ROLE);
        oddities = oddities_;
    }

    /**
     * @notice Adds the given Oddities to the senders queue.
     * @dev Oddity ownership is not relevant here as senders only have access to their own flag set. Upon burn, the
     * contract will only consider the flag of the current owner of the given Oddity.
     */
    function addToQueue(uint256[] calldata tokenIds) external {
        for (uint256 i = 0; i < tokenIds.length; ++i) {
            _queued[msg.sender][tokenIds[i]] = true;
        }
    }

    /**
     * @notice Removes the given Oddities from the senders queue.
     * @dev Oddity ownership is not relevant here as senders only have access to their own flag set. Upon burn, the
     * contract will only consider the flag of the current owner of the given Oddity.
     */
    function removeFromQueue(uint256[] calldata tokenIds) external {
        for (uint256 i = 0; i < tokenIds.length; ++i) {
            _queued[msg.sender][tokenIds[i]] = false;
        }
    }

    /**
     * @notice Returns whether the given Oddities are in the queue.
     * @dev This does not imply that they can be sacrificed, as the owner may not have approved this contract to burn
     * them.
     */
    function queued(uint256[] calldata tokenIds) public view returns (bool[] memory) {
        bool[] memory queued_ = new bool[](tokenIds.length);
        for (uint256 i = 0; i < tokenIds.length; ++i) {
            address owner = oddities.ownerOf(tokenIds[i]);
            queued_[i] = _queued[owner][tokenIds[i]];
        }
        return queued_;
    }

    /**
     * @notice Returns whether the given Oddities can be sacrificed.
     * @dev True iff the Oddity is in the queue and the owner has approved this contract to burn it.
     */
    function burnable(uint256[] calldata tokenIds) external view returns (bool[] memory) {
        bool[] memory burnable_ = new bool[](tokenIds.length);
        for (uint256 i = 0; i < tokenIds.length; ++i) {
            address owner = oddities.ownerOf(tokenIds[i]);
            burnable_[i] = _burnable(owner, tokenIds[i]);
        }
        return burnable_;
    }

    /**
     * @notice Returns whether the given Oddities can be sacrificed.
     */
    function _burnable(address owner, uint256 tokenId) internal view returns (bool) {
        return _queued[owner][tokenId] && _approved(owner, tokenId);
    }

    /**
     * @notice Returns whether the given Oddities can be sacrificed.
     */
    function _approved(address owner, uint256 tokenId) internal view returns (bool) {
        return (oddities.isApprovedForAll(owner, address(this)) || oddities.getApproved(tokenId) == address(this));
    }

    /**
     * @notice Burns the given Oddity by sending it to a burn address.
     */
    function _burn(address owner, uint256 tokenId) internal returns (bool) {
        bool queued_ = _queued[owner][tokenId];
        bool approved = _approved(owner, tokenId);

        if (!(queued_ && approved)) {
            emit CannotBurnIneligibleOddity(tokenId, queued_, approved);
            return false;
        }

        oddities.transferFrom(owner, BURN_ADDRESS, tokenId);
        emit OdditySacrificed(owner, tokenId);
        return true;
    }

    /**
     * @notice Sacrifices the given Oddity by burning it and awards a Mythic to the original owner in return.
     */
    function _sacrifice(uint256 tokenId) internal returns (bool) {
        address owner = oddities.ownerOf(tokenId);
        bool burned = _burn(owner, tokenId);
        if (!burned) {
            return false;
        }
        _purchase(owner, 1, /* total cost */ 0, "");
        return true;
    }

    /**
     * @notice Sacrifices the given Oddities by burning them and awards Mythics to the original owners in return.
     */
    function sacrifice(uint256[] calldata tokenIds) external onlyRole(BURNER_ROLE) {
        uint64 numSacrificed;
        for (uint256 i = 0; i < tokenIds.length; ++i) {
            bool sacrificed = _sacrifice(tokenIds[i]);

            unchecked {
                if (sacrificed) {
                    ++numSacrificed;
                }
            }
        }
        _checkAndTrackRateLimit(numSacrificed);
    }

    /**
     * @notice Sets the maximum number of activations per day.
     */
    function setMaxSacrificesPerPeriod(uint32 maxSacrificesPerPeriod) external onlyRole(DEFAULT_STEERING_ROLE) {
        _setMaxActionsPerPeriod(maxSacrificesPerPeriod);
    }
}

// SPDX-License-Identifier: MIT
// Copyright (c) 2023 the ethier authors (github.com/divergencetech/ethier)
pragma solidity >=0.8.0 <0.9.0;

import {AccessControlEnumerableUpgradeable} from
    "openzeppelin-contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";

contract SteerableAccessControlEnumerableUpgradeable is AccessControlEnumerableUpgradeable {
    /// @notice The default role intended to perform access-restricted actions.
    /// @dev We are using this instead of DEFAULT_ADMIN_ROLE because the latter
    /// is intended to grant/revoke roles and will be secured differently.
    bytes32 public constant DEFAULT_STEERING_ROLE = keccak256("DEFAULT_STEERING_ROLE");
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {IEntropyOracle} from "proof/entropy/IEntropyOracle.sol";

/**
 * @notice Helper libray for sampling from a discrete probability distribution.
 */
library StochasticSamplingLib {
    /**
     * @notice Computes the cumulative probability distribution from a discrete probability distribution.
     */
    function computeCDF(uint64[] memory pdf) internal pure returns (uint64[] memory) {
        uint64[] memory cdf = new uint64[](pdf.length);
        cdf[0] = pdf[0];
        for (uint256 i = 1; i < pdf.length; ++i) {
            cdf[i] = cdf[i - 1] + pdf[i];
        }

        return cdf;
    }

    /**
     * @notice Samples from a discrete cumulative probability distribution.
     * @dev This function assumes that rand is uniform in [0,2^256) and that `cdf[cdf.length - 1] << 2^256`. If not the
     * outcome will be biased
     */
    function sampleWithCDF(uint256 rand, uint64[] memory cdf) internal pure returns (uint256) {
        rand = rand % cdf[cdf.length - 1];

        for (uint256 i; i < cdf.length; ++i) {
            if (rand < cdf[i]) {
                return i;
            }
        }

        // This will never be reached given the above bounds of rand.
        assert(false);
        return 0;
    }
}

/**
 * @notice A contract that can sample token traits from discrete probability distributions.
 * @dev The probability distributions and seed derivation functions are implemented in the inheriting contracts.
 * @dev The functions defined here might be gas-heavy and are therefore intended to be used in view-calls only.
 */
abstract contract StochasticSampler {
    /**
     * @notice Returns a random seed for a given token and a boolean indicating whether the seed is available.
     */
    function _seed(uint256 tokenId) internal view virtual returns (bytes32, bool);

    /**
     * @notice Returns the cumulative probability distribution for a given trait of a given token.
     */
    function _cdf(uint256 tokenId, uint256 traitId) internal view virtual returns (uint64[] memory);

    /**
     * @notice Samples a trait for a given token.
     * @dev Returns the sampled trait and a boolean indicating whether the trait was already revealed (i.e. if the seed
     * for the given token is available).
     */
    function _sampleTrait(uint256 tokenId, uint256 traitId) internal view returns (uint256, bool) {
        (bytes32 seed, bool revealed) = _seed(tokenId);
        seed = keccak256(abi.encodePacked(seed, traitId));
        return (StochasticSamplingLib.sampleWithCDF(uint256(seed), _cdf(tokenId, traitId)), revealed);
    }
}

/**
 * @notice A contract that can sample token traits from discrete probability distributions loaded from storage.
 */
abstract contract StochasticSamplerWithCDFStorage is StochasticSampler {
    using StochasticSamplingLib for uint64[];

    /**
     * @notice Thrown if the traitId is invalid, i.e. if it exceeds the number of traits.
     */
    error InvalidTraitId(uint256 traitId);

    /**
     * @notice Thrown if the length of the given PDF does not match the number of realisations in a given trait.
     */
    error IncorrectPDFLength(uint256 gotLength, uint256 traitId, uint256 wantLength);

    /**
     * @notice Thrown if the given PDF cannot be normalised, i.e. if the sum of the probabilities is zero.
     */
    error ConstantZeroPDF();

    /**
     * @notice The number of realisations for each trait.
     */
    uint256[] private _numPerTrait;

    /**
     * @notice The cumulative probability distributions for each trait.
     * @dev Indexed by traitId, distributionVersion, sample.
     * @dev The distributionVersion is intended to allow having multiple "versions" of the probability distributions.
     */
    uint64[][][] private _cdfs;

    constructor(uint256[] memory numPerTrait) {
        _numPerTrait = numPerTrait;
        for (uint256 i; i < numPerTrait.length; ++i) {
            _cdfs.push(new uint64[][](0));
        }
        assert(_cdfs.length == numPerTrait.length);
    }

    /**
     * @notice Adds a new probability distribution for a given trait.
     */
    function _pushProbabilities(uint256 traitId, uint64[] memory pdf) internal {
        if (traitId >= _numPerTrait.length) {
            revert InvalidTraitId(traitId);
        }

        if (pdf.length != _numPerTrait[traitId]) {
            revert IncorrectPDFLength(pdf.length, traitId, _numPerTrait[traitId]);
        }

        uint64[] memory cdf = pdf.computeCDF();
        if (cdf[cdf.length - 1] == 0) {
            revert ConstantZeroPDF();
        }
        _cdfs[traitId].push(cdf);
    }

    /**
     * @notice Returns the version/index of the latest probability distribution for a given trait.
     */
    function _latestDistributionVersion(uint256 traitId) internal view returns (uint256) {
        return _cdfs[traitId].length - 1;
    }

    /**
     * @notice Returns the version/index of the probability distribution that is used for a given token and trait.
     * @dev This function is intended to be overridden by inheriting contracts.
     */
    function _distributionVersion(uint256 tokenId, uint256 traitId) internal view virtual returns (uint256);

    /**
     * @inheritdoc StochasticSampler
     * @dev Returns the probability distribution that is index by `_distributionVersion`.
     */
    function _cdf(uint256 tokenId, uint256 traitId) internal view virtual override returns (uint64[] memory) {
        if (traitId >= _numPerTrait.length) {
            revert InvalidTraitId(traitId);
        }
        return _cdfs[traitId][_distributionVersion(tokenId, traitId)];
    }
}

/**
 * @notice A contract that can sample token traits from discrete probability distributions using entropy provided by the
 * EntropyOracle.
 */
abstract contract StochasticSamplerWithOracle is StochasticSampler {
    /**
     * @notice The entropy oracle.
     */
    IEntropyOracle public entropyOracle;

    constructor(IEntropyOracle entropyOracle_) {
        entropyOracle = entropyOracle_;
    }

    /**
     * @inheritdoc StochasticSampler
     * @dev Uses the entropy of the block at `_revealBlockNumber(tokenId)`.
     */
    function _seed(uint256 tokenId) internal view virtual override returns (bytes32, bool) {
        bytes32 entropy = entropyOracle.blockEntropy(_revealBlockNumber(tokenId));
        return (keccak256(abi.encode(entropy, tokenId)), entropy != 0);
    }

    /**
     * @notice The blocknumber at which a given token will be revealed.
     * @dev The entropy provided by `entropyOracle` for this block will be used as seed for trait sampling.
     */
    function _revealBlockNumber(uint256 tokenId) internal view virtual returns (uint256);
}

{
  "compilationTarget": {
    "src/Mythics/MythicsEggRedeemer.sol": "MythicsEggRedeemer"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "appendCBOR": false,
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 9999
  },
  "remappings": [
    ":@divergencetech/ethier/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ethier_0-55-0/",
    ":@openzeppelin/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/",
    ":@openzeppelin/contracts-upgradeable/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts-upgradeable_4-9-0/",
    ":ERC721A/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ERC721A_4-2-3/contracts/",
    ":ERC721A_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ERC721A_4-2-3/",
    ":delegation-registry/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/delegation-registry_2d1a158b/src/",
    ":delegation-registry_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/delegation-registry_2d1a158b/",
    ":ds-test/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ds-test_013e6c64/src/",
    ":erc721a/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ERC721A_4-2-3/",
    ":ethier/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ethier_0-55-0/contracts/",
    ":ethier_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ethier_0-55-0/",
    ":forge-std/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/forge-std_1-5-6/src/",
    ":forge-std_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/forge-std_1-5-6/",
    ":openzeppelin-contracts-upgradeable/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts-upgradeable_4-9-0/contracts/",
    ":openzeppelin-contracts-upgradeable/contracts/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts-upgradeable_4-9-0/contracts/",
    ":openzeppelin-contracts-upgradeable_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts-upgradeable_4-9-0/",
    ":openzeppelin-contracts/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/contracts/",
    ":openzeppelin-contracts/contracts/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/contracts/",
    ":openzeppelin-contracts_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/",
    ":operator-filter-registry/src/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/operator-filter-registry_1-4-1/src/",
    ":operator-filter-registry_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/operator-filter-registry_1-4-1/",
    ":proof/archive/=/home/dave/proof/proof-seller/contracts/archive/src/",
    ":proof/constants/=/home/dave/proof/proof-seller/contracts/constants/src/",
    ":proof/entropy/=/home/dave/proof/proof-seller/contracts/entropy/",
    ":proof/redemption/=/home/dave/proof/proof-seller/contracts/redemption/src/",
    ":proof/sellers/=/home/dave/proof/proof-seller/contracts/sellers/src/"
  ]
}