Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.26;

import { Address } from "@oz/utils/Address.sol";
import { MerkleProof } from "@oz/utils/cryptography/MerkleProof.sol";
import { Math } from "@oz/utils/math/Math.sol";
import { EnumerableSet } from "@oz/utils/structs/EnumerableSet.sol";
import { AccessControlUpgradeable } from "@oz-upgradeable/access/AccessControlUpgradeable.sol";
import { Initializable } from "@oz-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import { UUPSUpgradeable } from "@oz-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import { ERC20Upgradeable } from "@oz-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import { PausableUpgradeable } from "@oz-upgradeable/utils/PausableUpgradeable.sol";

import { IToken } from "./IToken.sol";
import { TokenStorage as Storage } from "./TokenStorage.sol";
import { AccrualData, Fund, InitializationBasisPointValues, Refund } from "./Types.sol";

/// @title Token
/// @dev contains all logic for the Token contract
contract Token is
    IToken,
    UUPSUpgradeable,
    AccessControlUpgradeable,
    ERC20Upgradeable,
    PausableUpgradeable
{
    using Address for address payable;
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;
    using Math for uint256;

    /// @dev role which can change Token parameters and pause/unpause Token
    bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
    /// @dev role which can upgrade the contract
    bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
    /// @dev role which can mint / burn tokens only
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    /// @dev role which can start new periods, payout ETH and set social root
    bytes32 public constant SERVICE_ROLE = keccak256("SERVICE_ROLE");
    /// @dev role which can process batch refunds
    bytes32 public constant REFUND_OPERATOR_ROLE =
        keccak256("REFUND_OPERATOR_ROLE");

    // used for floating point calculations
    uint256 public constant SCALE = 10 ** 36;
    // used for fee calculations - not sufficient for floating point calculations
    uint32 public constant BASIS = 1000000000;

    /// @dev conversion ratio: 1 ETH = 1,000,000 $TOKEN
    uint256 public constant TOKEN_TO_ETH_RATIO = 1e6;

    constructor() {
        _disableInitializers();
    }

    /// @inheritdoc IToken
    function __Token_init(
        string memory name,
        string memory symbol,
        address admin,
        address manager,
        address upgrader,
        address service,
        address treasury,
        address tradesWallet,
        address refundOperator,
        InitializationBasisPointValues calldata basisPointValues
    ) external initializer {
        __Pausable_init();
        __AccessControl_init();
        __UUPSUpgradeable_init();

        __ERC20_init(name, symbol);
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(MANAGER_ROLE, manager);
        _grantRole(UPGRADER_ROLE, upgrader);
        _grantRole(MINTER_ROLE, service);
        _grantRole(SERVICE_ROLE, service);
        _grantRole(REFUND_OPERATOR_ROLE, refundOperator);

        _setTreasury(treasury);
        _setTradesWallet(tradesWallet);
        _setDistributionFractionBP(basisPointValues.distributionFractionBP);
        _setTradesFractionBP(basisPointValues.tradesFractionBP);
        _setTokenBackingFractionBP(basisPointValues.tokenBackingFractionBP);
        _setProtocolFeeBP(basisPointValues.protocolFeeBP);
        _setRepaymentFractionBP(basisPointValues.repaymentFractionBP);
    }

    /// @inheritdoc IToken
    function attempt(
        uint256 gameId,
        string calldata attemptId
    ) external payable whenNotPaused {
        Storage.Layout storage $ = Storage.layout();

        if (!$.gameIds.contains(gameId)) {
            revert InvalidGameId();
        }
        if (msg.value == 0) {
            revert ZeroAmountAttempt();
        }

        // allocate attempt value
        uint256 fees = msg.value.mulDiv($.protocolFeeBP, BASIS);
        uint256 tradesFundAllocation = msg.value.mulDiv(
            $.tradesFractionBP,
            BASIS
        );
        uint256 tokenBackingAllocation = msg.value.mulDiv(
            $.tokenBackingFractionBP,
            BASIS
        );
        uint256 earnings = msg.value -
            fees -
            tradesFundAllocation -
            tokenBackingAllocation;

        $.tradesFund += tradesFundAllocation;
        $.tokenBackingFund += tokenBackingAllocation;
        $.fees += fees;
        $.earnings += earnings;
        $.periodEarnings += earnings;

        emit AttemptMade(gameId, _msgSender(), msg.value, attemptId);
    }

    /// @inheritdoc IToken
    function attemptWithToken(
        uint256 gameId,
        uint256 amount,
        string calldata attemptId
    ) external whenNotPaused {
        Storage.Layout storage $ = Storage.layout();

        if (!$.gameIds.contains(gameId)) {
            revert InvalidGameId();
        }
        // if amount is less than TOKEN_TO_ETH_RATIO less than 1
        // wei is being sent in terms of value
        if (amount < TOKEN_TO_ETH_RATIO) {
            revert ZeroAmountAttempt();
        }

        uint256 amountValue = amount / TOKEN_TO_ETH_RATIO;

        // allocate attempt value
        uint256 fees = amountValue.mulDiv($.protocolFeeBP, BASIS);
        uint256 tradesFundAllocation = amountValue.mulDiv(
            $.tradesFractionBP,
            BASIS
        );
        uint256 tokenBackingAllocation = amountValue.mulDiv(
            $.tokenBackingFractionBP,
            BASIS
        );
        uint256 earnings = amountValue -
            fees -
            tradesFundAllocation -
            tokenBackingAllocation;

        if ($.tokenBackingFund < amountValue - tokenBackingAllocation) {
            revert InsufficientTokenBacking();
        }

        _accrueTokens($, _msgSender());
        _burn(_msgSender(), amount);

        $.fees += fees;
        $.tradesFund += tradesFundAllocation;
        // consolation decreases since that is where the value for this attempt
        // comes from
        $.tokenBackingFund -= amountValue - tokenBackingAllocation;
        $.earnings += earnings;
        $.periodEarnings += earnings;

        emit AttemptWithTokenMade(
            gameId,
            _msgSender(),
            amount,
            amountValue,
            attemptId
        );
    }

    /// @inheritdoc IToken
    function addGameId(uint256 id) external onlyRole(MANAGER_ROLE) {
        Storage.layout().gameIds.add(id);

        emit GameIdAdded(id);
    }

    /// @inheritdoc IToken
    function batchRefund(
        Refund[] calldata refunds
    ) external onlyRole(REFUND_OPERATOR_ROLE) {
        Storage.Layout storage $ = Storage.layout();

        uint256 refundCount = refunds.length;

        uint256 totalAmount;
        for (uint256 i = 0; i < refundCount; ++i) {
            totalAmount += refunds[i].amount;
        }

        if (totalAmount > $.repaymentFund) {
            revert InsufficientRepaymentFund();
        }

        $.repaymentFund -= totalAmount;

        unchecked {
            for (uint256 i = 0; i < refundCount; ++i) {
                if (refunds[i].account == address(0)) {
                    revert ZeroAddress();
                }
                if (refunds[i].amount == 0) continue;

                payable(refunds[i].account).sendValue(refunds[i].amount);
            }
        }

        emit BatchRefundProcessed(refunds);
    }

    /// @inheritdoc IToken
    function claim() external {
        Storage.Layout storage $ = Storage.layout();

        // accrue tokens prior to claim
        AccrualData storage accountData = _accrueTokens($, _msgSender());

        uint256 accruedTokens = accountData.accruedTokens;

        // decrease distribution supply by claimed tokens
        $.distributionSupply -= accruedTokens;

        // set accruedTokens of account to 0
        accountData.accruedTokens = 0;

        _transfer(address(this), _msgSender(), accruedTokens);
    }

    /// @inheritdoc IToken
    function claimSocialEarnings(
        bytes32[] calldata proof,
        uint256 amount
    ) external {
        Storage.Layout storage $ = Storage.layout();

        bytes32 leaf = keccak256(
            abi.encodePacked(keccak256(abi.encodePacked(_msgSender(), amount)))
        );

        if (!MerkleProof.verify(proof, $.socialRoot, leaf)) {
            revert InvalidProof();
        }

        uint256 amountEarned = amount - $.socialEarningsDeduction[_msgSender()];

        if (amountEarned > $.earnings) {
            revert InsufficientEarnings();
        }

        $.earnings -= amountEarned;
        $.tokenBackingFund += amountEarned;
        $.socialEarningsDeduction[_msgSender()] += amountEarned;

        _accrueTokens($, _msgSender());
        _mint(_msgSender(), amountEarned * TOKEN_TO_ETH_RATIO);

        emit SocialEarningsClaimed(_msgSender(), amountEarned);
    }

    /// @inheritdoc IToken
    function disperseTokens(
        address[] calldata recipients,
        uint256[] calldata amounts
    ) external onlyRole(MANAGER_ROLE) {
        Storage.Layout storage $ = Storage.layout();
        uint256 totalAmount;

        for (uint256 i = 0; i < recipients.length; ++i) {
            // accrue tokens prior to disperse
            _accrueTokens($, recipients[i]);

            _transfer(address(this), recipients[i], amounts[i]);

            totalAmount += amounts[i];
        }

        $.airdropSupply -= totalAmount;
    }

    /// @inheritdoc IToken
    function injectRepaymentLiquidity()
        external
        payable
        onlyRole(MANAGER_ROLE)
    {
        Storage.Layout storage $ = Storage.layout();

        $.repaymentFund += msg.value;

        emit RepaymentLiquidityInjected(msg.value);
    }

    /// @inheritdoc IToken
    function injectTradesLiquidity() external payable onlyRole(MANAGER_ROLE) {
        Storage.Layout storage $ = Storage.layout();

        $.tradesFund += msg.value;

        emit TradesLiquidityInjected(msg.value);
    }

    /// @inheritdoc IToken
    function injectTokenBackingLiquidity()
        external
        payable
        onlyRole(MANAGER_ROLE)
    {
        Storage.Layout storage $ = Storage.layout();

        $.tokenBackingFund += msg.value;

        emit TokenBackingLiquidityInjected(msg.value);
    }

    /// @inheritdoc IToken
    function mint(
        address account,
        uint256 amount
    ) external onlyRole(MINTER_ROLE) whenNotPaused {
        if (Storage.layout().distributionFractionBP == 0) {
            _mint(account, amount);
        } else {
            _mintWithDistribution(account, amount);
        }
    }

    /// @inheritdoc IToken
    function mintAirdrop(
        uint256 amount
    ) external payable onlyRole(MANAGER_ROLE) whenNotPaused {
        Storage.Layout storage $ = Storage.layout();
        _mint(address(this), amount);

        if (amount != msg.value * TOKEN_TO_ETH_RATIO) {
            revert IncorrectETHReceived();
        }

        // increase supply by the amount minted for airdrop
        $.airdropSupply += amount;
        $.tokenBackingFund += msg.value;

        emit AirdropMinted(amount);
    }

    /// @inheritdoc IToken
    function pause() external override onlyRole(MANAGER_ROLE) whenNotPaused {
        _pause();
    }

    /// @inheritdoc IToken
    function reallocateFunds(
        Fund from,
        Fund to,
        uint256 amount
    ) external onlyRole(MANAGER_ROLE) {
        if (from == to) {
            revert FundSelfTransfer();
        }

        _debitFund(from, amount);
        _creditFund(to, amount);

        emit FundsReallocated(from, to, amount);
    }

    /// @inheritdoc IToken
    function setDistributionFractionBP(
        uint256 distributionFractionBP
    ) external onlyRole(MANAGER_ROLE) {
        _setDistributionFractionBP(distributionFractionBP);
    }

    /// @inheritdoc IToken
    function setTradesFractionBP(
        uint256 tradesFractionBP
    ) external onlyRole(MANAGER_ROLE) {
        _setTradesFractionBP(tradesFractionBP);
    }

    /// @inheritdoc IToken
    function setTradesWallet(
        address tradesWallet
    ) external onlyRole(MANAGER_ROLE) {
        _setTradesWallet(tradesWallet);
    }

    /// @inheritdoc IToken
    function setProtocolFeeBP(
        uint256 protocolFeeBP
    ) external onlyRole(MANAGER_ROLE) {
        _setProtocolFeeBP(protocolFeeBP);
    }

    /// @inheritdoc IToken
    function setRepaymentFractionBP(
        uint256 repaymentFractionBP
    ) external onlyRole(MANAGER_ROLE) {
        _setRepaymentFractionBP(repaymentFractionBP);
    }

    /// @inheritdoc IToken
    function setSocialRoot(bytes32 root) external onlyRole(SERVICE_ROLE) {
        Storage.layout().socialRoot = root;

        emit SocialRootSet(root);
    }

    /// @inheritdoc IToken
    function setTokenBackingFractionBP(
        uint256 tokenBackingFractionBP
    ) external onlyRole(MANAGER_ROLE) {
        _setTokenBackingFractionBP(tokenBackingFractionBP);
    }

    /// @inheritdoc IToken
    function setTreasury(address treasury) external onlyRole(MANAGER_ROLE) {
        _setTreasury(treasury);
    }

    /// @inheritdoc IToken
    function startNewPeriod()
        external
        onlyRole(SERVICE_ROLE)
        returns (uint256 currentEarnings)
    {
        Storage.Layout storage $ = Storage.layout();

        currentEarnings = $.periodEarnings;
        delete $.periodEarnings;

        emit NewPeriodStarted(currentEarnings);
    }

    /// @inheritdoc IToken
    function unpause() external override onlyRole(MANAGER_ROLE) whenPaused {
        _unpause();
    }

    /// @inheritdoc IToken
    function withdrawEarnings(uint256 amount) external onlyRole(MANAGER_ROLE) {
        Storage.Layout storage $ = Storage.layout();

        if ($.earnings < amount) {
            revert InsufficientEarnings();
        }

        $.earnings -= amount;

        payable($.treasury).sendValue(amount);

        emit EarningsWithdrawn(amount);
    }

    /// @inheritdoc IToken
    function withdrawFees() external onlyRole(MANAGER_ROLE) {
        Storage.Layout storage $ = Storage.layout();

        uint256 fees = $.fees;
        delete $.fees;

        payable($.treasury).sendValue(fees);

        emit FeesWithdrawn(fees);
    }

    /// @inheritdoc IToken
    function withdrawTradesWalletFunds(
        uint256 amount
    ) external onlyRole(MANAGER_ROLE) {
        Storage.Layout storage $ = Storage.layout();

        if (amount > $.tradesFund) {
            revert TradesFundTooLow();
        }

        $.tradesFund -= amount;

        payable($.tradesWallet).sendValue(amount);

        emit TradesWalletFunded(amount);
    }

    /// @inheritdoc IToken
    function withdrawTokenBackingLiquidity(
        uint256 amount
    ) external onlyRole(MANAGER_ROLE) {
        Storage.Layout storage $ = Storage.layout();

        if (amount > $.tokenBackingFund) {
            revert TokenBackingFundTooLow();
        }

        $.tokenBackingFund -= amount;

        payable($.treasury).sendValue(amount);

        emit TokenBackingLiquidityWithdrawn(amount);
    }

    /// @inheritdoc IToken
    function getAccrualData(
        address account
    ) external view returns (AccrualData memory data) {
        data = Storage.layout().accrualData[account];
    }

    /// @inheritdoc IToken
    function getAirdropSupply() external view returns (uint256 supply) {
        supply = Storage.layout().airdropSupply;
    }

    /// @inheritdoc IToken
    function getClaimableTokens(
        address account
    ) external view returns (uint256 amount) {
        Storage.Layout storage $ = Storage.layout();
        AccrualData storage accountData = $.accrualData[account];

        amount =
            balanceOf(account).mulDiv(
                $.globalRatio - accountData.offset,
                SCALE
            ) +
            accountData.accruedTokens;
    }

    /// @inheritdoc IToken
    function getDistributionFractionBP()
        external
        view
        returns (uint256 fractionBP)
    {
        fractionBP = Storage.layout().distributionFractionBP;
    }

    /// @inheritdoc IToken
    function getDistributionSupply() external view returns (uint256 supply) {
        supply = Storage.layout().distributionSupply;
    }

    /// @inheritdoc IToken
    function getEarnings() external view returns (uint256 earnings) {
        earnings = Storage.layout().earnings;
    }

    /// @inheritdoc IToken
    function getFees() external view returns (uint256 fees) {
        fees = Storage.layout().fees;
    }

    /// @inheritdoc IToken
    function getTradesFractionBP() external view returns (uint256 fractionBP) {
        fractionBP = Storage.layout().tradesFractionBP;
    }

    /// @inheritdoc IToken
    function getTradesFund() external view returns (uint256 fund) {
        fund = Storage.layout().tradesFund;
    }

    /// @inheritdoc IToken
    function getTradesWallet() external view returns (address wallet) {
        wallet = Storage.layout().tradesWallet;
    }

    /// @inheritdoc IToken
    function getGameIds() external view returns (uint256[] memory ids) {
        ids = Storage.layout().gameIds.values();
    }

    /// @notice returns the global ratio value
    /// @return ratio global ratio value
    function getGlobalRatio() external view returns (uint256 ratio) {
        ratio = Storage.layout().globalRatio;
    }

    /// @inheritdoc IToken
    function getPeriodEarnings() external view returns (uint256 earnings) {
        earnings = Storage.layout().periodEarnings;
    }

    /// @inheritdoc IToken
    function getProtocolFeeBP() external view returns (uint256 protocolFeeBP) {
        protocolFeeBP = Storage.layout().protocolFeeBP;
    }

    /// @inheritdoc IToken
    function getRepaymentFractionBP()
        external
        view
        returns (uint256 fractionBP)
    {
        fractionBP = Storage.layout().repaymentFractionBP;
    }

    /// @inheritdoc IToken
    function getRepaymentFund() external view returns (uint256 fund) {
        fund = Storage.layout().repaymentFund;
    }

    /// @inheritdoc IToken
    function getSocialEarningsDeduction(
        address account
    ) external view returns (uint256 deduction) {
        deduction = Storage.layout().socialEarningsDeduction[account];
    }

    /// @inheritdoc IToken
    function getSocialRoot() external view returns (bytes32 root) {
        root = Storage.layout().socialRoot;
    }

    /// @inheritdoc IToken
    function getTokenBackingFractionBP()
        external
        view
        returns (uint256 fractionBP)
    {
        fractionBP = Storage.layout().tokenBackingFractionBP;
    }

    /// @inheritdoc IToken
    function getTokenBackingFund() external view returns (uint256 fund) {
        fund = Storage.layout().tokenBackingFund;
    }

    /// @inheritdoc IToken
    function getTreasury() external view returns (address treasury) {
        treasury = Storage.layout().treasury;
    }

    /// @notice accrues the tokens available for claiming for an account
    /// @param $ TokenStorage Layout struct
    /// @param account address of account
    /// @return accountData accrualData of given account
    function _accrueTokens(
        Storage.Layout storage $,
        address account
    ) internal returns (AccrualData storage accountData) {
        accountData = $.accrualData[account];

        // calculate claimable tokens
        uint256 accruedTokens = balanceOf(account).mulDiv(
            $.globalRatio - accountData.offset,
            SCALE
        );

        // update account's last ratio
        accountData.offset = $.globalRatio;

        // update claimable tokens
        accountData.accruedTokens += accruedTokens;
    }

    /// @inheritdoc UUPSUpgradeable
    function _authorizeUpgrade(
        address
    ) internal override onlyRole(UPGRADER_ROLE) {}

    /// @notice sets a new value for distributionFractionBP
    /// @param distributionFractionBP new distributionFractionBP value
    function _setDistributionFractionBP(
        uint256 distributionFractionBP
    ) internal {
        _enforceBasis(distributionFractionBP, BASIS);

        Storage.layout().distributionFractionBP = distributionFractionBP;
        emit DistributionFractionSet(distributionFractionBP);
    }

    /// @notice sets a new value for repaymentFractionBP
    /// @param repaymentFractionBP new repaymentFractionBP value
    function _setRepaymentFractionBP(uint256 repaymentFractionBP) internal {
        _enforceBasis(repaymentFractionBP, BASIS);
        Storage.Layout storage $ = Storage.layout();

        if (
            $.protocolFeeBP +
                $.tradesFractionBP +
                $.tokenBackingFractionBP +
                repaymentFractionBP >
            BASIS
        ) {
            revert FractionSumExceedsBasis();
        }

        $.repaymentFractionBP = repaymentFractionBP;
        emit RepaymentFractionSet(repaymentFractionBP);
    }

    /// @notice sets a new value for tradesFractionBP
    /// @param tradesFractionBP new tradesFractionBP value
    function _setTradesFractionBP(uint256 tradesFractionBP) internal {
        _enforceBasis(tradesFractionBP, BASIS);

        Storage.Layout storage $ = Storage.layout();

        if (
            $.tokenBackingFractionBP +
                tradesFractionBP +
                $.protocolFeeBP +
                $.repaymentFractionBP >
            BASIS
        ) {
            revert FractionSumExceedsBasis();
        }

        $.tradesFractionBP = tradesFractionBP;

        emit TradesFractionSet(tradesFractionBP);
    }

    /// @notice sets a new value for tradesWallet
    /// @param tradesWallet new tradesWallet value
    function _setTradesWallet(address tradesWallet) internal {
        _enforceNonZeroAddress(tradesWallet);

        Storage.layout().tradesWallet = tradesWallet;

        emit TradesWalletSet(tradesWallet);
    }

    /// @notice sets a new value for protocolFeeBP
    /// @param feeBP new protocolFeeBP value
    function _setProtocolFeeBP(uint256 feeBP) internal {
        _enforceBasis(feeBP, BASIS);

        Storage.Layout storage $ = Storage.layout();

        if (
            $.tokenBackingFractionBP +
                $.tradesFractionBP +
                feeBP +
                $.repaymentFractionBP >
            BASIS
        ) {
            revert FractionSumExceedsBasis();
        }

        $.protocolFeeBP = feeBP;

        emit ProtocolFeeSet(feeBP);
    }

    /// @notice sets a new value for tokenBackingFractionBP
    /// @param tokenBackingFractionBP new tokenBackingFractionBP value
    function _setTokenBackingFractionBP(
        uint256 tokenBackingFractionBP
    ) internal {
        _enforceBasis(tokenBackingFractionBP, BASIS);

        Storage.Layout storage $ = Storage.layout();

        if (
            $.tradesFractionBP +
                $.protocolFeeBP +
                $.repaymentFractionBP +
                tokenBackingFractionBP >
            BASIS
        ) {
            revert FractionSumExceedsBasis();
        }

        $.tokenBackingFractionBP = tokenBackingFractionBP;

        emit TokenBackingFractionSet(tokenBackingFractionBP);
    }

    /// @notice sets a new value for treasury
    /// @param treasury new treasury value
    function _setTreasury(address treasury) internal {
        _enforceNonZeroAddress(treasury);

        Storage.layout().treasury = treasury;

        emit TreasurySet(treasury);
    }

    /// @notice enforces that an address is not the zero address
    /// @param addressToCheck address to check
    function _enforceNonZeroAddress(address addressToCheck) internal pure {
        if (addressToCheck == address(0)) {
            revert ZeroAddress();
        }
    }

    /// @notice credits a given fund with an amount
    /// @param fund Fund to credit
    /// @param amount Amount to credit
    function _creditFund(Fund fund, uint256 amount) internal {
        Storage.Layout storage $ = Storage.layout();

        // enum conversion error thrown if fund is invalid

        if (fund == Fund.FEES) $.fees += amount;
        else if (fund == Fund.EARNINGS) $.earnings += amount;
        else if (fund == Fund.TRADES) $.tradesFund += amount;
        else if (fund == Fund.TOKEN_BACKING) $.tokenBackingFund += amount;
        else if (fund == Fund.REPAYMENT) $.repaymentFund += amount;
    }

    /// @notice debits a given fund with an amount
    /// @param fund Fund to debit
    /// @param amount Amount to debit
    function _debitFund(Fund fund, uint256 amount) internal {
        Storage.Layout storage $ = Storage.layout();

        // enum conversion error thrown if fund is invalid

        if (fund == Fund.FEES) $.fees -= amount;
        else if (fund == Fund.EARNINGS) $.earnings -= amount;
        else if (fund == Fund.TRADES) $.tradesFund -= amount;
        else if (fund == Fund.TOKEN_BACKING) $.tokenBackingFund -= amount;
        else if (fund == Fund.REPAYMENT) $.repaymentFund -= amount;
    }

    /// @notice mints tokens when distributionFractionBP is non-zero
    /// @param account address of account to mint to
    /// @param amount amount to mint
    function _mintWithDistribution(address account, uint256 amount) internal {
        Storage.Layout storage $ = Storage.layout();

        // calculate amount for distribution
        uint256 distributionAmount = amount.mulDiv(
            $.distributionFractionBP,
            BASIS
        );

        // decrease amount to mint to account
        amount -= distributionAmount;

        uint256 accountBalance = balanceOf(account);
        uint256 supplyDelta = totalSupply() -
            accountBalance -
            $.distributionSupply -
            $.airdropSupply;

        AccrualData storage accountData = $.accrualData[account];

        // Always calculate and accrue previous token accruals
        uint256 previousAccruals = accountBalance.mulDiv(
            $.globalRatio - accountData.offset,
            SCALE
        );

        // Calculate the distribution ratio
        uint256 distributionRatio = distributionAmount.mulDiv(
            SCALE,
            supplyDelta > 0 ? supplyDelta : amount
        );

        // Update globalRatio
        $.globalRatio += distributionRatio;

        // If supplyDelta is zero, adjust the account offset differently
        if (supplyDelta == 0) {
            // Handle the case where there are no tokens in circulation
            // If this is the first minter, account offset should be one step behind globalRatio
            if ($.globalRatio % distributionRatio == 0) {
                accountData.offset = $.globalRatio - distributionRatio;
            } else {
                // Sole holder due to all other minters burning tokens
                accountData.accruedTokens +=
                    distributionAmount +
                    previousAccruals;
                accountData.offset = $.globalRatio;
            }
        } else {
            // Normal case where there are other tokens in circulation
            accountData.offset = $.globalRatio;
            accountData.accruedTokens += previousAccruals;
        }

        $.distributionSupply += distributionAmount;

        // mint tokens to contract and account
        _mint(address(this), distributionAmount);
        _mint(account, amount);
    }

    /// @inheritdoc ERC20Upgradeable
    /// @dev overrides _update hook to enforce non-transferability
    function _update(
        address from,
        address to,
        uint256 value
    ) internal virtual override {
        if (from != address(0) && from != address(this)) {
            if (to != address(0)) {
                revert NonTransferable();
            }
        }

        super._update(from, to, value);
    }

    /// @notice enforces that a value does not exceed the basis
    /// @param value value to check
    /// @param basis basis to check against
    function _enforceBasis(uint256 value, uint256 basis) internal pure {
        if (value > basis) {
            revert BasisExceeded();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {Errors.FailedCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)
// This file was procedurally generated from scripts/generate/templates/MerkleProof.js.

pragma solidity ^0.8.20;

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

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 *
 * IMPORTANT: Consider memory side-effects when using custom hashing functions
 * that access memory in an unsafe way.
 *
 * NOTE: This library supports proof verification for merkle trees built using
 * custom _commutative_ hashing functions (i.e. `H(a, b) == H(b, a)`). Proving
 * leaf inclusion in trees built using non-commutative hashing functions requires
 * additional logic that is not supported by this library.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with the default hashing function.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with the default hashing function.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with a custom hashing function.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processProof(proof, leaf, hasher) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * This version handles proofs in memory with a custom hashing function.
     */
    function processProof(
        bytes32[] memory proof,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = hasher(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with the default hashing function.
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with the default hashing function.
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = Hashes.commutativeKeccak256(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with a custom hashing function.
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processProofCalldata(proof, leaf, hasher) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * This version handles proofs in calldata with a custom hashing function.
     */
    function processProofCalldata(
        bytes32[] calldata proof,
        bytes32 leaf,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = hasher(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in memory with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProof}.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in memory with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = Hashes.commutativeKeccak256(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in memory with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProof}.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processMultiProof(proof, proofFlags, leaves, hasher) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in memory with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = hasher(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in calldata with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProofCalldata}.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in calldata with the default hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = Hashes.commutativeKeccak256(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * This version handles multiproofs in calldata with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * NOTE: Consider the case where `root == proof[0] && leaves.length == 0` as it will return `true`.
     * The `leaves` must be validated independently. See {processMultiProofCalldata}.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves, hasher) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * This version handles multiproofs in calldata with a custom hashing function.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * NOTE: The _empty set_ (i.e. the case where `proof.length == 1 && leaves.length == 0`) is considered a no-op,
     * and therefore a valid multiproof (i.e. it returns `proof[0]`). Consider disallowing this case if you're not
     * validating the leaves elsewhere.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves,
        function(bytes32, bytes32) view returns (bytes32) hasher
    ) internal view returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofFlagsLen = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proof.length != proofFlagsLen + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](proofFlagsLen);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < proofFlagsLen; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = hasher(a, b);
        }

        if (proofFlagsLen > 0) {
            if (proofPos != proof.length) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[proofFlagsLen - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a > b, a, b);
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a < b, a, b);
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

    /**
     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     *
     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2²⁵⁶ + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
            if (denominator <= prod1) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 exp;
        unchecked {
            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
            value >>= exp;
            result += exp;

            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
            value >>= exp;
            result += exp;

            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
            value >>= exp;
            result += exp;

            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
            value >>= exp;
            result += exp;

            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
            value >>= exp;
            result += exp;

            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
            value >>= exp;
            result += exp;

            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
            value >>= exp;
            result += exp;

            result += SafeCast.toUint(value > 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 isGt;
        unchecked {
            isGt = SafeCast.toUint(value > (1 << 128) - 1);
            value >>= isGt * 128;
            result += isGt * 16;

            isGt = SafeCast.toUint(value > (1 << 64) - 1);
            value >>= isGt * 64;
            result += isGt * 8;

            isGt = SafeCast.toUint(value > (1 << 32) - 1);
            value >>= isGt * 32;
            result += isGt * 4;

            isGt = SafeCast.toUint(value > (1 << 16) - 1);
            value >>= isGt * 16;
            result += isGt * 2;

            result += SafeCast.toUint(value > (1 << 8) - 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly ("memory-safe") {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)

pragma solidity ^0.8.20;

import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {ERC165Upgradeable} from "../utils/introspection/ERC165Upgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;


    /// @custom:storage-location erc7201:openzeppelin.storage.AccessControl
    struct AccessControlStorage {
        mapping(bytes32 role => RoleData) _roles;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.AccessControl")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;

    function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {
        assembly {
            $.slot := AccessControlStorageLocation
        }
    }

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    function __AccessControl_init() internal onlyInitializing {
    }

    function __AccessControl_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        AccessControlStorage storage $ = _getAccessControlStorage();
        return $._roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        AccessControlStorage storage $ = _getAccessControlStorage();
        return $._roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        AccessControlStorage storage $ = _getAccessControlStorage();
        bytes32 previousAdminRole = getRoleAdmin(role);
        $._roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        AccessControlStorage storage $ = _getAccessControlStorage();
        if (!hasRole(role, account)) {
            $._roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        AccessControlStorage storage $ = _getAccessControlStorage();
        if (hasRole(role, account)) {
            $._roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.20;

import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol";
import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
import {Initializable} from "./Initializable.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable __self = address(this);

    /**
     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`
     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,
     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.
     * If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must
     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function
     * during an upgrade.
     */
    string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";

    /**
     * @dev The call is from an unauthorized context.
     */
    error UUPSUnauthorizedCallContext();

    /**
     * @dev The storage `slot` is unsupported as a UUID.
     */
    error UUPSUnsupportedProxiableUUID(bytes32 slot);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        _checkProxy();
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        _checkNotDelegated();
        _;
    }

    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual notDelegated returns (bytes32) {
        return ERC1967Utils.IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data);
    }

    /**
     * @dev Reverts if the execution is not performed via delegatecall or the execution
     * context is not of a proxy with an ERC-1967 compliant implementation pointing to self.
     * See {_onlyProxy}.
     */
    function _checkProxy() internal view virtual {
        if (
            address(this) == __self || // Must be called through delegatecall
            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy
        ) {
            revert UUPSUnauthorizedCallContext();
        }
    }

    /**
     * @dev Reverts if the execution is performed via delegatecall.
     * See {notDelegated}.
     */
    function _checkNotDelegated() internal view virtual {
        if (address(this) != __self) {
            // Must not be called through delegatecall
            revert UUPSUnauthorizedCallContext();
        }
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.
     *
     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value
     * is expected to be the implementation slot in ERC-1967.
     *
     * Emits an {IERC1967-Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {
        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {
                revert UUPSUnsupportedProxiableUUID(slot);
            }
            ERC1967Utils.upgradeToAndCall(newImplementation, data);
        } catch {
            // The implementation is not UUPS
            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC20
    struct ERC20Storage {
        mapping(address account => uint256) _balances;

        mapping(address account => mapping(address spender => uint256)) _allowances;

        uint256 _totalSupply;

        string _name;
        string _symbol;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;

    function _getERC20Storage() private pure returns (ERC20Storage storage $) {
        assembly {
            $.slot := ERC20StorageLocation
        }
    }

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        ERC20Storage storage $ = _getERC20Storage();
        $._name = name_;
        $._symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            $._totalSupply += value;
        } else {
            uint256 fromBalance = $._balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                $._balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                $._totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                $._balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        $._allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Pausable
    struct PausableStorage {
        bool _paused;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;

    function _getPausableStorage() private pure returns (PausableStorage storage $) {
        assembly {
            $.slot := PausableStorageLocation
        }
    }

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal onlyInitializing {
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal onlyInitializing {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        PausableStorage storage $ = _getPausableStorage();
        return $._paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.26;

import { AccrualData, Fund, InitializationBasisPointValues, Refund } from "./Types.sol";

/// @title IToken
/// @dev interface for Token contract containing all events, errors, and external/public functions
interface IToken {
    /// @notice thrown when the length of two arrays do not match
    error ArrayLengthMismatch();

    /// @notice thrown when attempting to set a value larger than basis
    error BasisExceeded();

    /// @notice thrown when attempting to set a new value which would mean that the sum of all
    /// fractions to be taken from the attempt amount exceeds basis
    error FractionSumExceedsBasis();

    /// @notice thrown when attempting to reallocate funds to the 'from' fund
    error FundSelfTransfer();

    /// @notice thrown when attempting to mint an airdrop without sending enough ETH to `Token` contract
    error IncorrectETHReceived();

    /// @notice thrown when attempting to withdarw an amount larger than current earnings
    error InsufficientEarnings();

    /// @notice thrown when attempting to refund an amount larger than current repayment fund
    error InsufficientRepaymentFund();

    /// @notice thrown when attempting a mint attempt with Token but there is insufficient token backing
    /// to cover the attempt
    error InsufficientTokenBacking();

    /// @notice thrown when a non-existent fund is being accessed
    error InvalidFund();

    /// @notice thrown when attempting on a gameId not contained in gameIds enumerable set
    error InvalidGameId();

    /// @notice thrown when the proof for a social claim is not matching the _msgSender() claiming and amount to claim
    error InvalidProof();

    /// @notice thrown when attempting to withdraw token backing liquidity but the amount is greater than the current
    /// token backing fund amount
    error TokenBackingFundTooLow();

    /// @notice thrown when attempting to withdraw trades wallet funds but the amount is greater than the current
    /// trades fund amount
    error TradesFundTooLow();

    /// @notice thrown when attempting to transfer tokens and the from address is neither
    /// the zero-address, nor the contract address, or the to address is not the zero address
    error NonTransferable();

    /// @notice thrown when attempting to set a value to the zero address
    error ZeroAddress();

    /// @notice thrown when attempting on a game with zero amount ie zending 0 tokens or native currency (ETH)
    error ZeroAmountAttempt();

    /// @notice emitted when an attempt is made on a game
    /// @param gameId of game being attempted
    /// @param account address of account attempting game
    /// @param amount msg.value received on attempt call
    /// @param attemptId UUID of attempt
    event AttemptMade(
        uint256 gameId,
        address account,
        uint256 amount,
        string attemptId
    );

    /// @notice emitted when an attempt is made on a game, with `Token` used as payment
    /// @param gameId of game being attempted
    /// @param account address of account attempting game
    /// @param amount amount of `Token` received
    /// @param amountValue amount of ETH corresponding to `Token` amount received
    /// @param attemptId UUID of attempt
    event AttemptWithTokenMade(
        uint256 gameId,
        address account,
        uint256 amount,
        uint256 amountValue,
        string attemptId
    );

    /// @notice emitted when an airdrop is minted
    /// @param amount `Token` amount to mint for airdrop
    event AirdropMinted(uint256 amount);

    /// @notice emitted when a batch refund is processed
    /// @param refunds array of Refund structs
    event BatchRefundProcessed(Refund[] refunds);

    /// @notice emitted when a new distributionFractionBP value is set
    /// @param distributionFractionBP the new distributionFractionBP value
    event DistributionFractionSet(uint256 distributionFractionBP);

    /// @notice emitted when earnings are withdrawn
    /// @param amount earnings withdrawn
    event EarningsWithdrawn(uint256 amount);

    /// @notice emitted when fees are withdraw and sent to reasury
    event FeesWithdrawn(uint256 fees);

    /// @notice emitted when funds are reallocated from one fund to another
    /// @param from Fund debited
    /// @param to Fund credited
    /// @param amount Amount reallocated
    event FundsReallocated(Fund from, Fund to, uint256 amount);

    /// @notice emitted when a new gameId is added to gameIds
    /// @param gameId id of new game
    event GameIdAdded(uint256 gameId);

    /// @notice emitted when a new value of repaymentFractionBP is set
    /// @param repaymentFractionBP new repaymentFractionBP value
    event RepaymentFractionSet(uint256 repaymentFractionBP);

    /// @notice emitted when token backing liquidity is withdrawn
    /// @param amount token backing liquidity withdrawn
    event TokenBackingLiquidityWithdrawn(uint256 amount);

    /// @notice emitted when a new value of tradesFractionBP is set
    /// @param tradesFractionBP new tradesFractionBP value
    event TradesFractionSet(uint256 tradesFractionBP);

    /// @notice emitted when a new value of tradesWallet is set
    /// @param wallet new tradesWallet value
    event TradesWalletSet(address wallet);

    /// @notice emitted when trades funds are sent to trades wallet
    /// @param amount funded
    event TradesWalletFunded(uint256 amount);

    /// @notice emitted when an account is added to minters
    /// @param account address of account
    event MinterAdded(address account);

    /// @notice emitted when an account is removed from minters
    /// @param account address of account
    event MinterRemoved(address account);

    /// @notice emitted when a new period for earnings has started
    /// @param currentEarnings value of period earnings at end of last period
    event NewPeriodStarted(uint256 currentEarnings);

    /// @notice emitted when a new value of protocolFeeBP is set
    /// @param protocolFeeBP new protocolFeeBP value
    event ProtocolFeeSet(uint256 protocolFeeBP);

    /// @notice emitted when repayment liquidity is injected
    /// @param amount injected
    event RepaymentLiquidityInjected(uint256 amount);

    /// @notice emitted when an account claims social earnings
    /// @param account address of account which claimed
    /// @param amount amount claimed as social earnings
    event SocialEarningsClaimed(address account, uint256 amount);

    /// @notice emitted when a new socialRoot value is set
    /// @param root new socialRoot value
    event SocialRootSet(bytes32 root);

    /// @notice emitted when a new value of tokenBackingFractionBP is set
    /// @param fractionBP new tokenBackingFractionBP value
    event TokenBackingFractionSet(uint256 fractionBP);

    /// @notice emitted when token backing funds are injected
    /// @param amount injected
    event TokenBackingLiquidityInjected(uint256 amount);

    /// @notice emitted when trades funds are injected
    /// @param amount injected
    event TradesLiquidityInjected(uint256 amount);

    /// @notice emitted when a new value of treasury is set
    /// @param treasury new treasury value
    event TreasurySet(address treasury);

    /// @notice initializing function of Token contract
    /// @param name name of Token
    /// @param symbol symbol of Token
    /// @param admin address of DEFAULT_ADMIN
    /// @param manager address of manager
    /// @param upgrader address of ugprader
    /// @param service address of service responsible for minting, burning, starting new periods,
    /// paying out ETH and setting social root
    /// @param treasury address of treasury
    /// @param tradesWallet address of wallet to receive trades funds
    /// @param refundOperator address of account which can process batch refunds
    /// @param basisPointValues InitializationBasisPointValues struct containing distributionFractionBP, tradesFractionBP,
    /// tokenBackingFractionBP, and protocolFeeBP
    function __Token_init(
        string memory name,
        string memory symbol,
        address admin,
        address manager,
        address upgrader,
        address service,
        address treasury,
        address tradesWallet,
        address refundOperator,
        InitializationBasisPointValues calldata basisPointValues
    ) external;

    /// @notice adds a new game id to gameIds
    /// @param id new game id
    function addGameId(uint256 id) external;

    /// @notice makes an attempt on a game matching gameId on behalf of _msgSender()
    /// @param gameId id of game being attempted
    /// @param attemptId UUID of attempt
    function attempt(
        uint256 gameId,
        string calldata attemptId
    ) external payable;

    /// @notice makes an attempt on a game matching gameId on behalf of _msgSender()
    /// using `Token` as payment
    /// @param gameId id of game being attempted
    /// @param size amount of `Token` used as payment
    /// @param attemptId UUID of attempt
    function attemptWithToken(
        uint256 gameId,
        uint256 size,
        string calldata attemptId
    ) external;

    /// @notice processes a batch refund for a list of accounts and amounts, sending
    /// the amount of ETH corresponding to each account's refund amount
    /// @param refunds array of Refund structs
    function batchRefund(Refund[] calldata refunds) external;

    /// @notice claims all claimable tokens for the _msgSender()
    function claim() external;

    /// @notice sends an amount of ETH as social earnings to _msgSender() from the `earnings`
    /// @param proof merkle proof data to verify against
    /// @param amount total amount earned thus far by _msgSender()
    function claimSocialEarnings(
        bytes32[] calldata proof,
        uint256 amount
    ) external;

    /// @notice Disperses tokens to a list of recipients
    /// @param recipients assumed ordered array of recipient addresses
    /// @param amounts assumed ordered array of token amounts to disperse
    function disperseTokens(
        address[] calldata recipients,
        uint256[] calldata amounts
    ) external;

    /// @notice returns AccrualData struct pertaining to account, which contains Token accrual
    /// information
    /// @param account address of account
    /// @return data AccrualData of account
    function getAccrualData(
        address account
    ) external view returns (AccrualData memory data);

    /// @notice returns value of airdropSupply
    /// @return supply value of airdropSupply
    function getAirdropSupply() external view returns (uint256 supply);

    /// @notice returns all claimable tokens of a given account
    /// @param account address of account
    /// @return amount amount of claimable tokens
    function getClaimableTokens(
        address account
    ) external view returns (uint256 amount);

    /// @notice returns the distributionFractionBP value
    /// @return fractionBP value of distributionFractionBP
    function getDistributionFractionBP()
        external
        view
        returns (uint256 fractionBP);

    /// @notice returns the distribution supply value
    /// @return supply distribution supply value
    function getDistributionSupply() external view returns (uint256 supply);

    /// @notice returns earnings from attempts
    /// @return earnings current earnings
    function getEarnings() external view returns (uint256 earnings);

    /// @notice returns fees earned from attempts
    /// @return fees current fees accrued from mint attempts
    function getFees() external view returns (uint256 fees);

    /// @notice returns the trades fraction in basis points
    /// @return fractionBP value of trades fraction in basis points
    function getTradesFractionBP() external view returns (uint256 fractionBP);

    /// @notice returns the trades fund value
    /// @return fund value of trades fund
    function getTradesFund() external view returns (uint256 fund);

    /// @notice returns the trades wallet address
    /// @return wallet address of trades wallet
    function getTradesWallet() external view returns (address wallet);

    /// @notice returns game ids of games which can be played
    /// @return ids array of game ids which can be played
    function getGameIds() external view returns (uint256[] memory ids);

    /// @notice returns the global ratio value
    /// @return ratio global ratio value
    function getGlobalRatio() external view returns (uint256 ratio);

    /// @notice returns the period earnings value
    /// @return earnings current value of period earnings
    function getPeriodEarnings() external view returns (uint256 earnings);

    /// @notice returns value of protocol fee in basis points
    /// @return protocolFeeBP value of protocol fee in basis points
    function getProtocolFeeBP() external view returns (uint256 protocolFeeBP);

    /// @notice returns value of repayment fraction in basis points
    /// @return fractionBP value of repayment fraction in basis points
    function getRepaymentFractionBP()
        external
        view
        returns (uint256 fractionBP);

    /// @notice returns ETH currently in repayment fund
    /// @return fund ETH in repayment fund
    function getRepaymentFund() external view returns (uint256 fund);

    /// @notice returns the social earnings deduction of an account
    /// @param account address of account to get deductions for
    /// @return deduction social earnings deduction of account
    function getSocialEarningsDeduction(
        address account
    ) external view returns (uint256 deduction);

    /// @notice retruns value of socialRoot
    /// @return root value of socialRoot
    function getSocialRoot() external view returns (bytes32 root);

    /// @notice returns value of tokenBackingFractionBP
    /// @return fractionBP value of tokenBackingFractionBP
    function getTokenBackingFractionBP()
        external
        view
        returns (uint256 fractionBP);

    /// @notice returns value of tokenBackingFund
    /// @return fund value of tokenBackingFund
    function getTokenBackingFund() external view returns (uint256 fund);

    /// @notice returns address of treasury
    /// @return treasury address of treasury
    function getTreasury() external view returns (address treasury);

    /// @notice injects liquidity into the repayment fund
    function injectRepaymentLiquidity() external payable;

    /// @notice injects liquidity into the token backing fund
    function injectTokenBackingLiquidity() external payable;

    /// @notice injects liquidity into the trades fund
    function injectTradesLiquidity() external payable;

    /// @notice mint an amount of tokens to an account
    /// @param account address of account receive the tokens
    /// @param amount amount of tokens to mint
    function mint(address account, uint256 amount) external;

    /// @notice mints an amount of tokens intended for airdrop
    /// @param amount airdrop token amount
    function mintAirdrop(uint256 amount) external payable;

    /// @notice pauses minting
    function pause() external;

    /// @notice reallocates funds from one fund to another
    /// @param from Fund to debit
    /// @param to Fund to credit
    /// @param amount Amount to reallocate
    function reallocateFunds(Fund from, Fund to, uint256 amount) external;

    /// @notice sets a new value for distributionFractionBP
    /// @param distributionFractionBP new distributionFractionBP value
    function setDistributionFractionBP(uint256 distributionFractionBP) external;

    /// @notice sets a new value for repaymentFractionBP
    /// @param repaymentFractionBP new repaymentFractionBP value
    function setRepaymentFractionBP(uint256 repaymentFractionBP) external;

    /// @notice sets a new value for tradesFractionBP
    /// @param tradesFractionBP new tradesFractionBP value
    function setTradesFractionBP(uint256 tradesFractionBP) external;

    /// @notice sets a new value for tradesWallet
    /// @param tradesWallet new tradesWallet value
    function setTradesWallet(address tradesWallet) external;

    /// @notice sets a new value for protocolFeeBP
    /// @param protocolFeeBP new protocolFeeBP value
    function setProtocolFeeBP(uint256 protocolFeeBP) external;

    /// @notice begins a new period for earnings
    /// @return currentEarnings returns current value of earnings for given period
    function startNewPeriod() external returns (uint256 currentEarnings);

    /// @notice  sets a new value for the socialRoot
    /// @param root new socialRoot value
    function setSocialRoot(bytes32 root) external;

    /// @notice sets a new value for tokenBackingFractionBP
    /// @param tokenBackingFractionBP new tokenBackingFractionBP value
    function setTokenBackingFractionBP(uint256 tokenBackingFractionBP) external;

    /// @notice sets a new value for treasury
    /// @param treasury new treasury value
    function setTreasury(address treasury) external;

    /// @notice unpauses minting
    function unpause() external;

    /// @notice withdraws an amount of ETH from earnings and sends to treasury
    /// @param amount withdrawal amount
    function withdrawEarnings(uint256 amount) external;

    /// @notice withdraws fees and sends to treasury
    function withdrawFees() external;

    /// @notice withdraws an amount of token backing liquidity and sends to treasury
    /// @param amount withdrawal amount
    function withdrawTokenBackingLiquidity(uint256 amount) external;

    /// @notice withdraws an amount of trades funds and sends to trades wallet
    /// @param amount withdrawal amount
    function withdrawTradesWalletFunds(uint256 amount) external;
}

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.26;

import { AccrualData } from "./Types.sol";
import { EnumerableSet } from "@oz/utils/structs/EnumerableSet.sol";

/// @title TokenStorage
/// @dev defines storage layout for the Token facet
library TokenStorage {
    struct Layout {
        /// @dev ratio of distributionSupply to totalSupply
        uint256 globalRatio;
        /// @dev number of tokens held for distribution to token holders
        uint256 distributionSupply;
        /// @dev number of tokens held for airdrop dispersion
        uint256 airdropSupply;
        /// @dev fraction of tokens to be reserved for distribution to token holders in basis points
        uint256 distributionFractionBP;
        /// @dev fraction of attempt value going to trades fund in basis points
        uint256 tradesFractionBP;
        /// @dev fraction of attempt value going to token backing fund in basis points
        uint256 tokenBackingFractionBP;
        /// @dev fraction of mint attempt value as fees for protocol in basis points
        uint256 protocolFeeBP;
        /// @dev earnigns in current period
        uint256 periodEarnings;
        /// @dev currently held ETH earnings from mint attempts
        uint256 earnings;
        /// @dev currently held ETH accumulated from fees on mint attempts
        uint256 fees;
        /// @dev currently held ETH in trades fund
        uint256 tradesFund;
        /// @dev currently held ETH in token backing fund
        uint256 tokenBackingFund;
        /// @dev root of merkleTree responsible for accounting for earnings due to social activity
        bytes32 socialRoot;
        /// @dev address to send fees to
        address treasury;
        /// @dev address to send trade funds to
        address tradesWallet;
        /// @dev information related to Token accruals for an account
        mapping(address account => AccrualData data) accrualData;
        /// @dev deduction on social earnings for an account
        mapping(address account => uint256 deduction) socialEarningsDeduction;
        /// @dev set of game ids currently active
        EnumerableSet.UintSet gameIds;
        /// @dev fraction of mint attempt value going to repayment fund in basis points
        uint256 repaymentFractionBP;
        /// @dev currently held ETH in repayment fund
        uint256 repaymentFund;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256("insrt.contracts.v3.storage.MintToken");

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

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.8.26;

/// @dev Types.sol defines the Token struct data types used in the TokenStorage layout

/// @dev represents data related to $MINT token accruals (linked to a specific account)
struct AccrualData {
    /// @dev last ratio an account had when one of their actions led to a change in the
    /// distributionSupply
    uint256 offset;
    /// @dev amount of tokens accrued as a result of distribution to token holders
    uint256 accruedTokens;
}

/// @dev struct representing the basis point values used to initialize the Token
/// and get around stack too deep
struct InitializationBasisPointValues {
    /// @dev fraction of attempt value going to distribution fund in basis points
    uint256 distributionFractionBP;
    /// @dev fraction of attempt value going to trades fund in basis points
    uint256 tradesFractionBP;
    /// @dev fraction of attempt value going to token backing fund in basis points
    uint256 tokenBackingFractionBP;
    /// @dev fraction of mint attempt value as fees for protocol in basis points
    uint256 protocolFeeBP;
    /// @dev fraction of mint attempt value going to repayment fund in basis points
    uint256 repaymentFractionBP;
}

/// @dev struct representing an account and amount to be refunded
struct Refund {
    /// @dev account that is being refunded
    address account;
    /// @dev amount being refunded
    uint256 amount;
}

/// @dev enum representing the different funds in the Token
enum Fund {
    /// @dev fees fund
    FEES,
    /// @dev earnings fund
    EARNINGS,
    /// @dev trades fund
    TRADES,
    /// @dev token backing fund
    TOKEN_BACKING,
    /// @dev repayment fund
    REPAYMENT
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();

    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();

    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library of standard hash functions.
 */
library Hashes {
    /**
     * @dev Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when working with merkle proofs.
     *
     * NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
     */
    function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) {
        return a < b ? _efficientKeccak256(a, b) : _efficientKeccak256(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientKeccak256(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly ("memory-safe") {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/**
 * @dev Helper library for emitting standardized panic codes.
 *
 * ```solidity
 * contract Example {
 *      using Panic for uint256;
 *
 *      // Use any of the declared internal constants
 *      function foo() { Panic.GENERIC.panic(); }
 *
 *      // Alternatively
 *      function foo() { Panic.panic(Panic.GENERIC); }
 * }
 * ```
 *
 * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
 */
// slither-disable-next-line unused-state
library Panic {
    /// @dev generic / unspecified error
    uint256 internal constant GENERIC = 0x00;
    /// @dev used by the assert() builtin
    uint256 internal constant ASSERT = 0x01;
    /// @dev arithmetic underflow or overflow
    uint256 internal constant UNDER_OVERFLOW = 0x11;
    /// @dev division or modulo by zero
    uint256 internal constant DIVISION_BY_ZERO = 0x12;
    /// @dev enum conversion error
    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    /// @dev invalid encoding in storage
    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    /// @dev empty array pop
    uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    /// @dev array out of bounds access
    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    /// @dev resource error (too large allocation or too large array)
    uint256 internal constant RESOURCE_ERROR = 0x41;
    /// @dev calling invalid internal function
    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;

    /// @dev Reverts with a panic code. Recommended to use with
    /// the internal constants with predefined codes.
    function panic(uint256 code) internal pure {
        assembly ("memory-safe") {
            mstore(0x00, 0x4e487b71)
            mstore(0x20, code)
            revert(0x1c, 0x24)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.20;

/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }

    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC-165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165Upgradeable is Initializable, IERC165 {
    function __ERC165_init() internal onlyInitializing {
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.20;

/**
 * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)

pragma solidity ^0.8.21;

import {IBeacon} from "../beacon/IBeacon.sol";
import {IERC1967} from "../../interfaces/IERC1967.sol";
import {Address} from "../../utils/Address.sol";
import {StorageSlot} from "../../utils/StorageSlot.sol";

/**
 * @dev This library provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.
 */
library ERC1967Utils {
    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev The `implementation` of the proxy is invalid.
     */
    error ERC1967InvalidImplementation(address implementation);

    /**
     * @dev The `admin` of the proxy is invalid.
     */
    error ERC1967InvalidAdmin(address admin);

    /**
     * @dev The `beacon` of the proxy is invalid.
     */
    error ERC1967InvalidBeacon(address beacon);

    /**
     * @dev An upgrade function sees `msg.value > 0` that may be lost.
     */
    error ERC1967NonPayable();

    /**
     * @dev Returns the current implementation address.
     */
    function getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the ERC-1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        if (newImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(newImplementation);
        }
        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Performs implementation upgrade with additional setup call if data is nonempty.
     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
     * to avoid stuck value in the contract.
     *
     * Emits an {IERC1967-Upgraded} event.
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) internal {
        _setImplementation(newImplementation);
        emit IERC1967.Upgraded(newImplementation);

        if (data.length > 0) {
            Address.functionDelegateCall(newImplementation, data);
        } else {
            _checkNonPayable();
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using
     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
     */
    function getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the ERC-1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        if (newAdmin == address(0)) {
            revert ERC1967InvalidAdmin(address(0));
        }
        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {IERC1967-AdminChanged} event.
     */
    function changeAdmin(address newAdmin) internal {
        emit IERC1967.AdminChanged(getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the ERC-1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        if (newBeacon.code.length == 0) {
            revert ERC1967InvalidBeacon(newBeacon);
        }

        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;

        address beaconImplementation = IBeacon(newBeacon).implementation();
        if (beaconImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(beaconImplementation);
        }
    }

    /**
     * @dev Change the beacon and trigger a setup call if data is nonempty.
     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
     * to avoid stuck value in the contract.
     *
     * Emits an {IERC1967-BeaconUpgraded} event.
     *
     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since
     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for
     * efficiency.
     */
    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
        _setBeacon(newBeacon);
        emit IERC1967.BeaconUpgraded(newBeacon);

        if (data.length > 0) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        } else {
            _checkNonPayable();
        }
    }

    /**
     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract
     * if an upgrade doesn't perform an initialization call.
     */
    function _checkNonPayable() private {
        if (msg.value > 0) {
            revert ERC1967NonPayable();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {UpgradeableBeacon} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.20;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.24;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC-1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * Since version 5.1, this library also support writing and reading value types to and from transient storage.
 *
 *  * Example using transient storage:
 * ```solidity
 * contract Lock {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _LOCK_SLOT = 0xf4678858b2b588224636b8522b729e7722d32fc491da849ed75b3fdf3c84f542;
 *
 *     modifier locked() {
 *         require(!_LOCK_SLOT.asBoolean().tload());
 *
 *         _LOCK_SLOT.asBoolean().tstore(true);
 *         _;
 *         _LOCK_SLOT.asBoolean().tstore(false);
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {SlotDerivation}.
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Int256Slot` with member `value` located at `slot`.
     */
    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns a `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev UDVT that represent a slot holding a address.
     */
    type AddressSlotType is bytes32;

    /**
     * @dev Cast an arbitrary slot to a AddressSlotType.
     */
    function asAddress(bytes32 slot) internal pure returns (AddressSlotType) {
        return AddressSlotType.wrap(slot);
    }

    /**
     * @dev UDVT that represent a slot holding a bool.
     */
    type BooleanSlotType is bytes32;

    /**
     * @dev Cast an arbitrary slot to a BooleanSlotType.
     */
    function asBoolean(bytes32 slot) internal pure returns (BooleanSlotType) {
        return BooleanSlotType.wrap(slot);
    }

    /**
     * @dev UDVT that represent a slot holding a bytes32.
     */
    type Bytes32SlotType is bytes32;

    /**
     * @dev Cast an arbitrary slot to a Bytes32SlotType.
     */
    function asBytes32(bytes32 slot) internal pure returns (Bytes32SlotType) {
        return Bytes32SlotType.wrap(slot);
    }

    /**
     * @dev UDVT that represent a slot holding a uint256.
     */
    type Uint256SlotType is bytes32;

    /**
     * @dev Cast an arbitrary slot to a Uint256SlotType.
     */
    function asUint256(bytes32 slot) internal pure returns (Uint256SlotType) {
        return Uint256SlotType.wrap(slot);
    }

    /**
     * @dev UDVT that represent a slot holding a int256.
     */
    type Int256SlotType is bytes32;

    /**
     * @dev Cast an arbitrary slot to a Int256SlotType.
     */
    function asInt256(bytes32 slot) internal pure returns (Int256SlotType) {
        return Int256SlotType.wrap(slot);
    }

    /**
     * @dev Load the value held at location `slot` in transient storage.
     */
    function tload(AddressSlotType slot) internal view returns (address value) {
        assembly ("memory-safe") {
            value := tload(slot)
        }
    }

    /**
     * @dev Store `value` at location `slot` in transient storage.
     */
    function tstore(AddressSlotType slot, address value) internal {
        assembly ("memory-safe") {
            tstore(slot, value)
        }
    }

    /**
     * @dev Load the value held at location `slot` in transient storage.
     */
    function tload(BooleanSlotType slot) internal view returns (bool value) {
        assembly ("memory-safe") {
            value := tload(slot)
        }
    }

    /**
     * @dev Store `value` at location `slot` in transient storage.
     */
    function tstore(BooleanSlotType slot, bool value) internal {
        assembly ("memory-safe") {
            tstore(slot, value)
        }
    }

    /**
     * @dev Load the value held at location `slot` in transient storage.
     */
    function tload(Bytes32SlotType slot) internal view returns (bytes32 value) {
        assembly ("memory-safe") {
            value := tload(slot)
        }
    }

    /**
     * @dev Store `value` at location `slot` in transient storage.
     */
    function tstore(Bytes32SlotType slot, bytes32 value) internal {
        assembly ("memory-safe") {
            tstore(slot, value)
        }
    }

    /**
     * @dev Load the value held at location `slot` in transient storage.
     */
    function tload(Uint256SlotType slot) internal view returns (uint256 value) {
        assembly ("memory-safe") {
            value := tload(slot)
        }
    }

    /**
     * @dev Store `value` at location `slot` in transient storage.
     */
    function tstore(Uint256SlotType slot, uint256 value) internal {
        assembly ("memory-safe") {
            tstore(slot, value)
        }
    }

    /**
     * @dev Load the value held at location `slot` in transient storage.
     */
    function tload(Int256SlotType slot) internal view returns (int256 value) {
        assembly ("memory-safe") {
            value := tload(slot)
        }
    }

    /**
     * @dev Store `value` at location `slot` in transient storage.
     */
    function tstore(Int256SlotType slot, int256 value) internal {
        assembly ("memory-safe") {
            tstore(slot, value)
        }
    }
}

{
  "viaIR": false,
  "codegen": "yul",
  "remappings": [
    "@forge-std/=lib/forge-std/src/",
    "@oz/=lib/openzeppelin-contracts/contracts/",
    "@oz-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "evmVersion": "cancun",
  "outputSelection": {
    "*": {
      "*": [
        "abi",
        "metadata"
      ],
      "": [
        "ast"
      ]
    }
  },
  "optimizer": {
    "enabled": true,
    "mode": "3",
    "fallback_to_optimizing_for_size": false,
    "disable_system_request_memoization": true
  },
  "metadata": {},
  "libraries": {},
  "enableEraVMExtensions": false,
  "forceEVMLA": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[],"name":"ArrayLengthMismatch","type":"error"},{"inputs":[],"name":"BasisExceeded","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"FractionSumExceedsBasis","type":"error"},{"inputs":[],"name":"FundSelfTransfer","type":"error"},{"inputs":[],"name":"IncorrectETHReceived","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InsufficientEarnings","type":"error"},{"inputs":[],"name":"InsufficientRepaymentFund","type":"error"},{"inputs":[],"name":"InsufficientTokenBacking","type":"error"},{"inputs":[],"name":"InvalidFund","type":"error"},{"inputs":[],"name":"InvalidGameId","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"NonTransferable","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"TokenBackingFundTooLow","type":"error"},{"inputs":[],"name":"TradesFundTooLow","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmountAttempt","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AirdropMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"string","name":"attemptId","type":"string"}],"name":"AttemptMade","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountValue","type":"uint256"},{"indexed":false,"internalType":"string","name":"attemptId","type":"string"}],"name":"AttemptWithTokenMade","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"indexed":false,"internalType":"struct Refund[]","name":"refunds","type":"tuple[]"}],"name":"BatchRefundProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"distributionFractionBP","type":"uint256"}],"name":"DistributionFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EarningsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fees","type":"uint256"}],"name":"FeesWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"enum Fund","name":"from","type":"uint8"},{"indexed":false,"internalType":"enum Fund","name":"to","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FundsReallocated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gameId","type":"uint256"}],"name":"GameIdAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MinterRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"currentEarnings","type":"uint256"}],"name":"NewPeriodStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"protocolFeeBP","type":"uint256"}],"name":"ProtocolFeeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"repaymentFractionBP","type":"uint256"}],"name":"RepaymentFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RepaymentLiquidityInjected","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SocialEarningsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"SocialRootSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fractionBP","type":"uint256"}],"name":"TokenBackingFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenBackingLiquidityInjected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenBackingLiquidityWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tradesFractionBP","type":"uint256"}],"name":"TradesFractionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TradesLiquidityInjected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TradesWalletFunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"wallet","type":"address"}],"name":"TradesWalletSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasury","type":"address"}],"name":"TreasurySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"BASIS","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MANAGER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REFUND_OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SCALE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SERVICE_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_TO_ETH_RATIO","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"manager","type":"address"},{"internalType":"address","name":"upgrader","type":"address"},{"internalType":"address","name":"service","type":"address"},{"internalType":"address","name":"treasury","type":"address"},{"internalType":"address","name":"tradesWallet","type":"address"},{"internalType":"address","name":"refundOperator","type":"address"},{"components":[{"internalType":"uint256","name":"distributionFractionBP","type":"uint256"},{"internalType":"uint256","name":"tradesFractionBP","type":"uint256"},{"internalType":"uint256","name":"tokenBackingFractionBP","type":"uint256"},{"internalType":"uint256","name":"protocolFeeBP","type":"uint256"},{"internalType":"uint256","name":"repaymentFractionBP","type":"uint256"}],"internalType":"struct InitializationBasisPointValues","name":"basisPointValues","type":"tuple"}],"name":"__Token_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"addGameId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"gameId","type":"uint256"},{"internalType":"string","name":"attemptId","type":"string"}],"name":"attempt","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"gameId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"attemptId","type":"string"}],"name":"attemptWithToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct Refund[]","name":"refunds","type":"tuple[]"}],"name":"batchRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimSocialEarnings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"disperseTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAccrualData","outputs":[{"components":[{"internalType":"uint256","name":"offset","type":"uint256"},{"internalType":"uint256","name":"accruedTokens","type":"uint256"}],"internalType":"struct AccrualData","name":"data","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAirdropSupply","outputs":[{"internalType":"uint256","name":"supply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getClaimableTokens","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistributionFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistributionSupply","outputs":[{"internalType":"uint256","name":"supply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEarnings","outputs":[{"internalType":"uint256","name":"earnings","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFees","outputs":[{"internalType":"uint256","name":"fees","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGameIds","outputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGlobalRatio","outputs":[{"internalType":"uint256","name":"ratio","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPeriodEarnings","outputs":[{"internalType":"uint256","name":"earnings","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProtocolFeeBP","outputs":[{"internalType":"uint256","name":"protocolFeeBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRepaymentFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRepaymentFund","outputs":[{"internalType":"uint256","name":"fund","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getSocialEarningsDeduction","outputs":[{"internalType":"uint256","name":"deduction","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSocialRoot","outputs":[{"internalType":"bytes32","name":"root","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenBackingFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenBackingFund","outputs":[{"internalType":"uint256","name":"fund","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradesFractionBP","outputs":[{"internalType":"uint256","name":"fractionBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradesFund","outputs":[{"internalType":"uint256","name":"fund","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTradesWallet","outputs":[{"internalType":"address","name":"wallet","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTreasury","outputs":[{"internalType":"address","name":"treasury","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"injectRepaymentLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"injectTokenBackingLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"injectTradesLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintAirdrop","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum Fund","name":"from","type":"uint8"},{"internalType":"enum Fund","name":"to","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"reallocateFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"distributionFractionBP","type":"uint256"}],"name":"setDistributionFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"protocolFeeBP","type":"uint256"}],"name":"setProtocolFeeBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"repaymentFractionBP","type":"uint256"}],"name":"setRepaymentFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"setSocialRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenBackingFractionBP","type":"uint256"}],"name":"setTokenBackingFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tradesFractionBP","type":"uint256"}],"name":"setTradesFractionBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tradesWallet","type":"address"}],"name":"setTradesWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startNewPeriod","outputs":[{"internalType":"uint256","name":"currentEarnings","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEarnings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTokenBackingLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTradesWalletFunds","outputs":[],"stateMutability":"nonpayable","type":"function"}]

9c4d535b00000000000000000000000000000000000000000000000000000000000000000100079dc32bf7717ac0087ed5d68351ddc982709282d58f037be91e0fed6f8400000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000

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