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, InitializationBasisPointValues } 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");

    // 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,
        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);

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

    /// @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 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 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 {
        Storage.Layout storage $ = Storage.layout();
        if ($.distributionFractionBP == 0) {
            revert DistributionFractionNotSet();
        }
        // 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 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 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 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 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 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 tradesFractionBP
    /// @param tradesFractionBP new tradesFractionBP value
    function _setTradesFractionBP(uint256 tradesFractionBP) internal {
        _enforceBasis(tradesFractionBP, BASIS);
        Storage.Layout storage $ = Storage.layout();

        if (
            $.tokenBackingFractionBP + $.protocolFeeBP + tradesFractionBP >
            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 > 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 + 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();
        }
    }

    /// @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, InitializationBasisPointValues } from "./Types.sol";
/// @title IToken
/// @dev interface for Token contract containing all events, errors, and external/public functions

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

    /// @notice thrown when attempting to mint but distribution fraction has not been set or is zero
    error DistributionFractionNotSet();

    /// @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 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 a mint attempt with Token but there is insufficient token backing
    /// to cover the attempt
    error InsufficientTokenBacking();

    /// @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 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 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 a new gameId is added to gameIds
    /// @param gameId id of new game
    event GameIdAdded(uint256 gameId);

    /// @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 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 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,
        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 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 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 trades fund
    function injectTradesLiquidity() external payable;

    /// @notice injects liquidity into the token backing fund
    function injectTokenBackingLiquidity() 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 sets a new value for distributionFractionBP
    /// @param distributionFractionBP new distributionFractionBP value
    function setDistributionFractionBP(uint256 distributionFractionBP) 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 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;
    }

    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;
}

// 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":"BasisExceeded","type":"error"},{"inputs":[],"name":"DistributionFractionNotSet","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":"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":"InsufficientTokenBacking","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":"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":[{"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":"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":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":"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":"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"},{"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":"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":[],"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":[{"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":"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":"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":"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":"withdrawTradesWalletFunds","outputs":[],"stateMutability":"nonpayable","type":"function"}]

9c4d535b0000000000000000000000000000000000000000000000000000000000000000010006e55cb5973bc2db5dcc4bdd3d5164bbbd3f91177a56de078357ae92e53400000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000

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